Datasets:
CIRCL
/
vulnerability-cwe-patch

Dataset card Data Studio Files
xet
Community
1
id
stringlengths
12
19
title
stringlengths
0
237
description
stringlengths
35
3.87k
⌀
patches
listlengths
1
22
cwe
stringlengths
2
440
⌀
CVE-2012-6547
The __tun_chr_ioctl function in drivers/net/tun.c in the Linux kernel before 3.6 does not initialize a certain structure, which allows local users to obtain sensitive information from kernel stack memory via a crafted application.
[ { "commit_message": "[PATCH] net/tun: fix ioctl() based info leaks The tun module leaks up to 36 bytes of memory by not fully initializing a structure located on the stack that gets copied to user memory by the TUNGETIFF and SIOCGIFHWADDR ioctl()s. Signed-off-by: Mathias Krause <minipli@googlemail.com> Signed-off-by: David S. Miller <davem@davemloft.net> drivers/net/tun.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSBhMTE3ZGFjZGUwMjg4ZjNlYzYwYjZlNWJjZWRhZThmYTM3ZWUwZGZjIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXRoaWFzIEtyYXVzZSA8bWluaXBsaUBnb29nbGVtYWlsLmNvbT4KRGF0ZTogU3VuLCAyOSBKdWwgMjAxMiAxOTo0NToxNCArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIG5ldC90dW46IGZpeCBpb2N0bCgpIGJhc2VkIGluZm8gbGVha3MKClRoZSB0dW4gbW9kdWxlIGxlYWtzIHVwIHRvIDM2IGJ5dGVzIG9mIG1lbW9yeSBieSBub3QgZnVsbHkgaW5pdGlhbGl6aW5nCmEgc3RydWN0dXJlIGxvY2F0ZWQgb24gdGhlIHN0YWNrIHRoYXQgZ2V0cyBjb3BpZWQgdG8gdXNlciBtZW1vcnkgYnkgdGhlClRVTkdFVElGRiBhbmQgU0lPQ0dJRkhXQUREUiBpb2N0bCgpcy4KClNpZ25lZC1vZmYtYnk6IE1hdGhpYXMgS3JhdXNlIDxtaW5pcGxpQGdvb2dsZW1haWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBTLiBNaWxsZXIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0tLQogZHJpdmVycy9uZXQvdHVuLmMgfCA0ICsrKy0KIDEgZmlsZSBjaGFuZ2VkLCAzIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC90dW4uYyBiL2RyaXZlcnMvbmV0L3R1bi5jCmluZGV4IGM2MjE2M2UyNzJjZDg1Li5mNTVjNDYyMjI2MTNmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdHVuLmMKKysrIGIvZHJpdmVycy9uZXQvdHVuLmMKQEAgLTEzNzksOSArMTM3OSwxMSBAQCBzdGF0aWMgbG9uZyBfX3R1bl9jaHJfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWQsCiAJaW50IHZuZXRfaGRyX3N6OwogCWludCByZXQ7CiAKLQlpZiAoY21kID09IFRVTlNFVElGRiB8fCBfSU9DX1RZUEUoY21kKSA9PSAweDg5KQorCWlmIChjbWQgPT0gVFVOU0VUSUZGIHx8IF9JT0NfVFlQRShjbWQpID09IDB4ODkpIHsKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZpZnIsIGFyZ3AsIGlmcmVxX2xlbikpCiAJCQlyZXR1cm4gLUVGQVVMVDsKKwl9IGVsc2UKKwkJbWVtc2V0KCZpZnIsIDAsIHNpemVvZihpZnIpKTsKIAogCWlmIChjbWQgPT0gVFVOR0VURkVBVFVSRVMpIHsKIAkJLyogQ3VycmVudGx5IHRoaXMganVzdCBtZWFuczogIndoYXQgSUZGIGZsYWdzIGFyZSB2YWxpZD8iLg==", "url": "https://github.com/torvalds/linux/commit/a117dacde0288f3ec60b6e5bcedae8fa37ee0dfc.patch" } ]
n/a
GHSA-28jp-44vh-q42h
Duplicate Advisory: Keras keras.utils.get_file API is vulnerable to a path traversal attack
null
[ { "commit_message": "[PATCH] Use `filter=\"data\"` option of `TarFile.extractall`. (#21760) For Python versions between 3.12 (inclusive) and 3.14 (exclusive). The \"data\" filter performs a number of additional checks on links and paths. The `filter` option was added in Python 3.12. The `filter=\"data\"` option became the default in Python 3.14. Also: - added similar path filtering when extracting zip archives - shared the extraction code between `file_utils` and `saving_lib` keras/src/saving/saving_lib.py | 2 +- keras/src/utils/file_utils.py | 60 ++++++++++++++++++++++++------ keras/src/utils/file_utils_test.py | 8 ++-- 3 files changed, 54 insertions(+), 16 deletions(-)", "patch_text_b64": "From 47fcb397ee4caffd5a75efd1fa3067559594e951 Mon Sep 17 00:00:00 2001
From: hertschuh <1091026+hertschuh@users.noreply.github.com>
Date: Mon, 20 Oct 2025 22:42:17 -0700
Subject: [PATCH] Use `filter="data"` option of `TarFile.extractall`. (#21760)

For Python versions between 3.12 (inclusive) and 3.14 (exclusive).

The "data" filter performs a number of additional checks on links and paths. The `filter` option was added in Python 3.12. The `filter="data"` option became the default in Python 3.14.

Also:
- added similar path filtering when extracting zip archives
- shared the extraction code between `file_utils` and `saving_lib`
---
 keras/src/saving/saving_lib.py     |  2 +-
 keras/src/utils/file_utils.py      | 60 ++++++++++++++++++++++++------
 keras/src/utils/file_utils_test.py |  8 ++--
 3 files changed, 54 insertions(+), 16 deletions(-)

diff --git a/keras/src/saving/saving_lib.py b/keras/src/saving/saving_lib.py
index c2d7b69d9f2e..55e9db485ba0 100644
--- a/keras/src/saving/saving_lib.py
+++ b/keras/src/saving/saving_lib.py
@@ -943,7 +943,7 @@ def __init__(self, root_path, archive=None, mode=None):
         if self.archive:
             self.tmp_dir = get_temp_dir()
             if self.mode == "r":
-                self.archive.extractall(path=self.tmp_dir)
+                file_utils.extract_open_archive(self.archive, self.tmp_dir)
             self.working_dir = file_utils.join(
                 self.tmp_dir, self.root_path
             ).replace("\\", "/")
diff --git a/keras/src/utils/file_utils.py b/keras/src/utils/file_utils.py
index 55d0a8d7b76e..161ca3cf7dc7 100644
--- a/keras/src/utils/file_utils.py
+++ b/keras/src/utils/file_utils.py
@@ -2,6 +2,7 @@
 import os
 import re
 import shutil
+import sys
 import tarfile
 import tempfile
 import urllib
@@ -52,17 +53,32 @@ def is_link_in_dir(info, base):
     return is_path_in_dir(info.linkname, base_dir=tip)
 
 
-def filter_safe_paths(members):
+def filter_safe_zipinfos(members):
     base_dir = resolve_path(".")
     for finfo in members:
         valid_path = False
-        if is_path_in_dir(finfo.name, base_dir):
+        if is_path_in_dir(finfo.filename, base_dir):
             valid_path = True
             yield finfo
-        elif finfo.issym() or finfo.islnk():
+        if not valid_path:
+            warnings.warn(
+                "Skipping invalid path during archive extraction: "
+                f"'{finfo.name}'.",
+                stacklevel=2,
+            )
+
+
+def filter_safe_tarinfos(members):
+    base_dir = resolve_path(".")
+    for finfo in members:
+        valid_path = False
+        if finfo.issym() or finfo.islnk():
             if is_link_in_dir(finfo, base_dir):
                 valid_path = True
                 yield finfo
+        elif is_path_in_dir(finfo.name, base_dir):
+            valid_path = True
+            yield finfo
         if not valid_path:
             warnings.warn(
                 "Skipping invalid path during archive extraction: "
@@ -71,6 +87,35 @@ def filter_safe_paths(members):
             )
 
 
+def extract_open_archive(archive, path="."):
+    """Extracts an open tar or zip archive to the provided directory.
+
+    This function filters unsafe paths during extraction.
+
+    Args:
+        archive: The archive object, either a `TarFile` or a `ZipFile`.
+        path: Where to extract the archive file.
+    """
+    if isinstance(archive, zipfile.ZipFile):
+        # Zip archive.
+        archive.extractall(
+            path, members=filter_safe_zipinfos(archive.infolist())
+        )
+    else:
+        # Tar archive.
+        extractall_kwargs = {}
+        # The `filter="data"` option was added in Python 3.12. It became the
+        # default starting from Python 3.14. So we only specify it between
+        # those two versions.
+        if sys.version_info >= (3, 12) and sys.version_info < (3, 14):
+            extractall_kwargs = {"filter": "data"}
+        archive.extractall(
+            path,
+            members=filter_safe_tarinfos(archive),
+            **extractall_kwargs,
+        )
+
+
 def extract_archive(file_path, path=".", archive_format="auto"):
     """Extracts an archive if it matches a support format.
 
@@ -112,14 +157,7 @@ def extract_archive(file_path, path=".", archive_format="auto"):
         if is_match_fn(file_path):
             with open_fn(file_path) as archive:
                 try:
-                    if zipfile.is_zipfile(file_path):
-                        # Zip archive.
-                        archive.extractall(path)
-                    else:
-                        # Tar archive, perhaps unsafe. Filter paths.
-                        archive.extractall(
-                            path, members=filter_safe_paths(archive)
-                        )
+                    extract_open_archive(archive, path)
                 except (tarfile.TarError, RuntimeError, KeyboardInterrupt):
                     if os.path.exists(path):
                         if os.path.isfile(path):
diff --git a/keras/src/utils/file_utils_test.py b/keras/src/utils/file_utils_test.py
index da99ed627576..146fa333f64a 100644
--- a/keras/src/utils/file_utils_test.py
+++ b/keras/src/utils/file_utils_test.py
@@ -142,7 +142,7 @@ def test_member_within_base_dir(self):
         with tarfile.open(self.tar_path, "w") as tar:
             tar.add(__file__, arcname="safe_path.txt")
         with tarfile.open(self.tar_path, "r") as tar:
-            members = list(file_utils.filter_safe_paths(tar.getmembers()))
+            members = list(file_utils.filter_safe_tarinfos(tar.getmembers()))
             self.assertEqual(len(members), 1)
             self.assertEqual(members[0].name, "safe_path.txt")
 
@@ -156,7 +156,7 @@ def test_symlink_within_base_dir(self):
         with tarfile.open(self.tar_path, "w") as tar:
             tar.add(symlink_path, arcname="symlink.txt")
         with tarfile.open(self.tar_path, "r") as tar:
-            members = list(file_utils.filter_safe_paths(tar.getmembers()))
+            members = list(file_utils.filter_safe_tarinfos(tar.getmembers()))
             self.assertEqual(len(members), 1)
             self.assertEqual(members[0].name, "symlink.txt")
         os.remove(symlink_path)
@@ -173,7 +173,7 @@ def test_invalid_path_warning(self):
             )  # Path intended to be outside of base dir
         with tarfile.open(self.tar_path, "r") as tar:
             with patch("warnings.warn") as mock_warn:
-                _ = list(file_utils.filter_safe_paths(tar.getmembers()))
+                _ = list(file_utils.filter_safe_tarinfos(tar.getmembers()))
                 warning_msg = (
                     "Skipping invalid path during archive extraction: "
                     "'../../invalid.txt'."
@@ -196,7 +196,7 @@ def test_symbolic_link_in_base_dir(self):
             tar.add(symlink_path, arcname="symlink.txt")
 
         with tarfile.open(self.tar_path, "r") as tar:
-            members = list(file_utils.filter_safe_paths(tar.getmembers()))
+            members = list(file_utils.filter_safe_tarinfos(tar.getmembers()))
             self.assertEqual(len(members), 1)
             self.assertEqual(members[0].name, "symlink.txt")
             self.assertTrue(", "url": "https://github.com/keras-team/keras/commit/47fcb397ee4caffd5a75efd1fa3067559594e951.patch" } ]
null
GHSA-379q-355j-w6rj
pnpm v10+ Bypass "Dependency lifecycle scripts execution disabled by default"
null
[ { "commit_message": "[PATCH] feat: support blockExoticSubdeps option to disallow non-trusted dep sources in subdeps (#10265) * feat(core): add onlyRegistryDependencies option to disallow non-registry subdependencies * fix: onlyRegistryDependencies=>registrySubdepsOnly * fix: allow resolution from custom resolver * fix: add registry-subdeps-only to types * docs: update changesets * refactor: registry-only * refactor: registrySubdepsOnly=>blockExoticSubdeps * fix: trust runtime deps * refactor: remove comment Co-authored-by: Zoltan Kochan <z@kochan.io> .changeset/better-parents-tell.md | 16 ++++++ config/config/src/Config.ts | 1 + config/config/src/index.ts | 1 + config/config/src/types.ts | 1 + .../core/src/install/extendInstallOptions.ts | 2 + pkg-manager/core/src/install/index.ts | 1 + .../core/test/install/blockExoticSubdeps.ts | 57 +++++++++++++++++++ .../src/resolveDependencies.ts | 31 ++++++++++ .../src/resolveDependencyTree.ts | 2 + 9 files changed, 112 insertions(+) create mode 100644 .changeset/better-parents-tell.md create mode 100644 pkg-manager/core/test/install/blockExoticSubdeps.ts", "patch_text_b64": "From 73cc63504d9bc360c43e4b2feb9080677f03c5b5 Mon Sep 17 00:00:00 2001
From: Oren <orenyomtov@users.noreply.github.com>
Date: Wed, 10 Dec 2025 13:14:16 +0200
Subject: [PATCH] feat: support blockExoticSubdeps option to disallow
 non-trusted dep sources in subdeps (#10265)

* feat(core): add onlyRegistryDependencies option to disallow non-registry subdependencies

* fix: onlyRegistryDependencies=>registrySubdepsOnly

* fix: allow resolution from custom resolver

* fix: add registry-subdeps-only to types

* docs: update changesets

* refactor: registry-only

* refactor: registrySubdepsOnly=>blockExoticSubdeps

* fix: trust runtime deps

* refactor: remove comment

---------

Co-authored-by: Zoltan Kochan <z@kochan.io>
---
 .changeset/better-parents-tell.md             | 16 ++++++
 config/config/src/Config.ts                   |  1 +
 config/config/src/index.ts                    |  1 +
 config/config/src/types.ts                    |  1 +
 .../core/src/install/extendInstallOptions.ts  |  2 +
 pkg-manager/core/src/install/index.ts         |  1 +
 .../core/test/install/blockExoticSubdeps.ts   | 57 +++++++++++++++++++
 .../src/resolveDependencies.ts                | 31 ++++++++++
 .../src/resolveDependencyTree.ts              |  2 +
 9 files changed, 112 insertions(+)
 create mode 100644 .changeset/better-parents-tell.md
 create mode 100644 pkg-manager/core/test/install/blockExoticSubdeps.ts

diff --git a/.changeset/better-parents-tell.md b/.changeset/better-parents-tell.md
new file mode 100644
index 00000000000..6c9381fbe98
--- /dev/null
+++ b/.changeset/better-parents-tell.md
@@ -0,0 +1,16 @@
+---
+"@pnpm/resolve-dependencies": minor
+"@pnpm/core": minor
+"@pnpm/config": minor
+"pnpm": minor
+---
+
+Added a new setting `blockExoticSubdeps` that prevents the resolution of exotic protocols in transitive dependencies.
+
+When set to `true`, direct dependencies (those listed in your root `package.json`) may still use exotic sources, but all transitive dependencies must be resolved from a trusted source. Trusted sources include the configured registry, local file paths, workspace links, trusted GitHub repositories (node, bun, deno), and custom resolvers.
+
+This helps to secure the dependency supply chain. Packages from trusted sources are considered safer, as they are typically subject to more reliable verification and scanning for malware and vulnerabilities.
+
+**Exotic sources** are dependency locations that bypass the usual trusted resolution process. These protocols are specifically targeted and blocked: Git repositories (`git+ssh://...`) and direct URL links to tarballs (`https://.../package.tgz`).
+
+Related PR: [#10265](https://github.com/pnpm/pnpm/pull/10265).
diff --git a/config/config/src/Config.ts b/config/config/src/Config.ts
index d38a0e39e95..76ce99cb59b 100644
--- a/config/config/src/Config.ts
+++ b/config/config/src/Config.ts
@@ -190,6 +190,7 @@ export interface Config extends OptionsFromRootManifest {
   ignoreWorkspaceCycles?: boolean
   disallowWorkspaceCycles?: boolean
   packGzipLevel?: number
+  blockExoticSubdeps?: boolean
 
   registries: Registries
   sslConfigs: Record<string, SslConfig>
diff --git a/config/config/src/index.ts b/config/config/src/index.ts
index 18b388f871e..c14463fec33 100644
--- a/config/config/src/index.ts
+++ b/config/config/src/index.ts
@@ -181,6 +181,7 @@ export async function getConfig (opts: {
     'public-hoist-pattern': [],
     'recursive-install': true,
     registry: npmDefaults.registry,
+    'block-exotic-subdeps': false,
     'resolution-mode': 'highest',
     'resolve-peers-from-workspace-root': true,
     'save-peer': false,
diff --git a/config/config/src/types.ts b/config/config/src/types.ts
index 3809478fe2c..8ea95dd9369 100644
--- a/config/config/src/types.ts
+++ b/config/config/src/types.ts
@@ -91,6 +91,7 @@ export const types = Object.assign({
   'public-hoist-pattern': Array,
   'publish-branch': String,
   'recursive-install': Boolean,
+  'block-exotic-subdeps': Boolean,
   reporter: String,
   'resolution-mode': ['highest', 'time-based', 'lowest-direct'],
   'resolve-peers-from-workspace-root': Boolean,
diff --git a/pkg-manager/core/src/install/extendInstallOptions.ts b/pkg-manager/core/src/install/extendInstallOptions.ts
index b61d556caba..1680e4f7456 100644
--- a/pkg-manager/core/src/install/extendInstallOptions.ts
+++ b/pkg-manager/core/src/install/extendInstallOptions.ts
@@ -170,6 +170,7 @@ export interface StrictInstallOptions {
   minimumReleaseAgeExclude?: string[]
   trustPolicy?: TrustPolicy
   trustPolicyExclude?: string[]
+  blockExoticSubdeps?: boolean
 }
 
 export type InstallOptions =
@@ -269,6 +270,7 @@ const defaults = (opts: InstallOptions): StrictInstallOptions => {
     excludeLinksFromLockfile: false,
     virtualStoreDirMaxLength: 120,
     peersSuffixMaxLength: 1000,
+    blockExoticSubdeps: false,
   } as StrictInstallOptions
 }
 
diff --git a/pkg-manager/core/src/install/index.ts b/pkg-manager/core/src/install/index.ts
index 69eb142368d..71330014a60 100644
--- a/pkg-manager/core/src/install/index.ts
+++ b/pkg-manager/core/src/install/index.ts
@@ -1228,6 +1228,7 @@ const _installInContext: InstallFunction = async (projects, ctx, opts) => {
       minimumReleaseAgeExclude: opts.minimumReleaseAgeExclude,
       trustPolicy: opts.trustPolicy,
       trustPolicyExclude: opts.trustPolicyExclude,
+      blockExoticSubdeps: opts.blockExoticSubdeps,
     }
   )
   if (!opts.include.optionalDependencies || !opts.include.devDependencies || !opts.include.dependencies) {
diff --git a/pkg-manager/core/test/install/blockExoticSubdeps.ts b/pkg-manager/core/test/install/blockExoticSubdeps.ts
new file mode 100644
index 00000000000..283d4db49b6
--- /dev/null
+++ b/pkg-manager/core/test/install/blockExoticSubdeps.ts
@@ -0,0 +1,57 @@
+import { prepareEmpty } from '@pnpm/prepare'
+import { addDependenciesToPackage } from '@pnpm/core'
+import { testDefaults } from '../utils/index.js'
+
+test('blockExoticSubdeps disallows git dependencies in subdependencies', async () => {
+  prepareEmpty()
+
+  await expect(addDependenciesToPackage({},
+    // @pnpm.e2e/has-aliased-git-dependency has a git-hosted subdependency (say-hi from github:zkochan/hi)
+    ['@pnpm.e2e/has-aliased-git-dependency'],
+    testDefaults({ blockExoticSubdeps: true, fastUnpack: false })
+  )).rejects.toThrow('is not allowed in subdependencies when blockExoticSubdeps is enabled')
+})
+
+test('blockExoticSubdeps allows git dependencies in direct dependencies', async () => {
+  const project = prepareEmpty()
+
+  // Direct git dependency should be allowed even when blockExoticSubdeps is enabled
+  const { updatedManifest: manifest } = await addDependenciesToPackage(
+    {},
+    ['kevva/is-negative#1.0.0'],
+    testDefaults({ blockExoticSubdeps: true })
+  )
+
+  project.has('is-negative')
+
+  expect(manifest.dependencies).toStrictEqual({
+    'is-negative': 'github:kevva/is-negative#1.0.0',
+  })
+})
+
+test('blockExoticSubdeps allows registry dependencies in subdependencies', async () => {
+  const project = prepareEmpty()
+
+  // A package with only registry subdependencies should work fine
+  await addDependenciesToPackage(
+    {},
+    ['is-positive@1.0.0'],
+    testDefaults({ blockExoticSubdeps: true })
+  )
+
+  project.has('is-positive')
+})
+
+test('blockExoticSubdeps: false (default) allows git dependencies in subdependencies', async () => {
+  const project = prepareEmpty()
+
+  // Without blockExoticSubdeps (or with it set to false), git subdeps should be allowed
+  await addDependenciesToPackage(
+    {},
+    ['@pnpm.e2e/has-aliased-git-dependency'],
+    testDefaults({ blockExoticSubdeps: false, fastUnpack: false })
+  )
+
+  const m = project.requireModule('@pnpm.e2e/has-aliased-git-dependency')
+  expect(m).toBe('Hi')
+})
diff --git a/pkg-manager/resolve-dependencies/src/resolveDependencies.ts b/pkg-manager/resolve-dependencies/src/resolveDependencies.ts
index b45a1d84054..5bdaff6452d 100644
--- a/pkg-manager/resolve-dependencies/src/resolveDependencies.ts
+++ b/pkg-manager/resolve-dependencies/src/resolveDependencies.ts
@@ -187,6 +187,7 @@ export interface ResolutionContext {
   publishedByExclude?: PackageVersionPolicy
   trustPolicy?: TrustPolicy
   trustPolicyExclude?: PackageVersionPolicy
+  blockExoticSubdeps?: boolean
 }
 
 export interface MissingPeerInfo {
@@ -1387,6 +1388,21 @@ async function resolveDependency (
     },
   })
 
+  // Check if exotic dependencies are disallowed in subdependencies
+  if (
+    ctx.blockExoticSubdeps &&
+    options.currentDepth > 0 &&
+    !isNonExoticDep(pkgResponse.body.resolvedVia)
+  ) {
+    const error = new PnpmError(
+      'EXOTIC_SUBDEP',
+      `Exotic dependency "${wantedDependency.alias ?? wantedDependency.bareSpecifier}" (resolved via ${pkgResponse.body.resolvedVia}) is not allowed in subdependencies when blockExoticSubdeps is enabled`
+    )
+    error.prefix = options.prefix
+    error.pkgsStack = getPkgsInfoFromIds(options.parentIds, ctx.resolvedPkgsById)
+    throw error
+  }
+
   if (ctx.allPreferredVersions && pkgResponse.body.manifest?.version) {
     if (!ctx.allPreferredVersions[pkgResponse.body.manifest.name]) {
       ctx.allPreferredVersions[pkgResponse.body.manifest.name] = {}
@@ -1781,3 +1797,18 @@ function getCatalogExistingVersionFromSnapshot (
     ? existingCatalogResolution.version
     : undefined
 }
+
+const NON_EXOTIC_RESOLVED_VIA = new Set([
+  'custom-resolver',
+  'github.com/denoland/deno',
+  'github.com/oven-sh/bun',
+  'jsr-registry',
+  'local-filesystem',
+  'nodejs.org',
+  'npm-registry',
+  'workspace',
+])
+
+function isNonExoticDep (resolvedVia: string | undefined): boolean {
+  return resolvedVia != null && NON_EXOTIC_RESOLVED_VIA.has(resolvedVia)
+}
diff --git a/pkg-manager/resolve-dependencies/src/resolveDependencyTree.ts b/pkg-manager/resolve-dependencies/src/resolveDependencyTree.ts
index 80a46d7d407..3eaabb45d87 100644
--- a/pkg-manager/resolve-dependencies/src/resolveDependencyTree.ts
+++ b/pkg-manager/resolve-dependencies/src/resolveDependencyTree.ts
@@ -143,6 +143,7 @@ export interface ResolveDependenciesOptions {
   minimumReleaseAgeExclude?: string[]
   trustPolicy?: TrustPolicy
   trustPolicyExclude?: string[]
+  blockExoticSubdeps?: boolean
 }
 
 export interface ResolveDependencyTreeResult {
@@ -208,6 +209,7 @@ export async function resolveDependencyTree<T> (
     publishedByExclude: opts.minimumReleaseAgeExclude ? createPackageVersionPolicyByExclude(opts.minimumReleaseAgeExclude, 'minimumReleaseAgeExclude') : undefined,
     trustPolicy: opts.trustPolicy,
     trustPolicyExclude: opts.trustPolicyExclude ? createPackageVersionPolicyByExclude(opts.trustPolicyExclude, 'trustPolicyExclude') : undefined,
+    blockExoticSubdeps: opts.blockExoticSubdeps,
   }
 
   function createPackageVersionPolicyByExclude (patterns: string[], key: string): PackageVersionPolicy {", "url": "https://github.com/pnpm/pnpm/commit/73cc63504d9bc360c43e4b2feb9080677f03c5b5.patch" } ]
null
GHSA-6h58-c7r7-g2hw
UberFire Framework Improperly Restricts Paths
null
[ { "commit_message": "[PATCH] BZ(1169544,1169556, 1169557,1169559,1169560): improvements on security related to file access .../commons/regex}/util/AntPathMatcher.java | 229 ++++++++-------- .../org/uberfire/io/regex/AntPathMatcher.java | 89 +++++++ .../uberfire/io/regex/AntPathMatcherTest.java | 244 ++++++++++++++++++ .../security/server/URLResourceManager.java | 2 +- .../uberfire/server/BaseFilteredServlet.java | 66 +++++ .../uberfire/server/FileDownloadServlet.java | 33 ++- .../uberfire/server/FileUploadServlet.java | 80 +++--- 7 files changed, 578 insertions(+), 165 deletions(-) rename {uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server => uberfire-commons/src/main/java/org/uberfire/commons/regex}/util/AntPathMatcher.java (59%) create mode 100644 uberfire-io/src/main/java/org/uberfire/io/regex/AntPathMatcher.java create mode 100644 uberfire-io/src/test/java/org/uberfire/io/regex/AntPathMatcherTest.java create mode 100644 uberfire-server/src/main/java/org/uberfire/server/BaseFilteredServlet.java", "patch_text_b64": "From 21ec50eb150ab976be060848d6dd0e97ec6c8246 Mon Sep 17 00:00:00 2001
From: Alexandre Porcelli <alexandre.porcelli@gmail.com>
Date: Tue, 23 Dec 2014 11:35:18 -0300
Subject: [PATCH] BZ(1169544,1169556, 1169557,1169559,1169560): improvements on
 security related to file access

---
 .../commons/regex}/util/AntPathMatcher.java   | 229 ++++++++--------
 .../org/uberfire/io/regex/AntPathMatcher.java |  89 +++++++
 .../uberfire/io/regex/AntPathMatcherTest.java | 244 ++++++++++++++++++
 .../security/server/URLResourceManager.java   |   2 +-
 .../uberfire/server/BaseFilteredServlet.java  |  66 +++++
 .../uberfire/server/FileDownloadServlet.java  |  33 ++-
 .../uberfire/server/FileUploadServlet.java    |  80 +++---
 7 files changed, 578 insertions(+), 165 deletions(-)
 rename {uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server => uberfire-commons/src/main/java/org/uberfire/commons/regex}/util/AntPathMatcher.java (59%)
 create mode 100644 uberfire-io/src/main/java/org/uberfire/io/regex/AntPathMatcher.java
 create mode 100644 uberfire-io/src/test/java/org/uberfire/io/regex/AntPathMatcherTest.java
 create mode 100644 uberfire-server/src/main/java/org/uberfire/server/BaseFilteredServlet.java

diff --git a/uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server/util/AntPathMatcher.java b/uberfire-commons/src/main/java/org/uberfire/commons/regex/util/AntPathMatcher.java
similarity index 59%
rename from uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server/util/AntPathMatcher.java
rename to uberfire-commons/src/main/java/org/uberfire/commons/regex/util/AntPathMatcher.java
index b4bdcdc783..d8c7e05199 100644
--- a/uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server/util/AntPathMatcher.java
+++ b/uberfire-commons/src/main/java/org/uberfire/commons/regex/util/AntPathMatcher.java
@@ -1,20 +1,4 @@
-/*
- * Copyright 2012 JBoss Inc
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.uberfire.security.server.util;
+package org.uberfire.commons.regex.util;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -39,20 +23,22 @@ public class AntPathMatcher {
      * Set the path separator to use for pattern parsing. Default is "/", as in
      * Ant.
      */
-    public void setPathSeparator(final String pathSeparator) {
+    public void setPathSeparator( final String pathSeparator ) {
         this.pathSeparator = pathSeparator != null ? pathSeparator : DEFAULT_PATH_SEPARATOR;
     }
 
-    public boolean isPattern(final String path) {
-        return path.indexOf('*') != -1 || path.indexOf('?') != -1;
+    public boolean isPattern( final String path ) {
+        return path.indexOf( '*' ) != -1 || path.indexOf( '?' ) != -1;
     }
 
-    public boolean match(final String pattern, final String path) {
-        return doMatch(pattern, path, true);
+    public boolean match( final String pattern,
+                          final String path ) {
+        return doMatch( pattern, path, true );
     }
 
-    public boolean matchStart(final String pattern, final String path) {
-        return doMatch(pattern, path, false);
+    public boolean matchStart( final String pattern,
+                               final String path ) {
+        return doMatch( pattern, path, false );
     }
 
     /**
@@ -63,15 +49,17 @@ public boolean matchStart(final String pattern, final String path) {
      * @param fullMatch whether a full pattern match is required (else a pattern
      * match as far as the given base path goes is sufficient)
      * @return <code>true</code> if the supplied <code>path</code> matched,
-     *         <code>false</code> if it didn't
+     * <code>false</code> if it didn't
      */
-    protected boolean doMatch(String pattern, String path, boolean fullMatch) {
-        if (path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
+    protected boolean doMatch( String pattern,
+                               String path,
+                               boolean fullMatch ) {
+        if ( path.startsWith( this.pathSeparator ) != pattern.startsWith( this.pathSeparator ) ) {
             return false;
         }
 
-        String[] pattDirs = tokenizeToStringArray(pattern, this.pathSeparator);
-        String[] pathDirs = tokenizeToStringArray(path, this.pathSeparator);
+        String[] pattDirs = tokenizeToStringArray( pattern, this.pathSeparator );
+        String[] pathDirs = tokenizeToStringArray( path, this.pathSeparator );
 
         int pattIdxStart = 0;
         int pattIdxEnd = pattDirs.length - 1;
@@ -79,76 +67,76 @@ protected boolean doMatch(String pattern, String path, boolean fullMatch) {
         int pathIdxEnd = pathDirs.length - 1;
 
         // Match all elements up to the first **
-        while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
-            String patDir = pattDirs[pattIdxStart];
-            if ("**".equals(patDir)) {
+        while ( pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd ) {
+            String patDir = pattDirs[ pattIdxStart ];
+            if ( "**".equals( patDir ) ) {
                 break;
             }
-            if (!matchStrings(patDir, pathDirs[pathIdxStart])) {
+            if ( !matchStrings( patDir, pathDirs[ pathIdxStart ] ) ) {
                 return false;
             }
             pattIdxStart++;
             pathIdxStart++;
         }
 
-        if (pathIdxStart > pathIdxEnd) {
+        if ( pathIdxStart > pathIdxEnd ) {
             // Path is exhausted, only match if rest of pattern is * or **'s
-            if (pattIdxStart > pattIdxEnd) {
-                return pattern.endsWith(this.pathSeparator) ? path.endsWith(this.pathSeparator) : !path
-                        .endsWith(this.pathSeparator);
+            if ( pattIdxStart > pattIdxEnd ) {
+                return pattern.endsWith( this.pathSeparator ) ? path.endsWith( this.pathSeparator ) : !path
+                        .endsWith( this.pathSeparator );
             }
-            if (!fullMatch) {
+            if ( !fullMatch ) {
                 return true;
             }
-            if (pattIdxStart == pattIdxEnd && pattDirs[pattIdxStart].equals("*")
-                    && path.endsWith(this.pathSeparator)) {
+            if ( pattIdxStart == pattIdxEnd && pattDirs[ pattIdxStart ].equals( "*" )
+                    && path.endsWith( this.pathSeparator ) ) {
                 return true;
             }
-            for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
-                if (!pattDirs[i].equals("**")) {
+            for ( int i = pattIdxStart; i <= pattIdxEnd; i++ ) {
+                if ( !pattDirs[ i ].equals( "**" ) ) {
                     return false;
                 }
             }
             return true;
-        } else if (pattIdxStart > pattIdxEnd) {
+        } else if ( pattIdxStart > pattIdxEnd ) {
             // String not exhausted, but pattern is. Failure.
             return false;
-        } else if (!fullMatch && "**".equals(pattDirs[pattIdxStart])) {
+        } else if ( !fullMatch && "**".equals( pattDirs[ pattIdxStart ] ) ) {
             // Path start definitely matches due to "**" part in pattern.
             return true;
         }
 
         // up to last '**'
-        while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
-            String patDir = pattDirs[pattIdxEnd];
-            if (patDir.equals("**")) {
+        while ( pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd ) {
+            String patDir = pattDirs[ pattIdxEnd ];
+            if ( patDir.equals( "**" ) ) {
                 break;
             }
-            if (!matchStrings(patDir, pathDirs[pathIdxEnd])) {
+            if ( !matchStrings( patDir, pathDirs[ pathIdxEnd ] ) ) {
                 return false;
             }
             pattIdxEnd--;
             pathIdxEnd--;
         }
-        if (pathIdxStart > pathIdxEnd) {
+        if ( pathIdxStart > pathIdxEnd ) {
             // String is exhausted
-            for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
-                if (!pattDirs[i].equals("**")) {
+            for ( int i = pattIdxStart; i <= pattIdxEnd; i++ ) {
+                if ( !pattDirs[ i ].equals( "**" ) ) {
                     return false;
                 }
             }
             return true;
         }
 
-        while (pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+        while ( pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd ) {
             int patIdxTmp = -1;
-            for (int i = pattIdxStart + 1; i <= pattIdxEnd; i++) {
-                if (pattDirs[i].equals("**")) {
+            for ( int i = pattIdxStart + 1; i <= pattIdxEnd; i++ ) {
+                if ( pattDirs[ i ].equals( "**" ) ) {
                     patIdxTmp = i;
                     break;
                 }
             }
-            if (patIdxTmp == pattIdxStart + 1) {
+            if ( patIdxTmp == pattIdxStart + 1 ) {
                 // '**/**' situation, so skip one
                 pattIdxStart++;
                 continue;
@@ -160,11 +148,11 @@ protected boolean doMatch(String pattern, String path, boolean fullMatch) {
             int foundIdx = -1;
 
             strLoop:
-            for (int i = 0; i <= strLength - patLength; i++) {
-                for (int j = 0; j < patLength; j++) {
-                    String subPat = pattDirs[pattIdxStart + j + 1];
-                    String subStr = pathDirs[pathIdxStart + i + j];
-                    if (!matchStrings(subPat, subStr)) {
+            for ( int i = 0; i <= strLength - patLength; i++ ) {
+                for ( int j = 0; j < patLength; j++ ) {
+                    String subPat = pattDirs[ pattIdxStart + j + 1 ];
+                    String subStr = pathDirs[ pathIdxStart + i + j ];
+                    if ( !matchStrings( subPat, subStr ) ) {
                         continue strLoop;
                     }
                 }
@@ -172,7 +160,7 @@ protected boolean doMatch(String pattern, String path, boolean fullMatch) {
                 break;
             }
 
-            if (foundIdx == -1) {
+            if ( foundIdx == -1 ) {
                 return false;
             }
 
@@ -180,8 +168,8 @@ protected boolean doMatch(String pattern, String path, boolean fullMatch) {
             pathIdxStart = foundIdx + patLength;
         }
 
-        for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
-            if (!pattDirs[i].equals("**")) {
+        for ( int i = pattIdxStart; i <= pattIdxEnd; i++ ) {
+            if ( !pattDirs[ i ].equals( "**" ) ) {
                 return false;
             }
         }
@@ -198,9 +186,10 @@ protected boolean doMatch(String pattern, String path, boolean fullMatch) {
      * @param str string which must be matched against the pattern. Must not be
      * <code>null</code>.
      * @return <code>true</code> if the string matches against the pattern, or
-     *         <code>false</code> otherwise.
+     * <code>false</code> otherwise.
      */
-    private boolean matchStrings(String pattern, String str) {
+    private boolean matchStrings( String pattern,
+                                  String str ) {
         char[] patArr = pattern.toCharArray();
         char[] strArr = str.toCharArray();
         int patIdxStart = 0;
@@ -210,22 +199,22 @@ private boolean matchStrings(String pattern, String str) {
         char ch;
 
         boolean containsStar = false;
-        for (char c : patArr) {
-            if (c == '*') {
+        for ( char c : patArr ) {
+            if ( c == '*' ) {
                 containsStar = true;
                 break;
             }
         }
 
-        if (!containsStar) {
+        if ( !containsStar ) {
             // No '*'s, so we make a shortcut
-            if (patIdxEnd != strIdxEnd) {
+            if ( patIdxEnd != strIdxEnd ) {
                 return false; // Pattern and string do not have the same size
             }
-            for (int i = 0; i <= patIdxEnd; i++) {
-                ch = patArr[i];
-                if (ch != '?') {
-                    if (ch != strArr[i]) {
+            for ( int i = 0; i <= patIdxEnd; i++ ) {
+                ch = patArr[ i ];
+                if ( ch != '?' ) {
+                    if ( ch != strArr[ i ] ) {
                         return false;
                         // Character mismatch
                     }
@@ -234,14 +223,14 @@ private boolean matchStrings(String pattern, String str) {
             return true; // String matches against pattern
         }
 
-        if (patIdxEnd == 0) {
+        if ( patIdxEnd == 0 ) {
             return true; // Pattern contains only '*', which matches anything
         }
 
         // Process characters before first star
-        while ((ch = patArr[patIdxStart]) != '*' && strIdxStart <= strIdxEnd) {
-            if (ch != '?') {
-                if (ch != strArr[strIdxStart]) {
+        while ( ( ch = patArr[ patIdxStart ] ) != '*' && strIdxStart <= strIdxEnd ) {
+            if ( ch != '?' ) {
+                if ( ch != strArr[ strIdxStart ] ) {
                     return false;
                     // Character mismatch
                 }
@@ -249,11 +238,11 @@ private boolean matchStrings(String pattern, String str) {
             patIdxStart++;
             strIdxStart++;
         }
-        if (strIdxStart > strIdxEnd) {
+        if ( strIdxStart > strIdxEnd ) {
             // All characters in the string are used. Check if only '*'s are
             // left in the pattern. If so, we succeeded. Otherwise failure.
-            for (int i = patIdxStart; i <= patIdxEnd; i++) {
-                if (patArr[i] != '*') {
+            for ( int i = patIdxStart; i <= patIdxEnd; i++ ) {
+                if ( patArr[ i ] != '*' ) {
                     return false;
                 }
             }
@@ -261,9 +250,9 @@ private boolean matchStrings(String pattern, String str) {
         }
 
         // Process characters after last star
-        while ((ch = patArr[patIdxEnd]) != '*' && strIdxStart <= strIdxEnd) {
-            if (ch != '?') {
-                if (ch != strArr[strIdxEnd]) {
+        while ( ( ch = patArr[ patIdxEnd ] ) != '*' && strIdxStart <= strIdxEnd ) {
+            if ( ch != '?' ) {
+                if ( ch != strArr[ strIdxEnd ] ) {
                     return false;
                     // Character mismatch
                 }
@@ -271,11 +260,11 @@ private boolean matchStrings(String pattern, String str) {
             patIdxEnd--;
             strIdxEnd--;
         }
-        if (strIdxStart > strIdxEnd) {
+        if ( strIdxStart > strIdxEnd ) {
             // All characters in the string are used. Check if only '*'s are
             // left in the pattern. If so, we succeeded. Otherwise failure.
-            for (int i = patIdxStart; i <= patIdxEnd; i++) {
-                if (patArr[i] != '*') {
+            for ( int i = patIdxStart; i <= patIdxEnd; i++ ) {
+                if ( patArr[ i ] != '*' ) {
                     return false;
                 }
             }
@@ -284,15 +273,15 @@ private boolean matchStrings(String pattern, String str) {
 
         // process pattern between stars. padIdxStart and patIdxEnd point
         // always to a '*'.
-        while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
+        while ( patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd ) {
             int patIdxTmp = -1;
-            for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
-                if (patArr[i] == '*') {
+            for ( int i = patIdxStart + 1; i <= patIdxEnd; i++ ) {
+                if ( patArr[ i ] == '*' ) {
                     patIdxTmp = i;
                     break;
                 }
             }
-            if (patIdxTmp == patIdxStart + 1) {
+            if ( patIdxTmp == patIdxStart + 1 ) {
                 // Two stars next to each other, skip the first one.
                 patIdxStart++;
                 continue;
@@ -303,11 +292,11 @@ private boolean matchStrings(String pattern, String str) {
             int strLength = strIdxEnd - strIdxStart + 1;
             int foundIdx = -1;
             strLoop:
-            for (int i = 0; i <= strLength - patLength; i++) {
-                for (int j = 0; j < patLength; j++) {
-                    ch = patArr[patIdxStart + j + 1];
-                    if (ch != '?') {
-                        if (ch != strArr[strIdxStart + i + j]) {
+            for ( int i = 0; i <= strLength - patLength; i++ ) {
+                for ( int j = 0; j < patLength; j++ ) {
+                    ch = patArr[ patIdxStart + j + 1 ];
+                    if ( ch != '?' ) {
+                        if ( ch != strArr[ strIdxStart + i + j ] ) {
                             continue strLoop;
                         }
                     }
@@ -317,7 +306,7 @@ private boolean matchStrings(String pattern, String str) {
                 break;
             }
 
-            if (foundIdx == -1) {
+            if ( foundIdx == -1 ) {
                 return false;
             }
 
@@ -327,8 +316,8 @@ private boolean matchStrings(String pattern, String str) {
 
         // All characters in the string are used. Check if only '*'s are left
         // in the pattern. If so, we succeeded. Otherwise failure.
-        for (int i = patIdxStart; i <= patIdxEnd; i++) {
-            if (patArr[i] != '*') {
+        for ( int i = patIdxStart; i <= patIdxEnd; i++ ) {
+            if ( patArr[ i ] != '*' ) {
                 return false;
             }
         }
@@ -363,31 +352,32 @@ private boolean matchStrings(String pattern, String str) {
      * <code>pattern</code>' and '<code>path</code>', but does
      * <strong>not</strong> enforce this.
      */
-    public String extractPathWithinPattern(String pattern, String path) {
-        final String[] patternParts = tokenizeToStringArray(pattern, this.pathSeparator);
-        final String[] pathParts = tokenizeToStringArray(path, this.pathSeparator);
+    public String extractPathWithinPattern( String pattern,
+                                            String path ) {
+        final String[] patternParts = tokenizeToStringArray( pattern, this.pathSeparator );
+        final String[] pathParts = tokenizeToStringArray( path, this.pathSeparator );
 
         final StringBuilder buffer = new StringBuilder();
 
         // Add any path parts that have a wildcarded pattern part.
         int puts = 0;
-        for (int i = 0; i < patternParts.length; i++) {
-            final String patternPart = patternParts[i];
-            if ((patternPart.indexOf('*') > -1 || patternPart.indexOf('?') > -1) && pathParts.length >= i + 1) {
-                if (puts > 0 || (i == 0 && !pattern.startsWith(this.pathSeparator))) {
-                    buffer.append(this.pathSeparator);
+        for ( int i = 0; i < patternParts.length; i++ ) {
+            final String patternPart = patternParts[ i ];
+            if ( ( patternPart.indexOf( '*' ) > -1 || patternPart.indexOf( '?' ) > -1 ) && pathParts.length >= i + 1 ) {
+                if ( puts > 0 || ( i == 0 && !pattern.startsWith( this.pathSeparator ) ) ) {
+                    buffer.append( this.pathSeparator );
                 }
-                buffer.append(pathParts[i]);
+                buffer.append( pathParts[ i ] );
                 puts++;
             }
         }
 
         // Append any trailing path parts.
-        for (int i = patternParts.length; i < pathParts.length; i++) {
-            if (puts > 0 || i > 0) {
-                buffer.append(this.pathSeparator);
+        for ( int i = patternParts.length; i < pathParts.length; i++ ) {
+            if ( puts > 0 || i > 0 ) {
+                buffer.append( this.pathSeparator );
             }
-            buffer.append(pathParts[i]);
+            buffer.append( pathParts[ i ] );
         }
 
         return buffer.toString();
@@ -408,19 +398,20 @@ public String extractPathWithinPattern(String pattern, String path) {
      * @see java.util.StringTokenizer
      * @see java.lang.String#trim()
      */
-    public static String[] tokenizeToStringArray(String str, String delimiters) {
-        if (str == null) {
+    public static String[] tokenizeToStringArray( String str,
+                                                  String delimiters ) {
+        if ( str == null ) {
             return null;
         }
-        final StringTokenizer st = new StringTokenizer(str, delimiters);
+        final StringTokenizer st = new StringTokenizer( str, delimiters );
         final List<String> tokens = new ArrayList<String>();
-        while (st.hasMoreTokens()) {
+        while ( st.hasMoreTokens() ) {
             final String token = st.nextToken().trim();
-            if (token.length() > 0) {
-                tokens.add(token);
+            if ( token.length() > 0 ) {
+                tokens.add( token );
             }
         }
-        return tokens.toArray(new String[tokens.size()]);
+        return tokens.toArray( new String[ tokens.size() ] );
     }
 
-}
+}
\ No newline at end of file
diff --git a/uberfire-io/src/main/java/org/uberfire/io/regex/AntPathMatcher.java b/uberfire-io/src/main/java/org/uberfire/io/regex/AntPathMatcher.java
new file mode 100644
index 0000000000..25033269c8
--- /dev/null
+++ b/uberfire-io/src/main/java/org/uberfire/io/regex/AntPathMatcher.java
@@ -0,0 +1,89 @@
+package org.uberfire.io.regex;
+
+import java.net.URI;
+import java.util.Collection;
+
+import org.uberfire.java.nio.file.Path;
+
+import static org.uberfire.commons.validation.Preconditions.*;
+
+public final class AntPathMatcher {
+
+    private static org.uberfire.commons.regex.util.AntPathMatcher matcher = new org.uberfire.commons.regex.util.AntPathMatcher();
+
+    public static boolean filter( final Collection<String> includes,
+                                  final Collection<String> excludes,
+                                  final Path path ) {
+        checkNotNull( "includes", includes );
+        checkNotNull( "excludes", excludes );
+        checkNotNull( "path", path );
+        if ( includes.isEmpty() && excludes.isEmpty() ) {
+            return true;
+        } else if ( includes.isEmpty() ) {
+            return !( excludes( excludes, path ) );
+        } else if ( excludes.isEmpty() ) {
+            return includes( includes, path );
+        }
+        return includes( includes, path ) && !( excludes( excludes, path ) );
+    }
+
+    public static boolean filter( final Collection<String> includes,
+                                  final Collection<String> excludes,
+                                  final URI uri ) {
+        checkNotNull( "includes", includes );
+        checkNotNull( "excludes", excludes );
+        checkNotNull( "uri", uri );
+        if ( includes.isEmpty() && excludes.isEmpty() ) {
+            return true;
+        } else if ( includes.isEmpty() ) {
+            return !( excludes( excludes, uri ) );
+        } else if ( excludes.isEmpty() ) {
+            return includes( includes, uri );
+        }
+        return includes( includes, uri ) && !( excludes( excludes, uri ) );
+    }
+
+    public static boolean includes( final Collection<String> patterns,
+                                    final Path path ) {
+        checkNotNull( "patterns", patterns );
+        checkNotNull( "path", path );
+        return matches( patterns, path );
+    }
+
+    public static boolean includes( final Collection<String> patterns,
+                                    final URI uri ) {
+        checkNotNull( "patterns", patterns );
+        checkNotNull( "uri", uri );
+        return matches( patterns, uri );
+    }
+
+    public static boolean excludes( final Collection<String> patterns,
+                                    final URI uri ) {
+        checkNotNull( "patterns", patterns );
+        checkNotNull( "uri", uri );
+        return matches( patterns, uri );
+    }
+
+    public static boolean excludes( final Collection<String> patterns,
+                                    final Path path ) {
+        checkNotNull( "patterns", patterns );
+        checkNotNull( "path", path );
+        return matches( patterns, path );
+    }
+
+    private static boolean matches( final Collection<String> patterns,
+                                    final Path path ) {
+        return matches( patterns, path.toUri() );
+    }
+
+    private static boolean matches( final Collection<String> patterns,
+                                    final URI uri ) {
+        for ( final String pattern : patterns ) {
+            if ( matcher.match( pattern, uri.toString() ) ) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+}
diff --git a/uberfire-io/src/test/java/org/uberfire/io/regex/AntPathMatcherTest.java b/uberfire-io/src/test/java/org/uberfire/io/regex/AntPathMatcherTest.java
new file mode 100644
index 0000000000..d0b1318d49
--- /dev/null
+++ b/uberfire-io/src/test/java/org/uberfire/io/regex/AntPathMatcherTest.java
@@ -0,0 +1,244 @@
+package org.uberfire.io.regex;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+
+import org.apache.commons.io.FileUtils;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.uberfire.io.CommonIOServiceDotFileTest;
+import org.uberfire.io.IOService;
+import org.uberfire.io.impl.IOServiceDotFileImpl;
+import org.uberfire.java.nio.file.Path;
+import org.uberfire.java.nio.file.Paths;
+
+import static org.uberfire.io.regex.AntPathMatcher.*;
+
+public class AntPathMatcherTest {
+
+    final static IOService ioService = new IOServiceDotFileImpl();
+    private static File path = null;
+
+    @BeforeClass
+    public static void setup() throws IOException {
+        path = CommonIOServiceDotFileTest.createTempDirectory();
+        System.setProperty( "org.uberfire.nio.git.dir", path.getAbsolutePath() );
+        System.out.println( ".niogit: " + path.getAbsolutePath() );
+
+        final URI newRepo = URI.create( "git://antpathmatcher" );
+
+        ioService.newFileSystem( newRepo, new HashMap<String, Object>() );
+    }
+
+    @AfterClass
+    @BeforeClass
+    public static void cleanup() {
+        if ( path != null ) {
+            FileUtils.deleteQuietly( path );
+        }
+    }
+
+    @Test
+    public void testIncludes() {
+        final Collection<String> patterns = new ArrayList<String>() {{
+            add( "git://**" );
+            add( "**/repo/**" );
+        }};
+
+        {
+            final Path path = Paths.get( URI.create( "file:///Users/home" ) );
+            Assert.assertFalse( includes( patterns, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://antpathmatcher" ) );
+            Assert.assertTrue( includes( patterns, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://master@antpathmatcher" ) );
+            Assert.assertTrue( includes( patterns, path ) );
+        }
+    }
+
+    @Test
+    public void testIncludesMid() {
+        final Collection<String> patterns = new ArrayList<String>() {{
+            add( "default://**" );
+            add( "**/repo/**" );
+        }};
+
+        {
+            final Path path = Paths.get( URI.create( "file:///Users/home" ) );
+            Assert.assertTrue( includes( patterns, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://antpathmatcher" ) );
+            Assert.assertFalse( includes( patterns, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://master@antpathmatcher/repo/sss" ) );
+            Assert.assertTrue( includes( patterns, path ) );
+        }
+    }
+
+    @Test
+    public void testExcludes() {
+        final Collection<String> patterns = new ArrayList<String>() {{
+            add( "git://**" );
+            add( "**/repo/**" );
+        }};
+
+        {
+            final Path path = Paths.get( URI.create( "file:///Users/home" ) );
+            Assert.assertFalse( excludes( patterns, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://antpathmatcher" ) );
+            Assert.assertTrue( excludes( patterns, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://master@antpathmatcher" ) );
+            Assert.assertTrue( excludes( patterns, path ) );
+        }
+    }
+
+    @Test
+    public void testExcludesMid() {
+        final Collection<String> patterns = new ArrayList<String>() {{
+            add( "default://**" );
+            add( "**/repo/**" );
+        }};
+
+        {
+            final Path path = Paths.get( URI.create( "file:///Users/home" ) );
+            Assert.assertTrue( excludes( patterns, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://antpathmatcher" ) );
+            Assert.assertFalse( excludes( patterns, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://master@antpathmatcher/repo/sss" ) );
+            Assert.assertTrue( excludes( patterns, path ) );
+        }
+    }
+
+    @Test
+    public void testFilter() {
+        final Collection<String> includes = new ArrayList<String>() {{
+            add( "git://**" );
+        }};
+        final Collection<String> excludes = new ArrayList<String>() {{
+            add( "default://**" );
+        }};
+
+        {
+            final Path path = Paths.get( URI.create( "file:///Users/home" ) );
+            Assert.assertFalse( filter( includes, excludes, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://antpathmatcher" ) );
+            Assert.assertTrue( filter( includes, excludes, path ) );
+        }
+
+        {
+            final Path path = Paths.get( URI.create( "git://master@antpathmatcher/repo/sss" ) );
+            Assert.assertTrue( filter( includes, excludes, path ) );
+        }
+
+        Assert.assertTrue( filter( Collections.<String>emptyList(), Collections.<String>emptyList(), Paths.get( URI.create( "git://master@antpathmatcher/repo/sss" ) ) ) );
+        Assert.assertTrue( filter( Collections.<String>emptyList(), Collections.<String>emptyList(), Paths.get( URI.create( "git://antpathmatcher" ) ) ) );
+    }
+
+    @Test
+    public void testIncludesUri() {
+        final Collection<String> patterns = new ArrayList<String>() {{
+            add( "git://**" );
+            add( "**/repo/**" );
+        }};
+
+        Assert.assertFalse( includes( patterns, URI.create( "file:///Users/home" ) ) );
+
+        Assert.assertTrue( includes( patterns, URI.create( "git://antpathmatcher" ) ) );
+
+        Assert.assertTrue( includes( patterns, URI.create( "git://master@antpathmatcher" ) ) );
+    }
+
+    @Test
+    public void testIncludesMidUri() {
+        final Collection<String> patterns = new ArrayList<String>() {{
+            add( "file://**" );
+            add( "**/repo/**" );
+        }};
+
+        Assert.assertTrue( includes( patterns, URI.create( "file:///Users/home" ) ) );
+
+        Assert.assertFalse( includes( patterns, URI.create( "git://antpathmatcher" ) ) );
+
+        Assert.assertTrue( includes( patterns, URI.create( "git://master@antpathmatcher/repo/sss" ) ) );
+    }
+
+    @Test
+    public void testExcludesUri() {
+        final Collection<String> patterns = new ArrayList<String>() {{
+            add( "git://**" );
+            add( "**/repo/**" );
+        }};
+
+        Assert.assertFalse( excludes( patterns, URI.create( "file:///Users/home" ) ) );
+
+        Assert.assertTrue( excludes( patterns, URI.create( "git://antpathmatcher" ) ) );
+
+        Assert.assertTrue( excludes( patterns, URI.create( "git://master@antpathmatcher" ) ) );
+    }
+
+    @Test
+    public void testExcludesMidUri() {
+        final Collection<String> patterns = new ArrayList<String>() {{
+            add( "file://**" );
+            add( "**/repo/**" );
+        }};
+
+        Assert.assertTrue( excludes( patterns, URI.create( "file:///Users/home" ) ) );
+
+        Assert.assertFalse( excludes( patterns, URI.create( "git://antpathmatcher" ) ) );
+
+        Assert.assertTrue( excludes( patterns, URI.create( "git://master@antpathmatcher/repo/sss" ) ) );
+    }
+
+    @Test
+    public void testFilterUri() {
+        final Collection<String> includes = new ArrayList<String>() {{
+            add( "git://**" );
+        }};
+        final Collection<String> excludes = new ArrayList<String>() {{
+            add( "file://**" );
+        }};
+
+        Assert.assertFalse( filter( includes, excludes, URI.create( "file:///Users/home" ) ) );
+
+        Assert.assertTrue( filter( includes, excludes, URI.create( "git://antpathmatcher" ) ) );
+
+        Assert.assertTrue( filter( includes, excludes, URI.create( "git://master@antpathmatcher/repo/sss" ) ) );
+
+        Assert.assertTrue( filter( Collections.<String>emptyList(), Collections.<String>emptyList(), URI.create( "file:///Users/home" ) ) );
+
+        Assert.assertTrue( filter( Collections.<String>emptyList(), Collections.<String>emptyList(), URI.create( "git://master@antpathmatcher/repo/sss" ) ) );
+
+    }
+}
diff --git a/uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server/URLResourceManager.java b/uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server/URLResourceManager.java
index 96e8fc1663..0f6284b5f8 100644
--- a/uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server/URLResourceManager.java
+++ b/uberfire-security/uberfire-security-server/src/main/java/org/uberfire/security/server/URLResourceManager.java
@@ -31,7 +31,7 @@
 import org.uberfire.security.ResourceManager;
 import org.uberfire.security.Role;
 import org.uberfire.security.impl.RoleImpl;
-import org.uberfire.security.server.util.AntPathMatcher;
+import org.uberfire.commons.regex.util.AntPathMatcher;
 import org.yaml.snakeyaml.Yaml;
 
 import static java.util.Collections.*;
diff --git a/uberfire-server/src/main/java/org/uberfire/server/BaseFilteredServlet.java b/uberfire-server/src/main/java/org/uberfire/server/BaseFilteredServlet.java
new file mode 100644
index 0000000000..684d3459cc
--- /dev/null
+++ b/uberfire-server/src/main/java/org/uberfire/server/BaseFilteredServlet.java
@@ -0,0 +1,66 @@
+package org.uberfire.server;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletResponse;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.uberfire.io.regex.AntPathMatcher;
+import org.uberfire.java.nio.file.Path;
+
+import static javax.servlet.http.HttpServletResponse.*;
+
+public abstract class BaseFilteredServlet extends HttpServlet {
+
+    private static final Logger logger = LoggerFactory.getLogger( BaseFilteredServlet.class );
+
+    protected Collection<String> includes = new ArrayList<String>();
+    protected Collection<String> excludes = new ArrayList<String>();
+
+    @Override
+    public void init( final ServletConfig config ) throws ServletException {
+        final String _includes = config.getInitParameter( "includes-path" );
+        if ( _includes != null && !_includes.trim().isEmpty() ) {
+            includes.addAll( Arrays.asList( _includes.split( "," ) ) );
+        }
+        final String _excludes = config.getInitParameter( "excludes-path" );
+        if ( _excludes != null && !_excludes.trim().isEmpty() ) {
+            excludes.addAll( Arrays.asList( _excludes.split( "," ) ) );
+        }
+    }
+
+    protected boolean validateAccess( final URI uri,
+                                      final HttpServletResponse response ) {
+        if ( !AntPathMatcher.filter( includes, excludes, uri ) ) {
+            logger.error( "Invalid credentials to path." );
+            try {
+                response.sendError( SC_FORBIDDEN );
+            } catch ( Exception ex ) {
+                logger.error( ex.getMessage() );
+            }
+            return false;
+        }
+        return true;
+    }
+
+    protected boolean validateAccess( final Path path,
+                                      final HttpServletResponse response ) {
+        if ( !AntPathMatcher.filter( includes, excludes, path ) ) {
+            logger.error( "Invalid credentials to path." );
+            try {
+                response.sendError( SC_FORBIDDEN );
+            } catch ( Exception ex ) {
+                logger.error( ex.getMessage() );
+            }
+            return false;
+        }
+        return true;
+    }
+
+}
diff --git a/uberfire-server/src/main/java/org/uberfire/server/FileDownloadServlet.java b/uberfire-server/src/main/java/org/uberfire/server/FileDownloadServlet.java
index cfb476a5ab..7a7479f61a 100644
--- a/uberfire-server/src/main/java/org/uberfire/server/FileDownloadServlet.java
+++ b/uberfire-server/src/main/java/org/uberfire/server/FileDownloadServlet.java
@@ -2,11 +2,9 @@
 
 import java.io.IOException;
 import java.net.URI;
-import java.net.URISyntaxException;
 import javax.inject.Inject;
 import javax.inject.Named;
 import javax.servlet.ServletException;
-import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
@@ -15,37 +13,46 @@
 import org.uberfire.io.IOService;
 import org.uberfire.java.nio.file.Path;
 
+import static java.lang.String.*;
+
 public class FileDownloadServlet
-        extends HttpServlet {
+        extends BaseFilteredServlet {
 
-    private static final Logger logger = LoggerFactory.getLogger(FileDownloadServlet.class);
+    private static final Logger logger = LoggerFactory.getLogger( FileDownloadServlet.class );
 
     @Inject
     @Named("ioStrategy")
     private IOService ioService;
 
     @Override
-    protected void doGet(HttpServletRequest request, HttpServletResponse response)
+    protected void doGet( HttpServletRequest request,
+                          HttpServletResponse response )
             throws ServletException, IOException {
 
         try {
 
-            Path path = ioService.get(new URI(request.getParameter("path")));
+            final URI uri = new URI( request.getParameter( "path" ) );
+
+            if ( !validateAccess( uri, response ) ) {
+                return;
+            }
+
+            final Path path = ioService.get( uri );
 
-            byte[] bytes = ioService.readAllBytes(path);
+            byte[] bytes = ioService.readAllBytes( path );
 
-            response.setHeader("Content-Disposition",
-                    String.format("attachment; filename=%s;", path.getFileName().toString()));
+            response.setHeader( "Content-Disposition",
+                                format( "attachment; filename=%s;", path.getFileName().toString() ) );
 
-            response.setContentType("application/octet-stream");
+            response.setContentType( "application/octet-stream" );
 
             response.getOutputStream().write(
                     bytes,
                     0,
-                    bytes.length);
+                    bytes.length );
 
-        } catch (URISyntaxException e) {
-            logger.error("Failed to download a file.", e);
+        } catch ( final Exception e ) {
+            logger.error( "Failed to download a file.", e );
         }
 
     }
diff --git a/uberfire-server/src/main/java/org/uberfire/server/FileUploadServlet.java b/uberfire-server/src/main/java/org/uberfire/server/FileUploadServlet.java
index 6b5fb71a85..55c1ac1f33 100644
--- a/uberfire-server/src/main/java/org/uberfire/server/FileUploadServlet.java
+++ b/uberfire-server/src/main/java/org/uberfire/server/FileUploadServlet.java
@@ -7,7 +7,6 @@
 import javax.inject.Inject;
 import javax.inject.Named;
 import javax.servlet.ServletException;
-import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
@@ -23,73 +22,90 @@
 import org.uberfire.java.nio.file.Path;
 
 public class FileUploadServlet
-        extends HttpServlet {
+        extends BaseFilteredServlet {
 
-    private static final Logger logger = LoggerFactory.getLogger(FileUploadServlet.class);
+    private static final Logger logger = LoggerFactory.getLogger( FileUploadServlet.class );
 
     @Inject
     @Named("ioStrategy")
     private IOService ioService;
 
     @Override
-    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+    protected void doPost( HttpServletRequest request,
+                           HttpServletResponse response ) throws ServletException, IOException {
 
         try {
-            if (request.getParameter("path") != null) {
-                writeFile(ioService.get(new URI(request.getParameter("path"))), getFileItem(request));
+            if ( request.getParameter( "path" ) != null ) {
+
+                final URI uri = new URI( request.getParameter( "path" ) );
+
+                if ( !validateAccess( uri, response ) ) {
+                    return;
+                }
+
+                writeFile( ioService.get( uri ), getFileItem( request ) );
+
+                writeResponse( response, "OK" );
+            } else if ( request.getParameter( "folder" ) != null ) {
+
+                final URI uri = new URI( request.getParameter( "folder" ) + "/" + request.getParameter( "fileName" ) );
+
+                if ( !validateAccess( uri, response ) ) {
+                    return;
+                }
 
-                writeResponse(response, "OK");
-            } else if (request.getParameter("folder") != null) {
                 writeFile(
-                        ioService.get(new URI(request.getParameter("folder") + "/" + request.getParameter("fileName"))),
-                        getFileItem(request));
+                        ioService.get( uri ),
+                        getFileItem( request ) );
 
-                writeResponse(response, "OK");
+                writeResponse( response, "OK" );
             }
 
-        } catch (FileUploadException e) {
-            logError(e);
-            writeResponse(response, "FAIL");
-        } catch (URISyntaxException e) {
-            logError(e);
-            writeResponse(response, "FAIL");
+        } catch ( FileUploadException e ) {
+            logError( e );
+            writeResponse( response, "FAIL" );
+        } catch ( URISyntaxException e ) {
+            logError( e );
+            writeResponse( response, "FAIL" );
         }
     }
 
-    private FileItem getFileItem(HttpServletRequest request) throws FileUploadException {
-        Iterator iterator = getServletFileUpload().parseRequest(request).iterator();
-        while (iterator.hasNext()) {
+    private FileItem getFileItem( HttpServletRequest request ) throws FileUploadException {
+        Iterator iterator = getServletFileUpload().parseRequest( request ).iterator();
+        while ( iterator.hasNext() ) {
             FileItem item = (FileItem) iterator.next();
-            if (!item.isFormField()) {
+            if ( !item.isFormField() ) {
                 return item;
             }
         }
         return null;
     }
 
-    private void writeResponse(HttpServletResponse response, String ok) throws IOException {
-        response.setContentType("text/html");
-        response.getWriter().write(ok);
+    private void writeResponse( HttpServletResponse response,
+                                String ok ) throws IOException {
+        response.setContentType( "text/html" );
+        response.getWriter().write( ok );
     }
 
     private ServletFileUpload getServletFileUpload() {
         FileItemFactory factory = new DiskFileItemFactory();
-        ServletFileUpload upload = new ServletFileUpload(factory);
-        upload.setHeaderEncoding("UTF-8");
+        ServletFileUpload upload = new ServletFileUpload( factory );
+        upload.setHeaderEncoding( "UTF-8" );
         return upload;
     }
 
-    private void writeFile(Path path, FileItem uploadedItem) throws IOException {
-        if (!ioService.exists(path)) {
-            ioService.createFile(path);
+    private void writeFile( Path path,
+                            FileItem uploadedItem ) throws IOException {
+        if ( !ioService.exists( path ) ) {
+            ioService.createFile( path );
         }
 
-        ioService.write(path, IOUtils.toByteArray(uploadedItem.getInputStream()));
+        ioService.write( path, IOUtils.toByteArray( uploadedItem.getInputStream() ) );
 
         uploadedItem.getInputStream().close();
     }
 
-    private void logError(Throwable e) {
-        logger.error("Failed to upload a file.", e);
+    private void logError( Throwable e ) {
+        logger.error( "Failed to upload a file.", e );
     }
 }", "url": "https://github.com/uberfire/uberfire/commit/21ec50eb15.patch" } ]
null
GHSA-5f4h-mq48-hhq9
null
[ { "commit_message": "[PATCH] WBXML: add a basic sanity check for offset overflow This is a naive approach allowing to detact that something went wrong, without the need to replace all proto_tree_add_text() calls as what was done in master-2.0 branch. Bug: 12408 Change-Id: Ia14905005e17ae322c2fc639ad5e491fa08b0108 Reviewed-on: https://code.wireshark.org/review/15310 Reviewed-by: Michael Mann <mmann78@netscape.net> Reviewed-by: Pascal Quantin <pascal.quantin@gmail.com> epan/dissectors/packet-wbxml.c | 28 ++++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/wireshark/wireshark/commit/b8e0d416898bb975a02c1b55883342edc5b4c9c0.patch" } ]
null
CVE-2018-12436
wolfcrypt/src/ecc.c in wolfSSL before 3.15.1.patch allows a memory-cache side-channel attack on ECDSA signatures, aka the Return Of the Hidden Number Problem or ROHNP. To discover an ECDSA key, the attacker needs access to either the local machine or a different virtual machine on the same physical host.
[ { "commit_message": "[PATCH] Change ECDSA signing to use blinding. wolfcrypt/src/ecc.c | 68 +++++++++++++++++++++++++++++++++++---------- 1 file changed, 54 insertions(+), 14 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/wolfSSL/wolfssl/commit/9b9568d500f31f964af26ba8d01e542e1f27e5ca.patch" } ]
n/a
PYSEC-2021-218
null
[ { "commit_message": "[PATCH] Fix SEGV in CTC ops PiperOrigin-RevId: 372430279 Change-Id: I7ec2ad9d6f4d0980c33de45d27c6b17df5c6e26f tensorflow/core/kernels/ctc_decoder_ops.cc | 3 +++ 1 file changed, 3 insertions(+)", "patch_text_b64": "RnJvbSBiMWIzMjMwNDIyNjQ3NDBjMzk4MTQwZGEzMmU5M2ZiOWMyYzlmMzNlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWhhaSBNYXJ1c2VhYyA8bWloYWltYXJ1c2VhY0Bnb29nbGUuY29tPgpEYXRlOiBUaHUsIDYgTWF5IDIwMjEgMTQ6NTE6NDEgLTA3MDAKU3ViamVjdDogW1BBVENIXSBGaXggU0VHViBpbiBDVEMgb3BzCgpQaXBlck9yaWdpbi1SZXZJZDogMzcyNDMwMjc5CkNoYW5nZS1JZDogSTdlYzJhZDlkNmY0ZDA5ODBjMzNkZTQ1ZDI3YzZiMTdkZjVjNmUyNmYKLS0tCiB0ZW5zb3JmbG93L2NvcmUva2VybmVscy9jdGNfZGVjb2Rlcl9vcHMuY2MgfCAzICsrKwogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL3RlbnNvcmZsb3cvY29yZS9rZXJuZWxzL2N0Y19kZWNvZGVyX29wcy5jYyBiL3RlbnNvcmZsb3cvY29yZS9rZXJuZWxzL2N0Y19kZWNvZGVyX29wcy5jYwppbmRleCAyMjY4MWY5NzQzN2YwYy4uOWVmZGFjNjBlMzY5YzIgMTAwNjQ0Ci0tLSBhL3RlbnNvcmZsb3cvY29yZS9rZXJuZWxzL2N0Y19kZWNvZGVyX29wcy5jYworKysgYi90ZW5zb3JmbG93L2NvcmUva2VybmVscy9jdGNfZGVjb2Rlcl9vcHMuY2MKQEAgLTcwLDYgKzcwLDkgQEAgY2xhc3MgQ1RDRGVjb2RlSGVscGVyIHsKICAgICBpZiAoaW5wdXRzX3NoYXBlLmRpbXMoKSAhPSAzKSB7CiAgICAgICByZXR1cm4gZXJyb3JzOjpJbnZhbGlkQXJndW1lbnQoImlucHV0cyBpcyBub3QgYSAzLVRlbnNvciIpOwogICAgIH0KKyAgICBpZiAoaW5wdXRzX3NoYXBlLm51bV9lbGVtZW50cygpID09IDApIHsKKyAgICAgIHJldHVybiBlcnJvcnM6OkludmFsaWRBcmd1bWVudCgiaW5wdXRzIG11c3Qgbm90IGJlIGVtcHR5Iik7CisgICAgfQogCiAgICAgY29uc3QgaW50NjQgbWF4X3RpbWUgPSBpbnB1dHNfc2hhcGUuZGltX3NpemUoMCk7CiAgICAgY29uc3QgaW50NjQgYmF0Y2hfc2l6ZSA9IGlucHV0c19zaGFwZS5kaW1fc2l6ZSgxKTs=", "url": "https://github.com/tensorflow/tensorflow/commit/b1b323042264740c398140da32e93fb9c2c9f33e.patch" } ]
null
GHSA-765j-9r45-w2q2
Flask App Builder has an Authentication Bypass vulnerability when using non AUTH_DB methods
null
[ { "commit_message": "[PATCH] fix: don't register reset my password when not on AUTH_DB (#2384) * fix: don't register reset my password when not on AUTH_DB * fix: don't register reset my password when not on AUTH_DB * add test * fix lint flask_appbuilder/security/manager.py | 4 ++-- tests/security/test_auth_oauth.py | 20 ++++++++++++++++++++ 2 files changed, 22 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/dpgaspar/Flask-AppBuilder/commit/a942a9cc5775752f9a02f97fd8198dd288fa93ee.patch" } ]
null
GHSA-3gv2-29qc-v67m
Symfony vulnerable to Session Fixation of CSRF tokens
null
[ { "commit_message": "[PATCH] [Security/Http] Remove CSRF tokens from storage on successful login Resources/config/security.xml | 1 + Tests/Functional/CsrfFormLoginTest.php | 6 ++++++ Tests/Functional/LogoutTest.php | 4 +--- composer.json | 2 +- 4 files changed, 9 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/symfony/security-bundle/commit/076fd2088ada33d760758d98ff07ddedbf567946.patch" }, { "commit_message": "[PATCH] [Security/Http] Remove CSRF tokens from storage on successful login .../SecurityBundle/Resources/config/security.xml | 1 + .../Tests/Functional/CsrfFormLoginTest.php | 6 ++++++ .../SecurityBundle/Tests/Functional/LogoutTest.php | 4 +--- src/Symfony/Bundle/SecurityBundle/composer.json | 2 +- .../Http/Session/SessionAuthenticationStrategy.php | 14 +++++++++++--- .../Session/SessionAuthenticationStrategyTest.php | 13 +++++++++++++ 6 files changed, 33 insertions(+), 7 deletions(-)", "patch_text_b64": "From 5909d74ecee359ea4982fcf4331aaf2e489a1fd4 Mon Sep 17 00:00:00 2001
From: Nicolas Grekas <nicolas.grekas@gmail.com>
Date: Mon, 23 Jan 2023 19:43:46 +0100
Subject: [PATCH] [Security/Http] Remove CSRF tokens from storage on successful
 login

---
 .../SecurityBundle/Resources/config/security.xml   |  1 +
 .../Tests/Functional/CsrfFormLoginTest.php         |  6 ++++++
 .../SecurityBundle/Tests/Functional/LogoutTest.php |  4 +---
 src/Symfony/Bundle/SecurityBundle/composer.json    |  2 +-
 .../Http/Session/SessionAuthenticationStrategy.php | 14 +++++++++++---
 .../Session/SessionAuthenticationStrategyTest.php  | 13 +++++++++++++
 6 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/src/Symfony/Bundle/SecurityBundle/Resources/config/security.xml b/src/Symfony/Bundle/SecurityBundle/Resources/config/security.xml
index 3491383b8bba6..eabe5e547fada 100644
--- a/src/Symfony/Bundle/SecurityBundle/Resources/config/security.xml
+++ b/src/Symfony/Bundle/SecurityBundle/Resources/config/security.xml
@@ -63,6 +63,7 @@
 
         <service id="security.authentication.session_strategy" class="Symfony\Component\Security\Http\Session\SessionAuthenticationStrategy">
             <argument>%security.authentication.session_strategy.strategy%</argument>
+            <argument type="service" id="security.csrf.token_storage" on-invalid="ignore" />
         </service>
         <service id="Symfony\Component\Security\Http\Session\SessionAuthenticationStrategyInterface" alias="security.authentication.session_strategy" />
 
diff --git a/src/Symfony/Bundle/SecurityBundle/Tests/Functional/CsrfFormLoginTest.php b/src/Symfony/Bundle/SecurityBundle/Tests/Functional/CsrfFormLoginTest.php
index 1a672d70f8335..08ea67a6416fa 100644
--- a/src/Symfony/Bundle/SecurityBundle/Tests/Functional/CsrfFormLoginTest.php
+++ b/src/Symfony/Bundle/SecurityBundle/Tests/Functional/CsrfFormLoginTest.php
@@ -19,12 +19,15 @@ class CsrfFormLoginTest extends AbstractWebTestCase
     public function testFormLoginAndLogoutWithCsrfTokens($config)
     {
         $client = $this->createClient(['test_case' => 'CsrfFormLogin', 'root_config' => $config]);
+        static::$container->get('security.csrf.token_storage')->setToken('foo', 'bar');
 
         $form = $client->request('GET', '/login')->selectButton('login')->form();
         $form['user_login[username]'] = 'johannes';
         $form['user_login[password]'] = 'test';
         $client->submit($form);
 
+        $this->assertFalse(static::$container->get('security.csrf.token_storage')->hasToken('foo'));
+
         $this->assertRedirect($client->getResponse(), '/profile');
 
         $crawler = $client->followRedirect();
@@ -48,11 +51,14 @@ public function testFormLoginAndLogoutWithCsrfTokens($config)
     public function testFormLoginWithInvalidCsrfToken($config)
     {
         $client = $this->createClient(['test_case' => 'CsrfFormLogin', 'root_config' => $config]);
+        static::$container->get('security.csrf.token_storage')->setToken('foo', 'bar');
 
         $form = $client->request('GET', '/login')->selectButton('login')->form();
         $form['user_login[_token]'] = '';
         $client->submit($form);
 
+        $this->assertTrue(static::$container->get('security.csrf.token_storage')->hasToken('foo'));
+
         $this->assertRedirect($client->getResponse(), '/login');
 
         $text = $client->followRedirect()->text(null, true);
diff --git a/src/Symfony/Bundle/SecurityBundle/Tests/Functional/LogoutTest.php b/src/Symfony/Bundle/SecurityBundle/Tests/Functional/LogoutTest.php
index cb7868f3256ef..465027f42f0c8 100644
--- a/src/Symfony/Bundle/SecurityBundle/Tests/Functional/LogoutTest.php
+++ b/src/Symfony/Bundle/SecurityBundle/Tests/Functional/LogoutTest.php
@@ -36,15 +36,13 @@ public function testSessionLessRememberMeLogout()
     public function testCsrfTokensAreClearedOnLogout()
     {
         $client = $this->createClient(['test_case' => 'LogoutWithoutSessionInvalidation', 'root_config' => 'config.yml']);
-        static::$container->get('security.csrf.token_storage')->setToken('foo', 'bar');
 
         $client->request('POST', '/login', [
             '_username' => 'johannes',
             '_password' => 'test',
         ]);
 
-        $this->assertTrue(static::$container->get('security.csrf.token_storage')->hasToken('foo'));
-        $this->assertSame('bar', static::$container->get('security.csrf.token_storage')->getToken('foo'));
+        static::$container->get('security.csrf.token_storage')->setToken('foo', 'bar');
 
         $client->request('GET', '/logout');
 
diff --git a/src/Symfony/Bundle/SecurityBundle/composer.json b/src/Symfony/Bundle/SecurityBundle/composer.json
index 1106acfa008c6..4061646f399ff 100644
--- a/src/Symfony/Bundle/SecurityBundle/composer.json
+++ b/src/Symfony/Bundle/SecurityBundle/composer.json
@@ -25,7 +25,7 @@
         "symfony/security-core": "^4.4",
         "symfony/security-csrf": "^4.2|^5.0",
         "symfony/security-guard": "^4.2|^5.0",
-        "symfony/security-http": "^4.4.5"
+        "symfony/security-http": "^4.4.50"
     },
     "require-dev": {
         "doctrine/annotations": "^1.10.4",
diff --git a/src/Symfony/Component/Security/Http/Session/SessionAuthenticationStrategy.php b/src/Symfony/Component/Security/Http/Session/SessionAuthenticationStrategy.php
index a4bb88818d452..73691058d0ce6 100644
--- a/src/Symfony/Component/Security/Http/Session/SessionAuthenticationStrategy.php
+++ b/src/Symfony/Component/Security/Http/Session/SessionAuthenticationStrategy.php
@@ -13,6 +13,7 @@
 
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
+use Symfony\Component\Security\Csrf\TokenStorage\ClearableTokenStorageInterface;
 
 /**
  * The default session strategy implementation.
@@ -31,10 +32,15 @@ class SessionAuthenticationStrategy implements SessionAuthenticationStrategyInte
     public const INVALIDATE = 'invalidate';
 
     private $strategy;
+    private $csrfTokenStorage = null;
 
-    public function __construct(string $strategy)
+    public function __construct(string $strategy, ClearableTokenStorageInterface $csrfTokenStorage = null)
     {
         $this->strategy = $strategy;
+
+        if (self::MIGRATE === $strategy) {
+            $this->csrfTokenStorage = $csrfTokenStorage;
+        }
     }
 
     /**
@@ -47,10 +53,12 @@ public function onAuthentication(Request $request, TokenInterface $token)
                 return;
 
             case self::MIGRATE:
-                // Note: this logic is duplicated in several authentication listeners
-                // until Symfony 5.0 due to a security fix with BC compat
                 $request->getSession()->migrate(true);
 
+                if ($this->csrfTokenStorage) {
+                    $this->csrfTokenStorage->clear();
+                }
+
                 return;
 
             case self::INVALIDATE:
diff --git a/src/Symfony/Component/Security/Http/Tests/Session/SessionAuthenticationStrategyTest.php b/src/Symfony/Component/Security/Http/Tests/Session/SessionAuthenticationStrategyTest.php
index 010bb0edf2cfd..2051f34239144 100644
--- a/src/Symfony/Component/Security/Http/Tests/Session/SessionAuthenticationStrategyTest.php
+++ b/src/Symfony/Component/Security/Http/Tests/Session/SessionAuthenticationStrategyTest.php
@@ -14,6 +14,7 @@
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Symfony\Component\Security\Csrf\TokenStorage\ClearableTokenStorageInterface;
 use Symfony\Component\Security\Http\Session\SessionAuthenticationStrategy;
 use Symfony\Component\Security\Http\Tests\Fixtures\TokenInterface;
 
@@ -57,6 +58,18 @@ public function testSessionIsInvalidated()
         $strategy->onAuthentication($this->getRequest($session), $this->createMock(TokenInterface::class));
     }
 
+    public function testCsrfTokensAreCleared()
+    {
+        $session = $this->createMock(SessionInterface::class);
+        $session->expects($this->once())->method('migrate')->with($this->equalTo(true));
+
+        $csrfStorage = $this->createMock(ClearableTokenStorageInterface::class);
+        $csrfStorage->expects($this->once())->method('clear');
+
+        $strategy = new SessionAuthenticationStrategy(SessionAuthenticationStrategy::MIGRATE, $csrfStorage);
+        $strategy->onAuthentication($this->getRequest($session), $this->createMock(TokenInterface::class));
+    }
+
     private function getRequest($session = null)
     {
         $request = $this->createMock(Request::class);", "url": "https://github.com/symfony/symfony/commit/5909d74ecee359ea4982fcf4331aaf2e489a1fd4.patch" } ]
null
CVE-2023-30625
rudder-server vulnerable to SQL Injection
rudder-server is part of RudderStack, an open source Customer Data Platform (CDP). Versions of rudder-server prior to 1.3.0-rc.1 are vulnerable to SQL injection. This issue may lead to Remote Code Execution (RCE) due to the `rudder` role in PostgresSQL having superuser permissions by default. Version 1.3.0-rc.1 contains patches for this issue.
[ { "commit_message": "[PATCH] fix: always use a sql safe table name in failed events manager (#2664) router/failed-events-manager.go | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/rudderlabs/rudder-server/commit/0d061ff2d8c16845179d215bf8012afceba12a30.patch" }, { "commit_message": "[PATCH] fix: changed query to accept user input in prepared sql statement (#2652) * Changed query to accept user input in prepared sql statement * Changed query to accept user input in parameterized query * Changed query to accept user input in parameterized query * Changed query to accept user input in parameterized query * Changed query to accept user input in parameterized query warehouse/warehouse.go | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/rudderlabs/rudder-server/commit/2f956b7eb3d5eb2de3e79d7df2c87405af25071e.patch" }, { "commit_message": "[PATCH] fix: properly escape table name when querying for failed events (#2663) router/failed-events-manager.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/rudderlabs/rudder-server/commit/9c009d9775abc99e72fc470f4c4c8e8f1775e82a.patch" } ]
CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
GHSA-478m-xrv3-7r93
null
[ { "commit_message": "[PATCH] bugfix: prevented request smuggling in the ngx.location.capture API. Signed-off-by: Yichun Zhang (agentzh) <yichun@openresty.com> src/ngx_http_lua_subrequest.c | 196 +++++-------- t/020-subrequest.t | 520 +++++++++++++++++++++++++++++++++- 2 files changed, 585 insertions(+), 131 deletions(-)", "patch_text_b64": "From 9ab38e8ee35fc08a57636b1b6190dca70b0076fa Mon Sep 17 00:00:00 2001
From: Thibault Charbonnier <thibaultcha@me.com>
Date: Mon, 23 Mar 2020 19:40:47 -0700
Subject: [PATCH] bugfix: prevented request smuggling in the
 ngx.location.capture API.

Signed-off-by: Yichun Zhang (agentzh) <yichun@openresty.com>
---
 src/ngx_http_lua_subrequest.c | 196 +++++--------
 t/020-subrequest.t            | 520 +++++++++++++++++++++++++++++++++-
 2 files changed, 585 insertions(+), 131 deletions(-)

diff --git a/src/ngx_http_lua_subrequest.c b/src/ngx_http_lua_subrequest.c
index 19a88d995f..b866955569 100644
--- a/src/ngx_http_lua_subrequest.c
+++ b/src/ngx_http_lua_subrequest.c
@@ -57,8 +57,6 @@ static ngx_str_t  ngx_http_lua_content_length_header_key =
     ngx_string("Content-Length");
 
 
-static ngx_int_t ngx_http_lua_set_content_length_header(ngx_http_request_t *r,
-    off_t len);
 static ngx_int_t ngx_http_lua_adjust_subrequest(ngx_http_request_t *sr,
     ngx_uint_t method, int forward_body,
     ngx_http_request_body_t *body, unsigned vars_action,
@@ -79,7 +77,7 @@ static void ngx_http_lua_cancel_subreq(ngx_http_request_t *r);
 static ngx_int_t ngx_http_post_request_to_head(ngx_http_request_t *r);
 static ngx_int_t ngx_http_lua_copy_in_file_request_body(ngx_http_request_t *r);
 static ngx_int_t ngx_http_lua_copy_request_headers(ngx_http_request_t *sr,
-    ngx_http_request_t *r);
+    ngx_http_request_t *pr, int pr_not_chunked);
 
 
 enum {
@@ -634,8 +632,8 @@ ngx_http_lua_adjust_subrequest(ngx_http_request_t *sr, ngx_uint_t method,
     unsigned vars_action, ngx_array_t *extra_vars)
 {
     ngx_http_request_t          *r;
-    ngx_int_t                    rc;
     ngx_http_core_main_conf_t   *cmcf;
+    int                          pr_not_chunked = 0;
     size_t                       size;
 
     r = sr->parent;
@@ -645,46 +643,32 @@ ngx_http_lua_adjust_subrequest(ngx_http_request_t *sr, ngx_uint_t method,
     if (body) {
         sr->request_body = body;
 
-        rc = ngx_http_lua_set_content_length_header(sr,
-                                                    body->buf
-                                                    ? ngx_buf_size(body->buf)
-                                                    : 0);
-
-        if (rc != NGX_OK) {
-            return NGX_ERROR;
-        }
-
     } else if (!always_forward_body
                && method != NGX_HTTP_PUT
                && method != NGX_HTTP_POST
                && r->headers_in.content_length_n > 0)
     {
-        rc = ngx_http_lua_set_content_length_header(sr, 0);
-        if (rc != NGX_OK) {
-            return NGX_ERROR;
-        }
-
-#if 1
         sr->request_body = NULL;
-#endif
 
     } else {
-        if (ngx_http_lua_copy_request_headers(sr, r) != NGX_OK) {
-            return NGX_ERROR;
+        if (!r->headers_in.chunked) {
+            pr_not_chunked = 1;
         }
 
-        if (sr->request_body) {
+        if (sr->request_body && sr->request_body->temp_file) {
 
             /* deep-copy the request body */
 
-            if (sr->request_body->temp_file) {
-                if (ngx_http_lua_copy_in_file_request_body(sr) != NGX_OK) {
-                    return NGX_ERROR;
-                }
+            if (ngx_http_lua_copy_in_file_request_body(sr) != NGX_OK) {
+                return NGX_ERROR;
             }
         }
     }
 
+    if (ngx_http_lua_copy_request_headers(sr, r, pr_not_chunked) != NGX_OK) {
+        return NGX_ERROR;
+    }
+
     sr->method = method;
 
     switch (method) {
@@ -1134,100 +1118,6 @@ ngx_http_lua_post_subrequest(ngx_http_request_t *r, void *data, ngx_int_t rc)
 }
 
 
-static ngx_int_t
-ngx_http_lua_set_content_length_header(ngx_http_request_t *r, off_t len)
-{
-    ngx_table_elt_t                 *h, *header;
-    u_char                          *p;
-    ngx_list_part_t                 *part;
-    ngx_http_request_t              *pr;
-    ngx_uint_t                       i;
-
-    r->headers_in.content_length_n = len;
-
-    if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
-                      sizeof(ngx_table_elt_t)) != NGX_OK)
-    {
-        return NGX_ERROR;
-    }
-
-    h = ngx_list_push(&r->headers_in.headers);
-    if (h == NULL) {
-        return NGX_ERROR;
-    }
-
-    h->key = ngx_http_lua_content_length_header_key;
-    h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
-    if (h->lowcase_key == NULL) {
-        return NGX_ERROR;
-    }
-
-    ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
-
-    r->headers_in.content_length = h;
-
-    p = ngx_palloc(r->pool, NGX_OFF_T_LEN);
-    if (p == NULL) {
-        return NGX_ERROR;
-    }
-
-    h->value.data = p;
-
-    h->value.len = ngx_sprintf(h->value.data, "%O", len) - h->value.data;
-
-    h->hash = ngx_http_lua_content_length_hash;
-
-#if 0
-    dd("content length hash: %lu == %lu", (unsigned long) h->hash,
-       ngx_hash_key_lc((u_char *) "Content-Length",
-                       sizeof("Content-Length") - 1));
-#endif
-
-    dd("r content length: %.*s",
-       (int) r->headers_in.content_length->value.len,
-       r->headers_in.content_length->value.data);
-
-    pr = r->parent;
-
-    if (pr == NULL) {
-        return NGX_OK;
-    }
-
-    /* forward the parent request's all other request headers */
-
-    part = &pr->headers_in.headers.part;
-    header = part->elts;
-
-    for (i = 0; /* void */; i++) {
-
-        if (i >= part->nelts) {
-            if (part->next == NULL) {
-                break;
-            }
-
-            part = part->next;
-            header = part->elts;
-            i = 0;
-        }
-
-        if (header[i].key.len == sizeof("Content-Length") - 1
-            && ngx_strncasecmp(header[i].key.data, (u_char *) "Content-Length",
-                               sizeof("Content-Length") - 1) == 0)
-        {
-            continue;
-        }
-
-        if (ngx_http_lua_set_input_header(r, header[i].key,
-                                          header[i].value, 0) == NGX_ERROR)
-        {
-            return NGX_ERROR;
-        }
-    }
-
-    return NGX_OK;
-}
-
-
 static void
 ngx_http_lua_handle_subreq_responses(ngx_http_request_t *r,
     ngx_http_lua_ctx_t *ctx)
@@ -1742,11 +1632,17 @@ ngx_http_lua_copy_in_file_request_body(ngx_http_request_t *r)
 
 
 static ngx_int_t
-ngx_http_lua_copy_request_headers(ngx_http_request_t *sr, ngx_http_request_t *r)
+ngx_http_lua_copy_request_headers(ngx_http_request_t *sr,
+    ngx_http_request_t *pr, int pr_not_chunked)
 {
-    ngx_table_elt_t                 *header;
+    ngx_table_elt_t                 *clh, *header;
     ngx_list_part_t                 *part;
     ngx_uint_t                       i;
+    u_char                          *p;
+    off_t                            len;
+
+    dd("before: parent req headers count: %d",
+       (int) pr->headers_in.headers.part.nelts);
 
     if (ngx_list_init(&sr->headers_in.headers, sr->pool, 20,
                       sizeof(ngx_table_elt_t)) != NGX_OK)
@@ -1754,10 +1650,46 @@ ngx_http_lua_copy_request_headers(ngx_http_request_t *sr, ngx_http_request_t *r)
         return NGX_ERROR;
     }
 
-    dd("before: parent req headers count: %d",
-       (int) r->headers_in.headers.part.nelts);
+    if (sr->request_body && !pr_not_chunked) {
+
+        /* craft our own Content-Length */
+
+        len = sr->request_body->buf ? ngx_buf_size(sr->request_body->buf) : 0;
+
+        clh = ngx_list_push(&sr->headers_in.headers);
+        if (clh == NULL) {
+            return NGX_ERROR;
+        }
 
-    part = &r->headers_in.headers.part;
+        clh->hash = ngx_http_lua_content_length_hash;
+        clh->key = ngx_http_lua_content_length_header_key;
+        clh->lowcase_key = ngx_pnalloc(sr->pool, clh->key.len);
+        if (clh->lowcase_key == NULL) {
+            return NGX_ERROR;
+        }
+
+        ngx_strlow(clh->lowcase_key, clh->key.data, clh->key.len);
+
+        p = ngx_palloc(sr->pool, NGX_OFF_T_LEN);
+        if (p == NULL) {
+            return NGX_ERROR;
+        }
+
+        clh->value.data = p;
+        clh->value.len = ngx_sprintf(clh->value.data, "%O", len)
+                         - clh->value.data;
+
+        sr->headers_in.content_length = clh;
+        sr->headers_in.content_length_n = len;
+
+        dd("sr crafted content-length: %.*s",
+           (int) sr->headers_in.content_length->value.len,
+           sr->headers_in.content_length->value.data);
+    }
+
+    /* copy the parent request's headers */
+
+    part = &pr->headers_in.headers.part;
     header = part->elts;
 
     for (i = 0; /* void */; i++) {
@@ -1772,7 +1704,14 @@ ngx_http_lua_copy_request_headers(ngx_http_request_t *sr, ngx_http_request_t *r)
             i = 0;
         }
 
-        dd("setting request header %.*s: %.*s", (int) header[i].key.len,
+        if (!pr_not_chunked && header[i].key.len == sizeof("Content-Length") - 1
+            && ngx_strncasecmp(header[i].key.data, (u_char *) "Content-Length",
+                               sizeof("Content-Length") - 1) == 0)
+        {
+            continue;
+        }
+
+        dd("sr copied req header %.*s: %.*s", (int) header[i].key.len,
            header[i].key.data, (int) header[i].value.len,
            header[i].value.data);
 
@@ -1784,9 +1723,10 @@ ngx_http_lua_copy_request_headers(ngx_http_request_t *sr, ngx_http_request_t *r)
     }
 
     dd("after: parent req headers count: %d",
-       (int) r->headers_in.headers.part.nelts);
+       (int) pr->headers_in.headers.part.nelts);
 
     return NGX_OK;
 }
 
+
 /* vi:set ft=c ts=4 sw=4 et fdm=marker: */
diff --git a/t/020-subrequest.t b/t/020-subrequest.t
index 5a386dbe1a..18befbd761 100644
--- a/t/020-subrequest.t
+++ b/t/020-subrequest.t
@@ -14,6 +14,7 @@ repeat_each(2);
 plan tests => repeat_each() * (blocks() * 3 + 23);
 
 $ENV{TEST_NGINX_MEMCACHED_PORT} ||= 11211;
+$ENV{TEST_NGINX_HTML_DIR} ||= html_dir();
 
 #no_diff();
 no_long_string();
@@ -210,7 +211,7 @@ GET
 
 
 
-=== TEST 8: PUT (nobody, proxy method)
+=== TEST 8: PUT (with body, proxy method)
 --- config
     location /other {
         default_type 'foo/bar';
@@ -242,7 +243,7 @@ hello
 
 
 
-=== TEST 9: PUT (nobody, no proxy method)
+=== TEST 9: PUT (with body, no proxy method)
 --- config
     location /other {
         default_type 'foo/bar';
@@ -271,7 +272,7 @@ hello
 
 
 
-=== TEST 10: PUT (nobody, no proxy method)
+=== TEST 10: PUT (no body, no proxy method)
 --- config
     location /other {
         default_type 'foo/bar';
@@ -2877,3 +2878,516 @@ DELETE /file.txt, response status: 204
 --- no_error_log
 [error]
 --- error_code: 200
+
+
+
+=== TEST 77: avoid request smuggling 1/4 (default capture + smuggle in header)
+--- http_config
+    upstream backend {
+        server unix:$TEST_NGINX_HTML_DIR/nginx.sock;
+        keepalive 32;
+    }
+
+    server {
+        listen unix:$TEST_NGINX_HTML_DIR/nginx.sock;
+
+        location / {
+            content_by_lua_block {
+                ngx.say("method: ", ngx.var.request_method,
+                        ", uri: ", ngx.var.uri,
+                        ", X: ", ngx.var.http_x)
+            }
+        }
+    }
+--- config
+    location /proxy {
+        proxy_http_version 1.1;
+        proxy_set_header   Connection "";
+        proxy_pass         http://backend/foo;
+    }
+
+    location /capture {
+        server_tokens off;
+        more_clear_headers Date;
+
+        content_by_lua_block {
+            local res = ngx.location.capture("/proxy")
+            ngx.print(res.body)
+        }
+    }
+
+    location /t {
+        content_by_lua_block {
+            local req = [[
+GET /capture HTTP/1.1
+Host: test.com
+Content-Length: 37
+Transfer-Encoding: chunked
+
+0
+
+GET /capture HTTP/1.1
+Host: test.com
+X: GET /bar HTTP/1.0
+
+]]
+
+            local sock = ngx.socket.tcp()
+            sock:settimeout(1000)
+
+            local ok, err = sock:connect("127.0.0.1", $TEST_NGINX_SERVER_PORT)
+            if not ok then
+                ngx.say("failed to connect: ", err)
+                return
+            end
+
+            local bytes, err = sock:send(req)
+            if not bytes then
+                ngx.say("failed to send req: ", err)
+                return
+            end
+
+            ngx.say("req bytes: ", bytes)
+
+            local n_resp = 0
+
+            local reader = sock:receiveuntil("\r\n")
+            while true do
+                local line, err = reader()
+                if line then
+                    ngx.say(line)
+                    if line == "0" then
+                        n_resp = n_resp + 1
+                    end
+
+                    if n_resp >= 2 then
+                        break
+                    end
+
+                else
+                    ngx.say("err: ", err)
+                    break
+                end
+            end
+
+            sock:close()
+        }
+    }
+--- request
+GET /t
+--- response_body
+req bytes: 146
+HTTP/1.1 200 OK
+Server: nginx
+Content-Type: text/plain
+Transfer-Encoding: chunked
+Connection: keep-alive
+
+1f
+method: GET, uri: /foo, X: nil
+
+0
+
+HTTP/1.1 200 OK
+Server: nginx
+Content-Type: text/plain
+Transfer-Encoding: chunked
+Connection: keep-alive
+
+2d
+method: GET, uri: /foo, X: GET /bar HTTP/1.0
+
+0
+--- no_error_log
+[error]
+
+
+
+=== TEST 78: avoid request smuggling 2/4 (POST capture + smuggle in body)
+--- http_config
+    upstream backend {
+        server unix:$TEST_NGINX_HTML_DIR/nginx.sock;
+        keepalive 32;
+    }
+
+    server {
+        listen unix:$TEST_NGINX_HTML_DIR/nginx.sock;
+
+        location / {
+            content_by_lua_block {
+                ngx.say("method: ", ngx.var.request_method,
+                        ", uri: ", ngx.var.uri)
+            }
+        }
+    }
+--- config
+    location /proxy {
+        proxy_http_version 1.1;
+        proxy_set_header   Connection "";
+        proxy_pass         http://backend/foo;
+    }
+
+    location /capture {
+        server_tokens off;
+        more_clear_headers Date;
+
+        content_by_lua_block {
+            ngx.req.read_body()
+            local res = ngx.location.capture("/proxy", { method = ngx.HTTP_POST })
+            ngx.print(res.body)
+        }
+    }
+
+    location /t {
+        content_by_lua_block {
+            local req = [[
+GET /capture HTTP/1.1
+Host: test.com
+Content-Length: 57
+Transfer-Encoding: chunked
+
+0
+
+POST /capture HTTP/1.1
+Host: test.com
+Content-Length: 60
+
+POST /bar HTTP/1.1
+Host: test.com
+Content-Length: 5
+
+hello
+
+]]
+
+            local sock = ngx.socket.tcp()
+            sock:settimeout(1000)
+
+            local ok, err = sock:connect("127.0.0.1", $TEST_NGINX_SERVER_PORT)
+            if not ok then
+                ngx.say("failed to connect: ", err)
+                return
+            end
+
+            local bytes, err = sock:send(req)
+            if not bytes then
+                ngx.say("failed to send req: ", err)
+                return
+            end
+
+            ngx.say("req bytes: ", bytes)
+
+            local n_resp = 0
+
+            local reader = sock:receiveuntil("\r\n")
+            while true do
+                local line, err = reader()
+                if line then
+                    ngx.say(line)
+                    if line == "0" then
+                        n_resp = n_resp + 1
+                    end
+
+                    if n_resp >= 2 then
+                        break
+                    end
+
+                else
+                    ngx.say("err: ", err)
+                    break
+                end
+            end
+
+            sock:close()
+        }
+    }
+--- request
+GET /t
+--- response_body
+req bytes: 205
+HTTP/1.1 200 OK
+Server: nginx
+Content-Type: text/plain
+Transfer-Encoding: chunked
+Connection: keep-alive
+
+18
+method: POST, uri: /foo
+
+0
+
+HTTP/1.1 200 OK
+Server: nginx
+Content-Type: text/plain
+Transfer-Encoding: chunked
+Connection: keep-alive
+
+18
+method: POST, uri: /foo
+
+0
+--- no_error_log
+[error]
+
+
+
+=== TEST 79: avoid request smuggling 3/4 (POST capture w/ always_forward_body + smuggle in body)
+--- http_config
+    upstream backend {
+        server unix:$TEST_NGINX_HTML_DIR/nginx.sock;
+        keepalive 32;
+    }
+
+    server {
+        listen unix:$TEST_NGINX_HTML_DIR/nginx.sock;
+
+        location / {
+            content_by_lua_block {
+                ngx.say("method: ", ngx.var.request_method,
+                        ", uri: ", ngx.var.uri)
+            }
+        }
+    }
+--- config
+    location /proxy {
+        proxy_http_version 1.1;
+        proxy_set_header   Connection "";
+        proxy_pass         http://backend/foo;
+    }
+
+    location /capture {
+        server_tokens off;
+        more_clear_headers Date;
+
+        content_by_lua_block {
+            ngx.req.read_body()
+            local res = ngx.location.capture("/proxy", {
+                method = ngx.HTTP_POST,
+                always_forward_body = true
+            })
+            ngx.print(res.body)
+        }
+    }
+
+    location /t {
+        content_by_lua_block {
+            local req = [[
+GET /capture HTTP/1.1
+Host: test.com
+Content-Length: 57
+Transfer-Encoding: chunked
+
+0
+
+POST /capture HTTP/1.1
+Host: test.com
+Content-Length: 60
+
+POST /bar HTTP/1.1
+Host: test.com
+Content-Length: 5
+
+hello
+
+]]
+
+            local sock = ngx.socket.tcp()
+            sock:settimeout(1000)
+
+            local ok, err = sock:connect("127.0.0.1", $TEST_NGINX_SERVER_PORT)
+            if not ok then
+                ngx.say("failed to connect: ", err)
+                return
+            end
+
+            local bytes, err = sock:send(req)
+            if not bytes then
+                ngx.say("failed to send req: ", err)
+                return
+            end
+
+            ngx.say("req bytes: ", bytes)
+
+            local n_resp = 0
+
+            local reader = sock:receiveuntil("\r\n")
+            while true do
+                local line, err = reader()
+                if line then
+                    ngx.say(line)
+                    if line == "0" then
+                        n_resp = n_resp + 1
+                    end
+
+                    if n_resp >= 2 then
+                        break
+                    end
+
+                else
+                    ngx.say("err: ", err)
+                    break
+                end
+            end
+
+            sock:close()
+        }
+    }
+--- request
+GET /t
+--- response_body
+req bytes: 205
+HTTP/1.1 200 OK
+Server: nginx
+Content-Type: text/plain
+Transfer-Encoding: chunked
+Connection: keep-alive
+
+18
+method: POST, uri: /foo
+
+0
+
+HTTP/1.1 200 OK
+Server: nginx
+Content-Type: text/plain
+Transfer-Encoding: chunked
+Connection: keep-alive
+
+18
+method: POST, uri: /foo
+
+0
+--- no_error_log
+[error]
+
+
+
+=== TEST 80: avoid request smuggling 4/4 (POST capture w/ body + smuggle in body)
+--- http_config
+    upstream backend {
+        server unix:$TEST_NGINX_HTML_DIR/nginx.sock;
+        keepalive 32;
+    }
+
+    server {
+        listen unix:$TEST_NGINX_HTML_DIR/nginx.sock;
+
+        location / {
+            content_by_lua_block {
+                ngx.say("method: ", ngx.var.request_method,
+                        ", uri: ", ngx.var.uri)
+            }
+        }
+    }
+--- config
+    location /proxy {
+        proxy_http_version 1.1;
+        proxy_set_header   Connection "";
+        proxy_pass         http://backend/foo;
+    }
+
+    location /capture {
+        server_tokens off;
+        more_clear_headers Date;
+
+        content_by_lua_block {
+            ngx.req.read_body()
+            local res = ngx.location.capture("/proxy", {
+                method = ngx.HTTP_POST,
+                always_forward_body = true,
+                body = ngx.req.get_body_data()
+            })
+            ngx.print(res.body)
+        }
+    }
+
+    location /t {
+        content_by_lua_block {
+            local req = [[
+GET /capture HTTP/1.1
+Host: test.com
+Content-Length: 57
+Transfer-Encoding: chunked
+
+0
+
+POST /capture HTTP/1.1
+Host: test.com
+Content-Length: 60
+
+POST /bar HTTP/1.1
+Host: test.com
+Content-Length: 5
+
+hello
+
+]]
+
+            local sock = ngx.socket.tcp()
+            sock:settimeout(1000)
+
+            local ok, err = sock:connect("127.0.0.1", $TEST_NGINX_SERVER_PORT)
+            if not ok then
+                ngx.say("failed to connect: ", err)
+                return
+            end
+
+            local bytes, err = sock:send(req)
+            if not bytes then
+                ngx.say("failed to send req: ", err)
+                return
+            end
+
+            ngx.say("req bytes: ", bytes)
+
+            local n_resp = 0
+
+            local reader = sock:receiveuntil("\r\n")
+            while true do
+                local line, err = reader()
+                if line then
+                    ngx.say(line)
+                    if line == "0" then
+                        n_resp = n_resp + 1
+                    end
+
+                    if n_resp >= 2 then
+                        break
+                    end
+
+                else
+                    ngx.say("err: ", err)
+                    break
+                end
+            end
+
+            sock:close()
+        }
+    }
+--- request
+GET /t
+--- response_body
+req bytes: 205
+HTTP/1.1 200 OK
+Server: nginx
+Content-Type: text/plain
+Transfer-Encoding: chunked
+Connection: keep-alive
+
+18
+method: POST, uri: /foo
+
+0
+
+HTTP/1.1 200 OK
+Server: nginx
+Content-Type: text/plain
+Transfer-Encoding: chunked
+Connection: keep-alive
+
+18
+method: POST, uri: /foo
+
+0
+--- no_error_log
+[error]", "url": "https://github.com/openresty/lua-nginx-module/commit/9ab38e8ee35fc08a57636b1b6190dca70b0076fa.patch" } ]
null
CVE-2021-32855
vditor vulnerable to Cross-site Scripting
Vditor is a browser-side Markdown editor. Versions prior to 3.8.7 are vulnerable to copy-paste cross-site scripting (XSS). For this particular type of XSS, the victim needs to be fooled into copying a malicious payload into the text editor. Version 3.8.7 contains a patch for this issue.
[ { "commit_message": "[PATCH] :lock: https://github.com/Vanessa219/vditor/issues/1085 src/ts/util/fixBrowserBehavior.ts | 2 +- types/index.d.ts | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSAxYjIzODJkN2Y4YTRlZTUwOWQ5MjQ1ZGI0NDUwZDkyNmEwYjI0MTQ2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBWYW5lc3NhIDxsbHkyMTlAZ21haWwuY29tPgpEYXRlOiBUdWUsIDIxIFNlcCAyMDIxIDIxOjM0OjM4ICswODAwClN1YmplY3Q6IFtQQVRDSF0gOmxvY2s6IGh0dHBzOi8vZ2l0aHViLmNvbS9WYW5lc3NhMjE5L3ZkaXRvci9pc3N1ZXMvMTA4NQoKLS0tCiBzcmMvdHMvdXRpbC9maXhCcm93c2VyQmVoYXZpb3IudHMgfCAyICstCiB0eXBlcy9pbmRleC5kLnRzICAgICAgICAgICAgICAgICAgfCAzICsrKwogMiBmaWxlcyBjaGFuZ2VkLCA0IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zcmMvdHMvdXRpbC9maXhCcm93c2VyQmVoYXZpb3IudHMgYi9zcmMvdHMvdXRpbC9maXhCcm93c2VyQmVoYXZpb3IudHMKaW5kZXggMTQ0ZDI2ZDQyLi40ZTI0MzQ4YmMgMTAwNjQ0Ci0tLSBhL3NyYy90cy91dGlsL2ZpeEJyb3dzZXJCZWhhdmlvci50cworKysgYi9zcmMvdHMvdXRpbC9maXhCcm93c2VyQmVoYXZpb3IudHMKQEAgLTEzNTUsNyArMTM1NSw3IEBAIGV4cG9ydCBjb25zdCBwYXN0ZSA9IGFzeW5jICh2ZGl0b3I6IElWZGl0b3IsIGV2ZW50OiAoQ2xpcGJvYXJkRXZlbnQgfCBEcmFnRXZlbnQpCiAgICAgaWYgKGRvYy5ib2R5KSB7CiAgICAgICAgIHRleHRIVE1MID0gZG9jLmJvZHkuaW5uZXJIVE1MOwogICAgIH0KLQorICAgIHRleHRIVE1MID0gTHV0ZS5TYW5pdGl6ZSh0ZXh0SFRNTCk7CiAgICAgdmRpdG9yLnd5c2l3eWcuZ2V0Q29tbWVudHModmRpdG9yKTsKIAogICAgIC8vIHByb2Nlc3MgY29kZQpkaWZmIC0tZ2l0IGEvdHlwZXMvaW5kZXguZC50cyBiL3R5cGVzL2luZGV4LmQudHMKaW5kZXggYmE1NzhmYjY5Li4zNDI3YjViOTkgMTAwNjQ0Ci0tLSBhL3R5cGVzL2luZGV4LmQudHMKKysrIGIvdHlwZXMvaW5kZXguZC50cwpAQCAtMTE4LDYgKzExOCw4IEBAIGRlY2xhcmUgY2xhc3MgTHV0ZSB7CiAKICAgICBwdWJsaWMgc3RhdGljIE5ld05vZGVJRCgpOiBzdHJpbmc7CiAKKyAgICBwdWJsaWMgc3RhdGljIFNhbml0aXplKGh0bWw6IHN0cmluZyk6IHN0cmluZzsKKwogICAgIHByaXZhdGUgY29uc3RydWN0b3IoKTsKIAogICAgIHB1YmxpYyBTZXRKU1JlbmRlcmVycyhvcHRpb25zPzogewpAQCAtMjMyLDYgKzIzNCw3IEBAIGRlY2xhcmUgY29uc3Qgd2Via2l0QXVkaW9Db250ZXh0OiB7CiAKIGludGVyZmFjZSBJVGlwcyB7CiAgICAgW2luZGV4OiBzdHJpbmddOiBzdHJpbmc7CisKICAgICBhbGlnbkNlbnRlcjogc3RyaW5nOwogICAgIGFsaWduTGVmdDogc3RyaW5nOwogICAgIGFsaWduUmlnaHQ6IHN0cmluZzs=", "url": "https://github.com/Vanessa219/vditor/commit/1b2382d7f8a4ee509d9245db4450d926a0b24146.patch" } ]
CWE-79 Cross-site Scripting (XSS)
GHSA-fqcv-rfp6-wv92
Microweber Cross-site Scripting vulnerability
null
[ { "commit_message": "[PATCH] update .../Content/ContentManagerHelpers.php | 1 + .../ContentApiControllerLiveEditSaveTest.php | 72 ++++++++++--------- .../Database/DatabaseManager.php | 24 +++++-- .../Module/Models/Module.php | 16 +++-- 4 files changed, 70 insertions(+), 43 deletions(-)", "patch_text_b64": "From 42efa981a2239d042d910069952d6276497bdcf1 Mon Sep 17 00:00:00 2001
From: Peter Ivanov <peter@microweber.com>
Date: Wed, 7 Jun 2023 14:18:07 +0300
Subject: [PATCH] update

---
 .../Content/ContentManagerHelpers.php         |  1 +
 .../ContentApiControllerLiveEditSaveTest.php  | 72 ++++++++++---------
 .../Database/DatabaseManager.php              | 24 +++++--
 .../Module/Models/Module.php                  | 16 +++--
 4 files changed, 70 insertions(+), 43 deletions(-)

diff --git a/src/MicroweberPackages/Content/ContentManagerHelpers.php b/src/MicroweberPackages/Content/ContentManagerHelpers.php
index 0a720e324ce..db6a26acd5c 100644
--- a/src/MicroweberPackages/Content/ContentManagerHelpers.php
+++ b/src/MicroweberPackages/Content/ContentManagerHelpers.php
@@ -659,6 +659,7 @@ public function save_from_live_edit($post_data)
         $ref_page_url = false;
         if (isset($_SERVER['HTTP_REFERER'])) {
             $ref_page_url = $_SERVER['HTTP_REFERER'];
+            $ref_page_url = xss_clean($ref_page_url);
         }
 
         if (isset($post_data['id']) and intval($post_data['id']) > 0) {
diff --git a/src/MicroweberPackages/Content/tests/ContentApiControllerLiveEditSaveTest.php b/src/MicroweberPackages/Content/tests/ContentApiControllerLiveEditSaveTest.php
index f472903ffde..66464b88712 100644
--- a/src/MicroweberPackages/Content/tests/ContentApiControllerLiveEditSaveTest.php
+++ b/src/MicroweberPackages/Content/tests/ContentApiControllerLiveEditSaveTest.php
@@ -2,9 +2,7 @@
 
 namespace MicroweberPackages\Content\tests;
 
-use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
-use MicroweberPackages\Category\Models\Category;
 use MicroweberPackages\Core\tests\TestCase;
 use MicroweberPackages\Helper\XSSClean;
 use MicroweberPackages\Multilanguage\MultilanguageHelpers;
@@ -64,14 +62,11 @@ public function testSaveContentOnPageLiveEditSingle()
 HTML;
 
 
-
-
         $pq = \phpQuery::newDocument($contentFieldHtml);
 
         $contentFieldHtml = $pq->htmlOuter();
 
 
-
         $fieldsData = [
             'field_data_0' => [
                 'attributes' => [
@@ -130,7 +125,6 @@ public function testSaveContentOnPageLiveEditFromBootstrapExamples()
         ]);
 
 
-
         $findPage = Page::whereId($newCleanMlPage)->first();
 
         $pageId = $findPage->id;
@@ -172,12 +166,12 @@ public function testSaveContentOnPageLiveEditFromBootstrapExamples()
 
 
             //remove empty tags
-           $html =  preg_replace('/<[^\/>]*>([\s]?)*<\/[^>]*>/', '', $html);
+            $html = preg_replace('/<[^\/>]*>([\s]?)*<\/[^>]*>/', '', $html);
 
             // remove script tags
             $html = preg_replace('/<script\b[^>]*>(.*?)<\/script>/is', "", $html);
 
-             // remove code tags
+            // remove code tags
             $html = preg_replace('/<code\b[^>]*>(.*?)<\/code>/is', "", $html);
 
 
@@ -201,8 +195,6 @@ public function testSaveContentOnPageLiveEditFromBootstrapExamples()
             ];
 
 
-
-
             $encoded = base64_encode(json_encode($fieldsData));
 
             $response = $this->call(
@@ -225,7 +217,6 @@ public function testSaveContentOnPageLiveEditFromBootstrapExamples()
             $this->assertEquals($fieldSaved[0]['field'], 'content');
 
 
-
             $pq2 = \phpQuery::newDocument($contentFieldHtml);
             $this->assertEquals($contentFieldHtml, $pq2->htmlOuter());
 
@@ -273,7 +264,6 @@ public function testSaveContentOnPageLiveEditXssList()
         $_SERVER['HTTP_REFERER'] = content_link($pageId);
 
 
-
         $zip = new \ZipArchive();
         $zip->open(__DIR__ . '/../../Helper/tests/misc/xss-test-files.zip');
         $xssList = $zip->getFromName('xss-payload-list.txt');
@@ -289,14 +279,13 @@ public function testSaveContentOnPageLiveEditXssList()
         foreach ($xssListChunks as $stringChunk) {
 
             $string = implode(PHP_EOL, $stringChunk);
-             if (empty(trim($string))) {
+            if (empty(trim($string))) {
                 continue;
             }
 
             $contentFieldHtml = $string;
 
 
-
             $fieldsData = [
                 'field_data_0' => [
                     'attributes' => [
@@ -333,7 +322,7 @@ public function testSaveContentOnPageLiveEditXssList()
             $contentFieldHtml1 = trim($contentFieldHtml);
             $contentFieldHtml2 = trim($findPage->content);
 
-           $this->assertNotEquals($contentFieldHtml1, $contentFieldHtml2);
+            $this->assertNotEquals($contentFieldHtml1, $contentFieldHtml2);
 
 
             foreach ($stringChunk as $stringItem) {
@@ -344,12 +333,10 @@ public function testSaveContentOnPageLiveEditXssList()
             }
 
 
-
         }
     }
 
 
-
     public function testSaveContentOnPageLiveEditFromOtherExamples()
     {
         $this->cleanupAndPrepare();
@@ -390,7 +377,7 @@ public function testSaveContentOnPageLiveEditFromOtherExamples()
                 $ext = get_file_extension($fn);
                 if ($ext == 'html') {
                     $string = $zip->getFromName($fn);
-                    if(trim($string) == ''){
+                    if (trim($string) == '') {
                         continue;
                     }
                     $htmls[$fn] = $string;
@@ -421,14 +408,13 @@ public function testSaveContentOnPageLiveEditFromOtherExamples()
         $htmlsChunks = array_chunk($htmls, 100);
 
 
+        foreach ($htmlsChunks as $k => $htmlChunk) {
 
-      foreach ($htmlsChunks as $k => $htmlChunk) {
-
-          $html = implode('--------chunk-------', $htmlChunk);
-         $contentFieldHtml = $html;
+            $html = implode('--------chunk-------', $htmlChunk);
+            $contentFieldHtml = $html;
 
 
-           // $contentFieldHtml = str_replace('{SITE_URL}', site_url(), $contentFieldHtml);
+            // $contentFieldHtml = str_replace('{SITE_URL}', site_url(), $contentFieldHtml);
             $fieldsData = [
                 'field_data_0' => [
                     'attributes' => [
@@ -462,7 +448,6 @@ public function testSaveContentOnPageLiveEditFromOtherExamples()
             $fieldSaved = $response->decodeResponseJson();
 
 
-
             $findPage = Page::whereId($fieldSaved[0]['id'])->first();
             $contentFieldHtml1 = trim($contentFieldHtml);
             $contentFieldHtml2 = trim($findPage->content);
@@ -471,13 +456,37 @@ public function testSaveContentOnPageLiveEditFromOtherExamples()
             $this->assertEquals($contentFieldHtml, $findPage->content);
 
 
-       }
+        }
+
+
+    }
+
+
+    public function testSaveContentXssSpaceInUrlAttribute()
+    {
+
+        $this->cleanupAndPrepare();
+        $unique = uniqid('testSaveContentXssInUrlAttribute');
+        $newCleanPage = save_content([
+            'subtype' => 'static',
+            'content_type' => 'page',
+            'layout_file' => 'clean.php',
+            'title' => 'testSaveContentXssInUrlAttribute-save' . $unique,
+            'preview_layout_file' => 'clean.php',
+            'url' => 'url with space ' . $unique . '  <script>alert(1)</script>',
+            'is_active' => 1,
+        ]);
+
+        $findPage = Page::whereId($newCleanPage)->first();
 
+        $this->assertEquals($findPage->url, 'url-with-space-' . strtolower($unique));
 
     }
 
 
-    private function cleanupAndPrepare(){
+
+    private function cleanupAndPrepare()
+    {
         $user = User::where('is_admin', '=', '1')->first();
         Auth::login($user);
         \Config::set('microweber.disable_model_cache', 1);
@@ -489,18 +498,17 @@ private function cleanupAndPrepare(){
 
     public static function fixLinksPrecentAttributes($text)
     {
-        $text = str_ireplace('{SITE_URL}','___mw-site-url-temp-replace-on-clean___', $text);
+        $text = str_ireplace('{SITE_URL}', '___mw-site-url-temp-replace-on-clean___', $text);
         $pq = \phpQuery::newDocument($text);
 
-        foreach($pq->find('a') as $stuffs)
-        {
+        foreach ($pq->find('a') as $stuffs) {
             $href = pq($stuffs)->attr('href');
-            if($href){
-            pq($stuffs)->attr('href', str_replace(' ', '%20', $href));
+            if ($href) {
+                pq($stuffs)->attr('href', str_replace(' ', '%20', $href));
             }
         }
         $text = $pq->htmlOuter();
-        $text = str_ireplace('___mw-site-url-temp-replace-on-clean___','{SITE_URL}',     $text);
+        $text = str_ireplace('___mw-site-url-temp-replace-on-clean___', '{SITE_URL}', $text);
         return $text;
 
     }
diff --git a/src/MicroweberPackages/Database/DatabaseManager.php b/src/MicroweberPackages/Database/DatabaseManager.php
index 7f4bc13af75..76381946b81 100644
--- a/src/MicroweberPackages/Database/DatabaseManager.php
+++ b/src/MicroweberPackages/Database/DatabaseManager.php
@@ -668,16 +668,32 @@ public function save($table, $data = false, $data_to_save_options = false)
                     $criteria['id'] = $next_id;
                 }
             }
-            $id_to_return = $this->table($table_assoc_name)->insert($criteria);
+
+            if(method_exists($this->table($table),'create')){
+                $id_to_return = $this->table($table)->create($criteria);
+            } else {
+                $id_to_return = $this->table($table)->insert($criteria);
+            }
+             //$id_to_return = $this->table($table_assoc_name)->insert($criteria);
+         //   $id_to_return = $this->table($table_assoc_name)->create($criteria);
             $id_to_return = $this->last_id($table);
 
         } else {
+
             $insert_or_update = $highestId = $this->table($table)->where('id', $criteria['id'])->count();
             if ($insert_or_update != 0) {
                 $insert_or_update = 'update';
             } else {
-                $insert_or_update = 'insert';
+              $insert_or_update = 'insert';
+              if(method_exists($this->table($table),'create')){
+                    $insert_or_update = 'create';
+              }
+          //  $insert_or_update = 'create';
             }
+
+
+
+
             $id_to_return = $this->table($table_assoc_name)->where('id', $criteria['id'])->$insert_or_update($criteria);
             $id_to_return = $criteria['id'];
         }
@@ -965,8 +981,8 @@ public function table($table, $params = [])
             $this->use_model_cache[$table]= true;
 
             if ($table == 'content') {
-              //  $model = new Content($params);
-                 $model = app()->make(Content::class);
+                 $model = new Content($params);
+              //   $model = app()->make(Content::class);
 
                 //    $model::boot();
             } else if ($table == 'categories') {
diff --git a/src/MicroweberPackages/Module/Models/Module.php b/src/MicroweberPackages/Module/Models/Module.php
index e84774e691e..6601e531910 100644
--- a/src/MicroweberPackages/Module/Models/Module.php
+++ b/src/MicroweberPackages/Module/Models/Module.php
@@ -46,13 +46,15 @@ public function icon()
 
     public function getIconInline()
     {
-        $icon = str_replace( '{SITE_URL}', '', $this->icon);
-        if (get_file_extension($icon) == 'svg') {
-            $content =  file_get_contents($icon);
-            $content = str_replace('<?xml version="1.0" encoding="utf-8"?>', '', $content);
-            return $content;
-        } else {
-            return '<img src="' . $icon . '" />';
+        $icon = str_replace('{SITE_URL}', '', $this->icon);
+        if (file_exists($icon)) {
+            if (get_file_extension($icon) == 'svg') {
+                $content = file_get_contents($icon);
+                $content = str_replace('<?xml version="1.0" encoding="utf-8"?>', '', $content);
+                return $content;
+            } else {
+                return '<img src="' . $icon . '" />';
+            }
         }
     }", "url": "https://github.com/microweber/microweber/commit/42efa981a2239d042d910069952d6276497bdcf1.patch" } ]
null
GHSA-q43h-4xr8-j6fq
null
[ { "commit_message": "[PATCH] patch XXE vulnerability .../http/webdav/DefaultPropFindRequestFieldParser.java | 7 +++++-- .../java/io/milton/http/webdav/DefaultPropPatchParser.java | 4 ++++ 2 files changed, 9 insertions(+), 2 deletions(-)", "patch_text_b64": "RnJvbSA1ZjgxYjBjNDhhODE3ZDQzMzdkOGIwZTk5ZWEwYjQ3NDRlY2Q3MjBiIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBicmFkIDxicmFkQGJyYWQtbGl0dGxlLWxhcHRvcD4KRGF0ZTogU2F0LCAyNiBTZXAgMjAxNSAxMDowNDozNSArMTIwMApTdWJqZWN0OiBbUEFUQ0hdIHBhdGNoIFhYRSB2dWxuZXJhYmlsaXR5CgotLS0KIC4uLi9odHRwL3dlYmRhdi9EZWZhdWx0UHJvcEZpbmRSZXF1ZXN0RmllbGRQYXJzZXIuamF2YSAgICAgfCA3ICsrKysrLS0KIC4uLi9qYXZhL2lvL21pbHRvbi9odHRwL3dlYmRhdi9EZWZhdWx0UHJvcFBhdGNoUGFyc2VyLmphdmEgfCA0ICsrKysKIDIgZmlsZXMgY2hhbmdlZCwgOSBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL21pbHRvbi1zZXJ2ZXItY2Uvc3JjL21haW4vamF2YS9pby9taWx0b24vaHR0cC93ZWJkYXYvRGVmYXVsdFByb3BGaW5kUmVxdWVzdEZpZWxkUGFyc2VyLmphdmEgYi9taWx0b24tc2VydmVyLWNlL3NyYy9tYWluL2phdmEvaW8vbWlsdG9uL2h0dHAvd2ViZGF2L0RlZmF1bHRQcm9wRmluZFJlcXVlc3RGaWVsZFBhcnNlci5qYXZhCmluZGV4IGJiMzdhZDMyLi41YWQ3YmE4NCAxMDA2NDQKLS0tIGEvbWlsdG9uLXNlcnZlci1jZS9zcmMvbWFpbi9qYXZhL2lvL21pbHRvbi9odHRwL3dlYmRhdi9EZWZhdWx0UHJvcEZpbmRSZXF1ZXN0RmllbGRQYXJzZXIuamF2YQorKysgYi9taWx0b24tc2VydmVyLWNlL3NyYy9tYWluL2phdmEvaW8vbWlsdG9uL2h0dHAvd2ViZGF2L0RlZmF1bHRQcm9wRmluZFJlcXVlc3RGaWVsZFBhcnNlci5qYXZhCkBAIC01Myw3ICs1Myw3IEBAIHB1YmxpYyBEZWZhdWx0UHJvcEZpbmRSZXF1ZXN0RmllbGRQYXJzZXIoKSB7CiAJQE92ZXJyaWRlDQogICAgIHB1YmxpYyBQcm9wZXJ0aWVzUmVxdWVzdCBnZXRSZXF1ZXN0ZWRGaWVsZHMoIElucHV0U3RyZWFtIGluICkgew0KIAkJZmluYWwgU2V0PFFOYW1lPiBzZXQgPSBuZXcgTGlua2VkSGFzaFNldDxRTmFtZT4oKTsNCi0gICAgICAgIHRyeSB7ICAgICAgICAgICAgDQorICAgICAgICB0cnkgew0KICAgICAgICAgICAgIEJ5dGVBcnJheU91dHB1dFN0cmVhbSBib3V0ID0gbmV3IEJ5dGVBcnJheU91dHB1dFN0cmVhbSgpOw0KICAgICAgICAgICAgIFN0cmVhbVV0aWxzLnJlYWRUbyggaW4sIGJvdXQsIGZhbHNlLCB0cnVlICk7DQogICAgICAgICAgICAgYnl0ZVtdIGFyciA9IGJvdXQudG9CeXRlQXJyYXkoKTsNCkBAIC02MSw2ICs2MSw5IEBAIHB1YmxpYyBQcm9wZXJ0aWVzUmVxdWVzdCBnZXRSZXF1ZXN0ZWRGaWVsZHMoIElucHV0U3RyZWFtIGluICkgewogICAgICAgICAgICAgICAgIEJ5dGVBcnJheUlucHV0U3RyZWFtIGJpbiA9IG5ldyBCeXRlQXJyYXlJbnB1dFN0cmVhbSggYXJyICk7DQogICAgICAgICAgICAgICAgIFhNTFJlYWRlciByZWFkZXIgPSBYTUxSZWFkZXJGYWN0b3J5LmNyZWF0ZVhNTFJlYWRlcigpOw0KIAkJCQlyZWFkZXIuc2V0RmVhdHVyZSgiaHR0cDovL3htbC5vcmcvc2F4L2ZlYXR1cmVzL2V4dGVybmFsLXBhcmFtZXRlci1lbnRpdGllcyIsIGZhbHNlKTsNCisJCQkJLy8gaHR0cHM6Ly93d3cub3dhc3Aub3JnL2luZGV4LnBocC9YTUxfRXh0ZXJuYWxfRW50aXR5XyUyOFhYRSUyOV9Qcm9jZXNzaW5nDQorCQkJCXJlYWRlci5zZXRGZWF0dXJlKCJodHRwOi8vYXBhY2hlLm9yZy94bWwvZmVhdHVyZXMvZGlzYWxsb3ctZG9jdHlwZS1kZWNsIiwgdHJ1ZSk7DQorCQkJCXJlYWRlci5zZXRGZWF0dXJlKCJodHRwOi8veG1sLm9yZy9zYXgvZmVhdHVyZXMvZXh0ZXJuYWwtZ2VuZXJhbC1lbnRpdGllcyIsIGZhbHNlKTsNCiAgICAgICAgICAgICAgICAgUHJvcEZpbmRTYXhIYW5kbGVyIGhhbmRsZXIgPSBuZXcgUHJvcEZpbmRTYXhIYW5kbGVyKCk7DQogICAgICAgICAgICAgICAgIHJlYWRlci5zZXRDb250ZW50SGFuZGxlciggaGFuZGxlciApOw0KICAgICAgICAgICAgICAgICB0cnkgew0KQEAgLTc3LDcgKzgwLDcgQEAgcHVibGljIFByb3BlcnRpZXNSZXF1ZXN0IGdldFJlcXVlc3RlZEZpZWxkcyggSW5wdXRTdHJlYW0gaW4gKSB7CiAgICAgICAgICAgICAgICAgICAgIGxvZy53YXJuKCAiZXhjZXB0aW9uIHBhcnNpbmcgcmVxdWVzdCBib2R5IiwgZSApOw0KICAgICAgICAgICAgICAgICAgICAgLy8gaWdub3JlDQogICAgICAgICAgICAgICAgIH0NCi0gICAgICAgICAgICB9ICAgICAgICAgICAgDQorICAgICAgICAgICAgfQ0KICAgICAgICAgfSBjYXRjaCggRXhjZXB0aW9uIGV4ICkgew0KIAkJCS8vIFRoZXJlJ3MgYSByZXBvcnQgb2YgYW4gZXhjZXB0aW9uIGJlaW5nIHRocm93biBoZXJlIGJ5IElUIEhpdCBXZWJkYXYgY2xpZW50DQogCQkJLy8gUGVyaGFwcyB3ZSBjYW4ganVzdCBsb2cgdGhlIGVycm9yIGFuZCByZXR1cm4gYW4gZW1wdHkgc2V0LiBVc3VhbGx5IHRoaXMNCmRpZmYgLS1naXQgYS9taWx0b24tc2VydmVyLWNlL3NyYy9tYWluL2phdmEvaW8vbWlsdG9uL2h0dHAvd2ViZGF2L0RlZmF1bHRQcm9wUGF0Y2hQYXJzZXIuamF2YSBiL21pbHRvbi1zZXJ2ZXItY2Uvc3JjL21haW4vamF2YS9pby9taWx0b24vaHR0cC93ZWJkYXYvRGVmYXVsdFByb3BQYXRjaFBhcnNlci5qYXZhCmluZGV4IDE4YjdjOTUxLi5jMzQ2MjAwMiAxMDA2NDQKLS0tIGEvbWlsdG9uLXNlcnZlci1jZS9zcmMvbWFpbi9qYXZhL2lvL21pbHRvbi9odHRwL3dlYmRhdi9EZWZhdWx0UHJvcFBhdGNoUGFyc2VyLmphdmEKKysrIGIvbWlsdG9uLXNlcnZlci1jZS9zcmMvbWFpbi9qYXZhL2lvL21pbHRvbi9odHRwL3dlYmRhdi9EZWZhdWx0UHJvcFBhdGNoUGFyc2VyLmphdmEKQEAgLTY5LDYgKzY5LDEwIEBAIHByaXZhdGUgUHJvcFBhdGNoUGFyc2VSZXN1bHQgcGFyc2VDb250ZW50KCBieXRlW10gYXJyICkgdGhyb3dzIElPRXhjZXB0aW9uLCBTQVhFCiAgICAgICAgICAgICBCeXRlQXJyYXlJbnB1dFN0cmVhbSBiaW4gPSBuZXcgQnl0ZUFycmF5SW5wdXRTdHJlYW0oIGFyciApOw0KICAgICAgICAgICAgIFhNTFJlYWRlciByZWFkZXIgPSBYTUxSZWFkZXJGYWN0b3J5LmNyZWF0ZVhNTFJlYWRlcigpOw0KIAkJCXJlYWRlci5zZXRGZWF0dXJlKCJodHRwOi8veG1sLm9yZy9zYXgvZmVhdHVyZXMvZXh0ZXJuYWwtcGFyYW1ldGVyLWVudGl0aWVzIiwgZmFsc2UpOw0KKwkJCS8vIGh0dHBzOi8vd3d3Lm93YXNwLm9yZy9pbmRleC5waHAvWE1MX0V4dGVybmFsX0VudGl0eV8lMjhYWEUlMjlfUHJvY2Vzc2luZw0KKwkJCXJlYWRlci5zZXRGZWF0dXJlKCJodHRwOi8vYXBhY2hlLm9yZy94bWwvZmVhdHVyZXMvZGlzYWxsb3ctZG9jdHlwZS1kZWNsIiwgdHJ1ZSk7DQorCQkJcmVhZGVyLnNldEZlYXR1cmUoImh0dHA6Ly94bWwub3JnL3NheC9mZWF0dXJlcy9leHRlcm5hbC1nZW5lcmFsLWVudGl0aWVzIiwgZmFsc2UpOw0KKw0KICAgICAgICAgICAgIFByb3BQYXRjaFNheEhhbmRsZXIgaGFuZGxlciA9IG5ldyBQcm9wUGF0Y2hTYXhIYW5kbGVyKCk7DQogICAgICAgICAgICAgcmVhZGVyLnNldENvbnRlbnRIYW5kbGVyKCBoYW5kbGVyICk7DQogICAgICAgICAgICAgcmVhZGVyLnBhcnNlKCBuZXcgSW5wdXRTb3VyY2UoIGJpbiApICk7", "url": "https://github.com/miltonio/milton2/commit/5f81b0c48a817d4337d8b0e99ea0b4744ecd720b.patch" }, { "commit_message": "[PATCH] updated OAuth2 helper to not included spaces when generating the scope .../src/main/java/io/milton/http/http11/auth/OAuth2Helper.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSBjODNkMjhlMDUxYmZjMjJmYzg4MjllMjJjNTEwNTRhOWE5ZTkzMjcxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBXZXNsZXkgPHR1enptYW5pYW5kZXZpbEBnbWFpbC5jb20+CkRhdGU6IFR1ZSwgMjkgU2VwIDIwMTUgMTQ6MzE6NTAgKzEzMDAKU3ViamVjdDogW1BBVENIXSB1cGRhdGVkIE9BdXRoMiBoZWxwZXIgdG8gbm90IGluY2x1ZGVkIHNwYWNlcyB3aGVuIGdlbmVyYXRpbmcKIHRoZSBzY29wZQoKLS0tCiAuLi4vc3JjL21haW4vamF2YS9pby9taWx0b24vaHR0cC9odHRwMTEvYXV0aC9PQXV0aDJIZWxwZXIuamF2YSAgfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9taWx0b24tc2VydmVyLWNlL3NyYy9tYWluL2phdmEvaW8vbWlsdG9uL2h0dHAvaHR0cDExL2F1dGgvT0F1dGgySGVscGVyLmphdmEgYi9taWx0b24tc2VydmVyLWNlL3NyYy9tYWluL2phdmEvaW8vbWlsdG9uL2h0dHAvaHR0cDExL2F1dGgvT0F1dGgySGVscGVyLmphdmEKaW5kZXggOGZmOTdiOWMuLjZmNDE3YWQxIDEwMDY0NAotLS0gYS9taWx0b24tc2VydmVyLWNlL3NyYy9tYWluL2phdmEvaW8vbWlsdG9uL2h0dHAvaHR0cDExL2F1dGgvT0F1dGgySGVscGVyLmphdmEKKysrIGIvbWlsdG9uLXNlcnZlci1jZS9zcmMvbWFpbi9qYXZhL2lvL21pbHRvbi9odHRwL2h0dHAxMS9hdXRoL09BdXRoMkhlbHBlci5qYXZhCkBAIC01MCw3ICs1MCw3IEBAIHB1YmxpYyBzdGF0aWMgVVJMIGdldE9BdXRoMlVSTChPQXV0aDJQcm92aWRlciBwcm92aWRlcikgewogDQogCQlTdHJpbmcgb0F1dGgyTG9jYXRpb24gPSBwcm92aWRlci5nZXRBdXRoTG9jYXRpb24oKTsNCiAJCVN0cmluZyBvQXV0aDJDbGllbnRJZCA9IHByb3ZpZGVyLmdldENsaWVudElkKCk7DQotCQlTdHJpbmcgc2NvcGVzID0gVXRpbHMudG9Dc3YocHJvdmlkZXIuZ2V0UGVybWlzc2lvblNjb3BlcygpKTsNCisJCVN0cmluZyBzY29wZXMgPSBVdGlscy50b0Nzdihwcm92aWRlci5nZXRQZXJtaXNzaW9uU2NvcGVzKCksIGZhbHNlKTsNCiAJCXRyeSB7DQogCQkJT0F1dGhDbGllbnRSZXF1ZXN0IG9BdXRoUmVxdWVzdCA9IE9BdXRoQ2xpZW50UmVxdWVzdA0KIAkJCQkJLmF1dGhvcml6YXRpb25Mb2NhdGlvbihvQXV0aDJMb2NhdGlvbik=", "url": "https://github.com/miltonio/milton2/commit/b41072b.patch" }, { "commit_message": "[PATCH] log returning null ACL .../main/java/io/milton/http/AclUtils.java | 27 ++++++++++--------- 1 file changed, 15 insertions(+), 12 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/miltonio/milton2/commit/b5851c1.patch" } ]
null
GHSA-p2h4-7fp3-cmh8
TYPO3 Disclosure of Information about Installed Extensions
null
[ { "commit_message": "[PATCH] [SECURITY] Avoid disclosing loaded extensions Inline JavaScript settings for RequireJS and ajaxUrls disclose the existence of specific extensions in a TYPO3 installation. In case no backend user is logged in RequireJS settings are fetched using an according endpoint, ajaxUrls (for backend AJAX routes) are limited to those that are accessible without having a user session. Resolves: #83855 Releases: master, 9.5, 8.7 Security-Commit: af76c928bbe6fe05611db0839da879fce132daff Security-Bulletin: TYPO3-CORE-SA-2019-001 Change-Id: I90dddd2fd3fd81834cd40c8638fa487fa106b07c Reviewed-on: https://review.typo3.org/59520 Reviewed-by: Oliver Hader <oliver.hader@typo3.org> Tested-by: Oliver Hader <oliver.hader@typo3.org> Classes/Controller/RequireJsController.php | 109 ++++++++++ Classes/Page/PageRenderer.php | 205 ++++++++++++++++-- Configuration/Backend/AjaxRoutes.php | 14 ++ .../Public/JavaScript/requirejs-loader.js | 134 ++++++++++++ ext_localconf.php | 1 + 5 files changed, 440 insertions(+), 23 deletions(-) create mode 100644 Classes/Controller/RequireJsController.php create mode 100644 Configuration/Backend/AjaxRoutes.php create mode 100644 Resources/Public/JavaScript/requirejs-loader.js", "patch_text_b64": "From 7960334bba1223a681283158f67a999334e88cf1 Mon Sep 17 00:00:00 2001
From: Oliver Hader <oliver@typo3.org>
Date: Tue, 22 Jan 2019 09:41:00 +0100
Subject: [PATCH] [SECURITY] Avoid disclosing loaded extensions

Inline JavaScript settings for RequireJS and ajaxUrls disclose the
existence of specific extensions in a TYPO3 installation.

In case no backend user is logged in RequireJS settings are fetched
using an according endpoint, ajaxUrls (for backend AJAX routes) are
limited to those that are accessible without having a user session.

Resolves: #83855
Releases: master, 9.5, 8.7
Security-Commit: af76c928bbe6fe05611db0839da879fce132daff
Security-Bulletin: TYPO3-CORE-SA-2019-001
Change-Id: I90dddd2fd3fd81834cd40c8638fa487fa106b07c
Reviewed-on: https://review.typo3.org/59520
Reviewed-by: Oliver Hader <oliver.hader@typo3.org>
Tested-by: Oliver Hader <oliver.hader@typo3.org>
---
 Classes/Controller/RequireJsController.php    | 109 ++++++++++
 Classes/Page/PageRenderer.php                 | 205 ++++++++++++++++--
 Configuration/Backend/AjaxRoutes.php          |  14 ++
 .../Public/JavaScript/requirejs-loader.js     | 134 ++++++++++++
 ext_localconf.php                             |   1 +
 5 files changed, 440 insertions(+), 23 deletions(-)
 create mode 100644 Classes/Controller/RequireJsController.php
 create mode 100644 Configuration/Backend/AjaxRoutes.php
 create mode 100644 Resources/Public/JavaScript/requirejs-loader.js

diff --git a/Classes/Controller/RequireJsController.php b/Classes/Controller/RequireJsController.php
new file mode 100644
index 0000000000..23b88cf80e
--- /dev/null
+++ b/Classes/Controller/RequireJsController.php
@@ -0,0 +1,109 @@
+<?php
+declare(strict_types = 1);
+namespace TYPO3\CMS\Core\Controller;
+
+/*
+ * This file is part of the TYPO3 CMS project.
+ *
+ * It is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, either version 2
+ * of the License, or any later version.
+ *
+ * For the full copyright and license information, please read the
+ * LICENSE.txt file that was distributed with this source code.
+ *
+ * The TYPO3 project - inspiring people to share!
+ */
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use TYPO3\CMS\Core\Http\JsonResponse;
+use TYPO3\CMS\Core\Page\PageRenderer;
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+
+/**
+ * Handling requirejs client requests.
+ */
+class RequireJsController
+{
+    /**
+     * @var PageRenderer
+     */
+    protected $pageRenderer;
+
+    public function __construct()
+    {
+        $this->pageRenderer = GeneralUtility::makeInstance(PageRenderer::class);
+    }
+
+    /**
+     * Retrieves additional requirejs configuration for a given module name or module path.
+     *
+     * The JSON result e.g. could look like:
+     * {
+     *   "shim": {
+     *     "vendor/module": ["exports" => "TheModule"]
+     *   },
+     *   "paths": {
+     *     "vendor/module": "/public/web/path/"
+     *   },
+     *   "packages": {
+     *     [
+     *       "name": "module",
+     *       ...
+     *     ]
+     *   }
+     * }
+     *
+     * Parameter name either could be the module name ("vendor/module") or a
+     * module path ("vendor/module/component") belonging to a module.
+     *
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface
+     */
+    public function retrieveConfiguration(ServerRequestInterface $request): ResponseInterface
+    {
+        $name = $request->getQueryParams()['name'] ?? null;
+        if (empty($name) || !is_string($name)) {
+            return new JsonResponse(null, 404);
+        }
+        $configuration = $this->findConfiguration($name);
+        return new JsonResponse($configuration, !empty($configuration) ? 200 : 404);
+    }
+
+    /**
+     * @param string $name
+     * @return array
+     */
+    protected function findConfiguration(string $name): array
+    {
+        $relevantConfiguration = [];
+        $this->pageRenderer->loadRequireJs();
+        $configuration = $this->pageRenderer->getRequireJsConfig(PageRenderer::REQUIREJS_SCOPE_RESOLVE);
+
+        $shim = $configuration['shim'] ?? [];
+        foreach ($shim as $baseModuleName => $baseModuleConfiguration) {
+            if (strpos($name . '/', $baseModuleName . '/') === 0) {
+                $relevantConfiguration['shim'][$baseModuleName] = $baseModuleConfiguration;
+            }
+        }
+
+        $paths = $configuration['paths'] ?? [];
+        foreach ($paths as $baseModuleName => $baseModulePath) {
+            if (strpos($name . '/', $baseModuleName . '/') === 0) {
+                $relevantConfiguration['paths'][$baseModuleName] = $baseModulePath;
+            }
+        }
+
+        $packages = $configuration['packages'] ?? [];
+        foreach ($packages as $package) {
+            if (!empty($package['name'])
+                && strpos($name . '/', $package['name'] . '/') === 0
+            ) {
+                $relevantConfiguration['packages'][] = $package;
+            }
+        }
+
+        return $relevantConfiguration;
+    }
+}
diff --git a/Classes/Page/PageRenderer.php b/Classes/Page/PageRenderer.php
index 99b5f15824..1885a22b69 100644
--- a/Classes/Page/PageRenderer.php
+++ b/Classes/Page/PageRenderer.php
@@ -43,6 +43,9 @@ class PageRenderer implements \TYPO3\CMS\Core\SingletonInterface
     const JQUERY_NAMESPACE_DEFAULT = 'jQuery';
     const JQUERY_NAMESPACE_DEFAULT_NOCONFLICT = 'defaultNoConflict';
 
+    const REQUIREJS_SCOPE_CONFIG = 'config';
+    const REQUIREJS_SCOPE_RESOLVE = 'resolve';
+
     /**
      * @var bool
      */
@@ -334,11 +337,23 @@ class PageRenderer implements \TYPO3\CMS\Core\SingletonInterface
     protected $addRequireJs = false;
 
     /**
-     * inline configuration for requireJS
+     * Inline configuration for requireJS (internal)
      * @var array
      */
     protected $requireJsConfig = [];
 
+    /**
+     * Module names of internal requireJS 'paths'
+     * @var array
+     */
+    protected $internalRequireJsPathModuleNames = [];
+
+    /**
+     * Inline configuration for requireJS (public)
+     * @var array
+     */
+    protected $publicRequireJsConfig = [];
+
     /**
      * @var bool
      */
@@ -615,6 +630,34 @@ public function setExtJsPath($path)
         $this->extJsPath = $path;
     }
 
+    /**
+     * @param string $scope
+     * @return array
+     */
+    public function getRequireJsConfig(string $scope = null): array
+    {
+        // return basic RequireJS configuration without shim, paths and packages
+        if ($scope === static::REQUIREJS_SCOPE_CONFIG) {
+            return array_replace_recursive(
+                $this->publicRequireJsConfig,
+                $this->filterArrayKeys(
+                    $this->requireJsConfig,
+                    ['shim', 'paths', 'packages'],
+                    false
+                )
+            );
+        }
+        // return RequireJS configuration for resolving only shim, paths and packages
+        if ($scope === static::REQUIREJS_SCOPE_RESOLVE) {
+            return $this->filterArrayKeys(
+                $this->requireJsConfig,
+                ['shim', 'paths', 'packages'],
+                true
+            );
+        }
+        return [];
+    }
+
     /*****************************************************/
     /*                                                   */
     /*  Public Enablers / Disablers                      */
@@ -1462,7 +1505,7 @@ public function loadJquery($version = null, $source = null, $namespace = self::J
     public function loadRequireJs()
     {
         $this->addRequireJs = true;
-        if (!empty($this->requireJsConfig)) {
+        if (!empty($this->requireJsConfig) && !empty($this->publicRequireJsConfig)) {
             return;
         }
 
@@ -1471,13 +1514,17 @@ public function loadRequireJs()
         $cacheIdentifier = 'requireJS_' . md5(implode(',', $loadedExtensions) . ($isDevelopment ? ':dev' : '') . GeneralUtility::getIndpEnv('TYPO3_REQUEST_SCRIPT'));
         /** @var VariableFrontend $cache */
         $cache = GeneralUtility::makeInstance(CacheManager::class)->getCache('assets');
-        $this->requireJsConfig = $cache->get($cacheIdentifier);
+        $requireJsConfig = $cache->get($cacheIdentifier);
 
         // if we did not get a configuration from the cache, compute and store it in the cache
-        if (empty($this->requireJsConfig)) {
-            $this->requireJsConfig = $this->computeRequireJsConfig($isDevelopment, $loadedExtensions);
-            $cache->set($cacheIdentifier, $this->requireJsConfig);
+        if (!isset($requireJsConfig['internal']) || !isset($requireJsConfig['public']) || true) {
+            $requireJsConfig = $this->computeRequireJsConfig($isDevelopment, $loadedExtensions);
+            $cache->set($cacheIdentifier, $requireJsConfig);
         }
+
+        $this->requireJsConfig = $requireJsConfig['internal'];
+        $this->publicRequireJsConfig = $requireJsConfig['public'];
+        $this->internalRequireJsPathModuleNames = $requireJsConfig['internalNames'];
     }
 
     /**
@@ -1491,18 +1538,22 @@ public function loadRequireJs()
     protected function computeRequireJsConfig($isDevelopment, array $loadedExtensions)
     {
         // load all paths to map to package names / namespaces
-        $requireJsConfig = [];
+        $requireJsConfig = [
+            'public' => [],
+            'internal' => [],
+            'internalNames' => [],
+        ];
 
         // In order to avoid browser caching of JS files, adding a GET parameter to the files loaded via requireJS
         if ($isDevelopment) {
-            $requireJsConfig['urlArgs'] = 'bust=' . $GLOBALS['EXEC_TIME'];
+            $requireJsConfig['public']['urlArgs'] = 'bust=' . $GLOBALS['EXEC_TIME'];
         } else {
-            $requireJsConfig['urlArgs'] = 'bust=' . GeneralUtility::hmac(TYPO3_version . PATH_site);
+            $requireJsConfig['public']['urlArgs'] = 'bust=' . GeneralUtility::hmac(TYPO3_version . PATH_site);
         }
         $corePath = ExtensionManagementUtility::extPath('core', 'Resources/Public/JavaScript/Contrib/');
         $corePath = PathUtility::getAbsoluteWebPath($corePath);
         // first, load all paths for the namespaces, and configure contrib libs.
-        $requireJsConfig['paths'] = [
+        $requireJsConfig['public']['paths'] = [
             'jquery-ui' => $corePath . 'jquery-ui',
             'datatables' => $corePath . 'jquery.dataTables',
             'matchheight' => $corePath . 'jquery.matchHeight-min',
@@ -1518,16 +1569,31 @@ protected function computeRequireJsConfig($isDevelopment, array $loadedExtension
             'jquery/autocomplete' => $corePath . 'jquery.autocomplete',
             'd3' => $corePath . 'd3/d3'
         ];
-
+        $requireJsConfig['public']['typo3BaseUrl'] = false;
+        $publicPackageNames = ['core', 'frontend', 'backend'];
         foreach ($loadedExtensions as $packageName) {
-            $fullJsPath = 'EXT:' . $packageName . '/Resources/Public/JavaScript/';
-            $fullJsPath = GeneralUtility::getFileAbsFileName($fullJsPath);
-            $fullJsPath = PathUtility::getAbsoluteWebPath($fullJsPath);
+            $jsPath = 'EXT:' . $packageName . '/Resources/Public/JavaScript/';
+            $absoluteJsPath = GeneralUtility::getFileAbsFileName($jsPath);
+            $fullJsPath = PathUtility::getAbsoluteWebPath($absoluteJsPath);
             $fullJsPath = rtrim($fullJsPath, '/');
-            if ($fullJsPath) {
-                $requireJsConfig['paths']['TYPO3/CMS/' . GeneralUtility::underscoredToUpperCamelCase($packageName)] = $fullJsPath;
+            if (!empty($fullJsPath) && file_exists($absoluteJsPath)) {
+                $type = in_array($packageName, $publicPackageNames, true) ? 'public' : 'internal';
+                $requireJsConfig[$type]['paths']['TYPO3/CMS/' . GeneralUtility::underscoredToUpperCamelCase($packageName)] = $fullJsPath;
             }
         }
+        // sanitize module names in internal 'paths'
+        $internalPathModuleNames = array_keys($requireJsConfig['internal']['paths'] ?? []);
+        $sanitizedInternalPathModuleNames = array_map(
+            function ($moduleName) {
+                // trim spaces and slashes & add ending slash
+                return trim($moduleName, ' /') . '/';
+            },
+            $internalPathModuleNames
+        );
+        $requireJsConfig['internalNames'] = array_combine(
+            $sanitizedInternalPathModuleNames,
+            $internalPathModuleNames
+        );
 
         // check if additional AMD modules need to be loaded if a single AMD module is initialized
         if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['RequireJS']['postInitializationModules'])) {
@@ -1561,6 +1627,72 @@ public function addRequireJsConfiguration(array $configuration)
         \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($this->requireJsConfig, $configuration);
     }
 
+    /**
+     * Generates RequireJS loader HTML markup.
+     *
+     * @return string
+     * @throws \TYPO3\CMS\Backend\Routing\Exception\RouteNotFoundException
+     */
+    protected function getRequireJsLoader(): string
+    {
+        $html = '';
+        $backendRequest = TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_BE;
+        $backendUserLoggedIn = !empty($GLOBALS['BE_USER']->user['uid']);
+
+        // no backend request - basically frontend
+        if (!$backendRequest) {
+            $requireJsConfig = $this->getRequireJsConfig(static::REQUIREJS_SCOPE_CONFIG);
+            $requireJsConfig['typo3BaseUrl'] = GeneralUtility::getIndpEnv('TYPO3_SITE_PATH') . '?eID=requirejs';
+        // backend request, but no backend user logged in
+        } elseif (!$backendUserLoggedIn) {
+            $uriBuilder = GeneralUtility::makeInstance(UriBuilder::class);
+            $requireJsConfig = $this->getRequireJsConfig(static::REQUIREJS_SCOPE_CONFIG);
+            $requireJsConfig['typo3BaseUrl'] = (string)$uriBuilder->buildUriFromRoute('ajax_core_requirejs');
+        // backend request, having backend user logged in
+        } else {
+            $requireJsConfig = array_replace_recursive(
+                $this->publicRequireJsConfig,
+                $this->requireJsConfig
+            );
+        }
+
+        // add (probably filtered) RequireJS configuration
+        $html .= GeneralUtility::wrapJS('var require = ' . json_encode($requireJsConfig)) . LF;
+        // directly after that, include the require.js file
+        $html .= '<script src="'
+            . $this->processJsFile($this->requireJsPath . 'require.js')
+            . '" type="text/javascript"></script>' . LF;
+
+        if (!empty($requireJsConfig['typo3BaseUrl'])) {
+            $html .= '<script src="'
+                . $this->processJsFile($this->getAbsoluteWebPath(
+                    GeneralUtility::getFileAbsFileName(
+                        'EXT:core/Resources/Public/JavaScript/requirejs-loader.js'
+                    )
+                ))
+                . '" type="text/javascript"></script>' . LF;
+        }
+
+        return $html;
+    }
+
+    /**
+     * @param array $array
+     * @param string[] $keys
+     * @param bool $keep
+     * @return array
+     */
+    protected function filterArrayKeys(array $array, array $keys, bool $keep = true): array
+    {
+        return array_filter(
+            $array,
+            function (string $key) use ($keys, $keep) {
+                return in_array($key, $keys, true) === $keep;
+            },
+            ARRAY_FILTER_USE_KEY
+        );
+    }
+
     /**
      * includes an AMD-compatible JS file by resolving the ModuleName, and then requires the file via a requireJS request,
      * additionally allowing to execute JavaScript code afterwards
@@ -1582,7 +1714,13 @@ public function loadRequireJsModule($mainModuleName, $callBackFunction = null)
         $inlineCodeKey = $mainModuleName;
         // make sure requireJS is initialized
         $this->loadRequireJs();
-
+        // move internal module path definition to public module definition
+        // (since loading a module ends up disclosing the existence anyway)
+        $baseModuleName = $this->findRequireJsBaseModuleName($mainModuleName);
+        if ($baseModuleName !== null && isset($this->requireJsConfig['paths'][$baseModuleName])) {
+            $this->publicRequireJsConfig['paths'][$baseModuleName] = $this->requireJsConfig['paths'][$baseModuleName];
+            unset($this->requireJsConfig['paths'][$baseModuleName]);
+        }
         // execute the main module, and load a possible callback function
         $javaScriptCode = 'require(["' . $mainModuleName . '"]';
         if ($callBackFunction !== null) {
@@ -1614,6 +1752,24 @@ public function enableExtJsDebug()
         $this->enableExtJsDebug = true;
     }
 
+    /**
+     * Determines requireJS base module name (if defined).
+     *
+     * @param string $moduleName
+     * @return string|null
+     */
+    protected function findRequireJsBaseModuleName(string $moduleName)
+    {
+        // trim spaces and slashes & add ending slash
+        $sanitizedModuleName = trim($moduleName, ' /') . '/';
+        foreach ($this->internalRequireJsPathModuleNames as $sanitizedBaseModuleName => $baseModuleName) {
+            if (strpos($sanitizedModuleName, $sanitizedBaseModuleName) === 0) {
+                return $baseModuleName;
+            }
+        }
+        return null;
+    }
+
     /**
      * Adds Javascript Inline Label. This will occur in TYPO3.lang - object
      * The label can be used in scripts with TYPO3.lang.<key>
@@ -1984,10 +2140,7 @@ protected function renderMainJavaScriptLibraries()
 
         // Include RequireJS
         if ($this->addRequireJs) {
-            // load the paths of the requireJS configuration
-            $out .= GeneralUtility::wrapJS('var require = ' . json_encode($this->requireJsConfig)) . LF;
-            // directly after that, include the require.js file
-            $out .= '<script src="' . $this->processJsFile($this->requireJsPath . 'require.js') . '" type="text/javascript"></script>' . LF;
+            $out .= $this->getRequireJsLoader();
         }
 
         // Include jQuery Core for each namespace, depending on the version and source
@@ -2023,7 +2176,8 @@ protected function renderMainJavaScriptLibraries()
         }
         $this->loadJavaScriptLanguageStrings();
         if (TYPO3_MODE === 'BE') {
-            $this->addAjaxUrlsToInlineSettings();
+            $noBackendUserLoggedIn = empty($GLOBALS['BE_USER']->user['uid']);
+            $this->addAjaxUrlsToInlineSettings($noBackendUserLoggedIn);
         }
         $inlineSettings = $this->inlineLanguageLabels ? 'TYPO3.lang = ' . json_encode($this->inlineLanguageLabels) . ';' : '';
         $inlineSettings .= $this->inlineSettings ? 'TYPO3.settings = ' . json_encode($this->inlineSettings) . ';' : '';
@@ -2116,8 +2270,10 @@ protected function convertCharsetRecursivelyToUtf8(&$data, string $fromCharset)
 
     /**
      * Make URLs to all backend ajax handlers available as inline setting.
+     *
+     * @param bool $publicRoutesOnly
      */
-    protected function addAjaxUrlsToInlineSettings()
+    protected function addAjaxUrlsToInlineSettings(bool $publicRoutesOnly = false)
     {
         $ajaxUrls = [];
         // Note: this method of adding Ajax URLs is @deprecated as of TYPO3 v8, and will be removed in TYPO3 v9
@@ -2132,6 +2288,9 @@ protected function addAjaxUrlsToInlineSettings()
         $router = GeneralUtility::makeInstance(Router::class);
         $routes = $router->getRoutes();
         foreach ($routes as $routeIdentifier => $route) {
+            if ($publicRoutesOnly && $route->getOption('access') !== 'public') {
+                continue;
+            }
             if ($route->getOption('ajax')) {
                 $uri = (string)$uriBuilder->buildUriFromRoute($routeIdentifier);
                 // use the shortened value in order to use this in JavaScript
diff --git a/Configuration/Backend/AjaxRoutes.php b/Configuration/Backend/AjaxRoutes.php
new file mode 100644
index 0000000000..7a8faaecea
--- /dev/null
+++ b/Configuration/Backend/AjaxRoutes.php
@@ -0,0 +1,14 @@
+<?php
+use TYPO3\CMS\Core\Controller\RequireJsController;
+
+/**
+ * Definitions for routes provided by EXT:core
+ */
+return [
+    // dynamically load requirejs module definitions
+    'core_requirejs' => [
+        'path' => '/core/requirejs',
+        'access' => 'public',
+        'target' => RequireJsController::class . '::retrieveConfiguration',
+    ],
+];
diff --git a/Resources/Public/JavaScript/requirejs-loader.js b/Resources/Public/JavaScript/requirejs-loader.js
new file mode 100644
index 0000000000..e0a000af30
--- /dev/null
+++ b/Resources/Public/JavaScript/requirejs-loader.js
@@ -0,0 +1,134 @@
+(function(req) {
+  /**
+   * Determines whether moduleName is configured in requirejs paths
+   * (this code was taken from RequireJS context.nameToUrl).
+   *
+   * @see context.nameToUrl
+   * @see https://github.com/requirejs/requirejs/blob/2.3.3/require.js#L1650-L1670
+   *
+   * @param {Object} config the require context to find state.
+   * @param {String} moduleName the name of the module.
+   * @return {boolean}
+   */
+  var inPath = function(config, moduleName) {
+    var i, parentModule, parentPath;
+    var paths = config.paths;
+    var syms = moduleName.split('/');
+    //For each module name segment, see if there is a path
+    //registered for it. Start with most specific name
+    //and work up from it.
+    for (i = syms.length; i > 0; i -= 1) {
+      parentModule = syms.slice(0, i).join('/');
+      parentPath = paths[parentModule];
+      if (parentPath) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  /**
+   * @return {XMLHttpRequest}
+   */
+  var createXhr = function() {
+    if (typeof XMLHttpRequest !== 'undefined') {
+      return new XMLHttpRequest();
+    } else {
+      return new ActiveXObject('Microsoft.XMLHTTP');
+    }
+  };
+
+  /**
+   * Fetches RequireJS configuration from server via XHR call.
+   *
+   * @param {object} config
+   * @param {string} name
+   * @param {function} success
+   * @param {function} error
+   */
+  var fetchConfiguration = function(config, name, success, error) {
+    // cannot use jQuery here which would be loaded via RequireJS...
+    var xhr = createXhr();
+    xhr.onreadystatechange = function() {
+      if (this.readyState !== 4) {
+        return;
+      }
+      try {
+        if (this.status === 200) {
+          success(JSON.parse(xhr.responseText));
+        } else {
+          error(this.status, xhr.statusText);
+        }
+      } catch (error) {
+        error(this.status, error);
+      }
+    };
+    xhr.open('GET', config.typo3BaseUrl + '&name=' + encodeURIComponent(name));
+    xhr.send();
+  };
+
+  /**
+   * Adds aspects to RequireJS configuration keys paths and packages.
+   *
+   * @param {object} config
+   * @param {string} data
+   * @param {object} context
+   */
+  var addToConfiguration = function(config, data, context) {
+    if (data.shim && data.shim instanceof Object) {
+      if (typeof config.shim === 'undefined') {
+        config.shim = {};
+      }
+      Object.keys(data.shim).forEach(function(moduleName) {
+        config.shim[moduleName] = data.shim[moduleName];
+      });
+    }
+    if (data.paths && data.paths instanceof Object) {
+      if (typeof config.paths === 'undefined') {
+        config.paths = {};
+      }
+      Object.keys(data.paths).forEach(function(moduleName) {
+        config.paths[moduleName] = data.paths[moduleName];
+      });
+    }
+    if (data.packages && data.packages instanceof Array) {
+      if (typeof config.packages === 'undefined') {
+        config.packages = [];
+      }
+      data.packages.forEach(function (packageName) {
+        config.packages.push(packageName);
+      });
+    }
+    context.configure(config);
+  };
+
+  // keep reference to RequireJS default loader
+  var originalLoad = req.load;
+
+  /**
+   * Does the request to load a module for the browser case.
+   * Make this a separate function to allow other environments
+   * to override it.
+   *
+   * @param {Object} context the require context to find state.
+   * @param {String} name the name of the module.
+   * @param {Object} url the URL to the module.
+   */
+  req.load = function(context, name, url) {
+    if (inPath(context.config, name)) {
+      return originalLoad.call(req, context, name, url);
+    }
+
+    fetchConfiguration(
+      context.config,
+      name,
+      function(data) {
+        addToConfiguration(context.config, data, context);
+        url = context.nameToUrl(name);
+        // result cannot be returned since nested in two asynchronous calls
+        originalLoad.call(req, context, name, url);
+      },
+      function() {}
+    );
+  };
+})(requirejs);
diff --git a/ext_localconf.php b/ext_localconf.php
index 26d5749b98..41cc3b579a 100644
--- a/ext_localconf.php
+++ b/ext_localconf.php
@@ -87,6 +87,7 @@
 unset($signalSlotDispatcher);
 
 $GLOBALS['TYPO3_CONF_VARS']['FE']['eID_include']['dumpFile'] = \TYPO3\CMS\Core\Controller\FileDumpController::class . '::dumpAction';
+$GLOBALS['TYPO3_CONF_VARS']['FE']['eID_include']['requirejs'] = \TYPO3\CMS\Core\Controller\RequireJsController::class . '::retrievePath';
 
 /** @var \TYPO3\CMS\Core\Resource\Rendering\RendererRegistry $rendererRegistry */
 $rendererRegistry = \TYPO3\CMS\Core\Resource\Rendering\RendererRegistry::getInstance();", "url": "https://github.com/TYPO3-CMS/core/commit/7960334bba1223a681283158f67a999334e88cf1.patch" }, { "commit_message": "[PATCH] [SECURITY] Avoid disclosing loaded extensions Inline JavaScript settings for RequireJS and ajaxUrls disclose the existence of specific extensions in a TYPO3 installation. In case no backend user is logged in RequireJS settings are fetched using an according endpoint, ajaxUrls (for backend AJAX routes) are limited to those that are accessible without having a user session. Resolves: #83855 Releases: master, 9.5, 8.7 Security-Commit: a6275dcec387039a8a40972f3f8a8607d20fe6dd Security-Bulletin: TYPO3-CORE-SA-2019-001 Change-Id: I7be7e93b2bd67ddcb2e10863577090b34182c555 Reviewed-on: https://review.typo3.org/59527 Reviewed-by: Oliver Hader <oliver.hader@typo3.org> Tested-by: Oliver Hader <oliver.hader@typo3.org> Classes/Controller/RequireJsController.php | 109 +++++++++ Classes/Page/PageRenderer.php | 206 ++++++++++++++++-- Configuration/Backend/AjaxRoutes.php | 14 ++ .../Public/JavaScript/requirejs-loader.js | 134 ++++++++++++ ext_localconf.php | 1 + 5 files changed, 441 insertions(+), 23 deletions(-) create mode 100644 Classes/Controller/RequireJsController.php create mode 100644 Configuration/Backend/AjaxRoutes.php create mode 100644 Resources/Public/JavaScript/requirejs-loader.js", "patch_text_b64": "From 9453d8a8763fffa76deb6a16f6b99c0ab6f3d8f1 Mon Sep 17 00:00:00 2001
From: Oliver Hader <oliver@typo3.org>
Date: Tue, 22 Jan 2019 09:41:52 +0100
Subject: [PATCH] [SECURITY] Avoid disclosing loaded extensions

Inline JavaScript settings for RequireJS and ajaxUrls disclose the
existence of specific extensions in a TYPO3 installation.

In case no backend user is logged in RequireJS settings are fetched
using an according endpoint, ajaxUrls (for backend AJAX routes) are
limited to those that are accessible without having a user session.

Resolves: #83855
Releases: master, 9.5, 8.7
Security-Commit: a6275dcec387039a8a40972f3f8a8607d20fe6dd
Security-Bulletin: TYPO3-CORE-SA-2019-001
Change-Id: I7be7e93b2bd67ddcb2e10863577090b34182c555
Reviewed-on: https://review.typo3.org/59527
Reviewed-by: Oliver Hader <oliver.hader@typo3.org>
Tested-by: Oliver Hader <oliver.hader@typo3.org>
---
 Classes/Controller/RequireJsController.php    | 109 +++++++++
 Classes/Page/PageRenderer.php                 | 206 ++++++++++++++++--
 Configuration/Backend/AjaxRoutes.php          |  14 ++
 .../Public/JavaScript/requirejs-loader.js     | 134 ++++++++++++
 ext_localconf.php                             |   1 +
 5 files changed, 441 insertions(+), 23 deletions(-)
 create mode 100644 Classes/Controller/RequireJsController.php
 create mode 100644 Configuration/Backend/AjaxRoutes.php
 create mode 100644 Resources/Public/JavaScript/requirejs-loader.js

diff --git a/Classes/Controller/RequireJsController.php b/Classes/Controller/RequireJsController.php
new file mode 100644
index 0000000000..23b88cf80e
--- /dev/null
+++ b/Classes/Controller/RequireJsController.php
@@ -0,0 +1,109 @@
+<?php
+declare(strict_types = 1);
+namespace TYPO3\CMS\Core\Controller;
+
+/*
+ * This file is part of the TYPO3 CMS project.
+ *
+ * It is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, either version 2
+ * of the License, or any later version.
+ *
+ * For the full copyright and license information, please read the
+ * LICENSE.txt file that was distributed with this source code.
+ *
+ * The TYPO3 project - inspiring people to share!
+ */
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use TYPO3\CMS\Core\Http\JsonResponse;
+use TYPO3\CMS\Core\Page\PageRenderer;
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+
+/**
+ * Handling requirejs client requests.
+ */
+class RequireJsController
+{
+    /**
+     * @var PageRenderer
+     */
+    protected $pageRenderer;
+
+    public function __construct()
+    {
+        $this->pageRenderer = GeneralUtility::makeInstance(PageRenderer::class);
+    }
+
+    /**
+     * Retrieves additional requirejs configuration for a given module name or module path.
+     *
+     * The JSON result e.g. could look like:
+     * {
+     *   "shim": {
+     *     "vendor/module": ["exports" => "TheModule"]
+     *   },
+     *   "paths": {
+     *     "vendor/module": "/public/web/path/"
+     *   },
+     *   "packages": {
+     *     [
+     *       "name": "module",
+     *       ...
+     *     ]
+     *   }
+     * }
+     *
+     * Parameter name either could be the module name ("vendor/module") or a
+     * module path ("vendor/module/component") belonging to a module.
+     *
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface
+     */
+    public function retrieveConfiguration(ServerRequestInterface $request): ResponseInterface
+    {
+        $name = $request->getQueryParams()['name'] ?? null;
+        if (empty($name) || !is_string($name)) {
+            return new JsonResponse(null, 404);
+        }
+        $configuration = $this->findConfiguration($name);
+        return new JsonResponse($configuration, !empty($configuration) ? 200 : 404);
+    }
+
+    /**
+     * @param string $name
+     * @return array
+     */
+    protected function findConfiguration(string $name): array
+    {
+        $relevantConfiguration = [];
+        $this->pageRenderer->loadRequireJs();
+        $configuration = $this->pageRenderer->getRequireJsConfig(PageRenderer::REQUIREJS_SCOPE_RESOLVE);
+
+        $shim = $configuration['shim'] ?? [];
+        foreach ($shim as $baseModuleName => $baseModuleConfiguration) {
+            if (strpos($name . '/', $baseModuleName . '/') === 0) {
+                $relevantConfiguration['shim'][$baseModuleName] = $baseModuleConfiguration;
+            }
+        }
+
+        $paths = $configuration['paths'] ?? [];
+        foreach ($paths as $baseModuleName => $baseModulePath) {
+            if (strpos($name . '/', $baseModuleName . '/') === 0) {
+                $relevantConfiguration['paths'][$baseModuleName] = $baseModulePath;
+            }
+        }
+
+        $packages = $configuration['packages'] ?? [];
+        foreach ($packages as $package) {
+            if (!empty($package['name'])
+                && strpos($name . '/', $package['name'] . '/') === 0
+            ) {
+                $relevantConfiguration['packages'][] = $package;
+            }
+        }
+
+        return $relevantConfiguration;
+    }
+}
diff --git a/Classes/Page/PageRenderer.php b/Classes/Page/PageRenderer.php
index 303ac76463..5947a717a6 100644
--- a/Classes/Page/PageRenderer.php
+++ b/Classes/Page/PageRenderer.php
@@ -45,6 +45,9 @@ class PageRenderer implements \TYPO3\CMS\Core\SingletonInterface
     // @deprecated will be removed in TYPO3 v10.0.
     const JQUERY_NAMESPACE_NONE = 'none';
 
+    const REQUIREJS_SCOPE_CONFIG = 'config';
+    const REQUIREJS_SCOPE_RESOLVE = 'resolve';
+
     /**
      * @var bool
      */
@@ -332,11 +335,23 @@ class PageRenderer implements \TYPO3\CMS\Core\SingletonInterface
     protected $addRequireJs = false;
 
     /**
-     * inline configuration for requireJS
+     * Inline configuration for requireJS (internal)
      * @var array
      */
     protected $requireJsConfig = [];
 
+    /**
+     * Module names of internal requireJS 'paths'
+     * @var array
+     */
+    protected $internalRequireJsPathModuleNames = [];
+
+    /**
+     * Inline configuration for requireJS (public)
+     * @var array
+     */
+    protected $publicRequireJsConfig = [];
+
     /**
      * @var bool
      */
@@ -599,6 +614,34 @@ public function setRequireJsPath($path)
         $this->requireJsPath = $path;
     }
 
+    /**
+     * @param string $scope
+     * @return array
+     */
+    public function getRequireJsConfig(string $scope = null): array
+    {
+        // return basic RequireJS configuration without shim, paths and packages
+        if ($scope === static::REQUIREJS_SCOPE_CONFIG) {
+            return array_replace_recursive(
+                $this->publicRequireJsConfig,
+                $this->filterArrayKeys(
+                    $this->requireJsConfig,
+                    ['shim', 'paths', 'packages'],
+                    false
+                )
+            );
+        }
+        // return RequireJS configuration for resolving only shim, paths and packages
+        if ($scope === static::REQUIREJS_SCOPE_RESOLVE) {
+            return $this->filterArrayKeys(
+                $this->requireJsConfig,
+                ['shim', 'paths', 'packages'],
+                true
+            );
+        }
+        return [];
+    }
+
     /*****************************************************/
     /*                                                   */
     /*  Public Enablers / Disablers                      */
@@ -1399,7 +1442,7 @@ public function loadJquery($version = null, $source = null, $namespace = self::J
     public function loadRequireJs()
     {
         $this->addRequireJs = true;
-        if (!empty($this->requireJsConfig)) {
+        if (!empty($this->requireJsConfig) && !empty($this->publicRequireJsConfig)) {
             return;
         }
 
@@ -1408,13 +1451,17 @@ public function loadRequireJs()
         $cacheIdentifier = 'requireJS_' . md5(implode(',', $loadedExtensions) . ($isDevelopment ? ':dev' : '') . GeneralUtility::getIndpEnv('TYPO3_REQUEST_SCRIPT'));
         /** @var FrontendInterface $cache */
         $cache = static::$cache ?? GeneralUtility::makeInstance(CacheManager::class)->getCache('assets');
-        $this->requireJsConfig = $cache->get($cacheIdentifier);
+        $requireJsConfig = $cache->get($cacheIdentifier);
 
         // if we did not get a configuration from the cache, compute and store it in the cache
-        if (empty($this->requireJsConfig)) {
-            $this->requireJsConfig = $this->computeRequireJsConfig($isDevelopment, $loadedExtensions);
-            $cache->set($cacheIdentifier, $this->requireJsConfig);
+        if (!isset($requireJsConfig['internal']) || !isset($requireJsConfig['public']) || true) {
+            $requireJsConfig = $this->computeRequireJsConfig($isDevelopment, $loadedExtensions);
+            $cache->set($cacheIdentifier, $requireJsConfig);
         }
+
+        $this->requireJsConfig = $requireJsConfig['internal'];
+        $this->publicRequireJsConfig = $requireJsConfig['public'];
+        $this->internalRequireJsPathModuleNames = $requireJsConfig['internalNames'];
     }
 
     /**
@@ -1428,18 +1475,22 @@ public function loadRequireJs()
     protected function computeRequireJsConfig($isDevelopment, array $loadedExtensions)
     {
         // load all paths to map to package names / namespaces
-        $requireJsConfig = [];
+        $requireJsConfig = [
+            'public' => [],
+            'internal' => [],
+            'internalNames' => [],
+        ];
 
         // In order to avoid browser caching of JS files, adding a GET parameter to the files loaded via requireJS
         if ($isDevelopment) {
-            $requireJsConfig['urlArgs'] = 'bust=' . $GLOBALS['EXEC_TIME'];
+            $requireJsConfig['public']['urlArgs'] = 'bust=' . $GLOBALS['EXEC_TIME'];
         } else {
-            $requireJsConfig['urlArgs'] = 'bust=' . GeneralUtility::hmac(TYPO3_version . Environment::getProjectPath());
+            $requireJsConfig['public']['urlArgs'] = 'bust=' . GeneralUtility::hmac(TYPO3_version . Environment::getProjectPath());
         }
         $corePath = ExtensionManagementUtility::extPath('core', 'Resources/Public/JavaScript/Contrib/');
         $corePath = PathUtility::getAbsoluteWebPath($corePath);
         // first, load all paths for the namespaces, and configure contrib libs.
-        $requireJsConfig['paths'] = [
+        $requireJsConfig['public']['paths'] = [
             'jquery' => $corePath . '/jquery/jquery',
             'jquery-ui' => $corePath . 'jquery-ui',
             'datatables' => $corePath . 'jquery.dataTables',
@@ -1455,16 +1506,32 @@ protected function computeRequireJsConfig($isDevelopment, array $loadedExtension
             'jquery/autocomplete' => $corePath . 'jquery.autocomplete',
             'd3' => $corePath . 'd3/d3'
         ];
-        $requireJsConfig['waitSeconds']  = 30;
+        $requireJsConfig['public']['waitSeconds'] = 30;
+        $requireJsConfig['public']['typo3BaseUrl'] = false;
+        $publicPackageNames = ['core', 'frontend', 'backend'];
         foreach ($loadedExtensions as $packageName) {
-            $fullJsPath = 'EXT:' . $packageName . '/Resources/Public/JavaScript/';
-            $fullJsPath = GeneralUtility::getFileAbsFileName($fullJsPath);
-            $fullJsPath = PathUtility::getAbsoluteWebPath($fullJsPath);
+            $jsPath = 'EXT:' . $packageName . '/Resources/Public/JavaScript/';
+            $absoluteJsPath = GeneralUtility::getFileAbsFileName($jsPath);
+            $fullJsPath = PathUtility::getAbsoluteWebPath($absoluteJsPath);
             $fullJsPath = rtrim($fullJsPath, '/');
-            if ($fullJsPath) {
-                $requireJsConfig['paths']['TYPO3/CMS/' . GeneralUtility::underscoredToUpperCamelCase($packageName)] = $fullJsPath;
+            if (!empty($fullJsPath) && file_exists($absoluteJsPath)) {
+                $type = in_array($packageName, $publicPackageNames, true) ? 'public' : 'internal';
+                $requireJsConfig[$type]['paths']['TYPO3/CMS/' . GeneralUtility::underscoredToUpperCamelCase($packageName)] = $fullJsPath;
             }
         }
+        // sanitize module names in internal 'paths'
+        $internalPathModuleNames = array_keys($requireJsConfig['internal']['paths'] ?? []);
+        $sanitizedInternalPathModuleNames = array_map(
+            function ($moduleName) {
+                // trim spaces and slashes & add ending slash
+                return trim($moduleName, ' /') . '/';
+            },
+            $internalPathModuleNames
+        );
+        $requireJsConfig['internalNames'] = array_combine(
+            $sanitizedInternalPathModuleNames,
+            $internalPathModuleNames
+        );
 
         // check if additional AMD modules need to be loaded if a single AMD module is initialized
         if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['RequireJS']['postInitializationModules'] ?? false)) {
@@ -1498,6 +1565,72 @@ public function addRequireJsConfiguration(array $configuration)
         \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($this->requireJsConfig, $configuration);
     }
 
+    /**
+     * Generates RequireJS loader HTML markup.
+     *
+     * @return string
+     * @throws \TYPO3\CMS\Backend\Routing\Exception\RouteNotFoundException
+     */
+    protected function getRequireJsLoader(): string
+    {
+        $html = '';
+        $backendRequest = TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_BE;
+        $backendUserLoggedIn = !empty($GLOBALS['BE_USER']->user['uid']);
+
+        // no backend request - basically frontend
+        if (!$backendRequest) {
+            $requireJsConfig = $this->getRequireJsConfig(static::REQUIREJS_SCOPE_CONFIG);
+            $requireJsConfig['typo3BaseUrl'] = GeneralUtility::getIndpEnv('TYPO3_SITE_PATH') . '?eID=requirejs';
+        // backend request, but no backend user logged in
+        } elseif (!$backendUserLoggedIn) {
+            $uriBuilder = GeneralUtility::makeInstance(UriBuilder::class);
+            $requireJsConfig = $this->getRequireJsConfig(static::REQUIREJS_SCOPE_CONFIG);
+            $requireJsConfig['typo3BaseUrl'] = (string)$uriBuilder->buildUriFromRoute('ajax_core_requirejs');
+        // backend request, having backend user logged in
+        } else {
+            $requireJsConfig = array_replace_recursive(
+                $this->publicRequireJsConfig,
+                $this->requireJsConfig
+            );
+        }
+
+        // add (probably filtered) RequireJS configuration
+        $html .= GeneralUtility::wrapJS('var require = ' . json_encode($requireJsConfig)) . LF;
+        // directly after that, include the require.js file
+        $html .= '<script src="'
+            . $this->processJsFile($this->requireJsPath . 'require.js')
+            . '" type="text/javascript"></script>' . LF;
+
+        if (!empty($requireJsConfig['typo3BaseUrl'])) {
+            $html .= '<script src="'
+                . $this->processJsFile($this->getAbsoluteWebPath(
+                    GeneralUtility::getFileAbsFileName(
+                        'EXT:core/Resources/Public/JavaScript/requirejs-loader.js'
+                    )
+                ))
+                . '" type="text/javascript"></script>' . LF;
+        }
+
+        return $html;
+    }
+
+    /**
+     * @param array $array
+     * @param string[] $keys
+     * @param bool $keep
+     * @return array
+     */
+    protected function filterArrayKeys(array $array, array $keys, bool $keep = true): array
+    {
+        return array_filter(
+            $array,
+            function (string $key) use ($keys, $keep) {
+                return in_array($key, $keys, true) === $keep;
+            },
+            ARRAY_FILTER_USE_KEY
+        );
+    }
+
     /**
      * includes an AMD-compatible JS file by resolving the ModuleName, and then requires the file via a requireJS request,
      * additionally allowing to execute JavaScript code afterwards
@@ -1519,7 +1652,13 @@ public function loadRequireJsModule($mainModuleName, $callBackFunction = null)
         $inlineCodeKey = $mainModuleName;
         // make sure requireJS is initialized
         $this->loadRequireJs();
-
+        // move internal module path definition to public module definition
+        // (since loading a module ends up disclosing the existence anyway)
+        $baseModuleName = $this->findRequireJsBaseModuleName($mainModuleName);
+        if ($baseModuleName !== null && isset($this->requireJsConfig['paths'][$baseModuleName])) {
+            $this->publicRequireJsConfig['paths'][$baseModuleName] = $this->requireJsConfig['paths'][$baseModuleName];
+            unset($this->requireJsConfig['paths'][$baseModuleName]);
+        }
         // execute the main module, and load a possible callback function
         $javaScriptCode = 'require(["' . $mainModuleName . '"]';
         if ($callBackFunction !== null) {
@@ -1530,6 +1669,24 @@ public function loadRequireJsModule($mainModuleName, $callBackFunction = null)
         $this->addJsInlineCode('RequireJS-Module-' . $inlineCodeKey, $javaScriptCode);
     }
 
+    /**
+     * Determines requireJS base module name (if defined).
+     *
+     * @param string $moduleName
+     * @return string|null
+     */
+    protected function findRequireJsBaseModuleName(string $moduleName)
+    {
+        // trim spaces and slashes & add ending slash
+        $sanitizedModuleName = trim($moduleName, ' /') . '/';
+        foreach ($this->internalRequireJsPathModuleNames as $sanitizedBaseModuleName => $baseModuleName) {
+            if (strpos($sanitizedModuleName, $sanitizedBaseModuleName) === 0) {
+                return $baseModuleName;
+            }
+        }
+        return null;
+    }
+
     /**
      * Adds Javascript Inline Label. This will occur in TYPO3.lang - object
      * The label can be used in scripts with TYPO3.lang.<key>
@@ -1938,10 +2095,7 @@ protected function renderMainJavaScriptLibraries()
 
         // Include RequireJS
         if ($this->addRequireJs) {
-            // load the paths of the requireJS configuration
-            $out .= GeneralUtility::wrapJS('var require = ' . json_encode($this->requireJsConfig)) . LF;
-            // directly after that, include the require.js file
-            $out .= '<script src="' . $this->processJsFile($this->requireJsPath . 'require.js') . '" type="text/javascript"></script>' . LF;
+            $out .= $this->getRequireJsLoader();
         }
 
         // Include jQuery Core for each namespace, depending on the version and source
@@ -1953,7 +2107,8 @@ protected function renderMainJavaScriptLibraries()
 
         $this->loadJavaScriptLanguageStrings();
         if (TYPO3_MODE === 'BE') {
-            $this->addAjaxUrlsToInlineSettings();
+            $noBackendUserLoggedIn = empty($GLOBALS['BE_USER']->user['uid']);
+            $this->addAjaxUrlsToInlineSettings($noBackendUserLoggedIn);
         }
         $inlineSettings = '';
         $languageLabels = $this->parseLanguageLabelsForJavaScript();
@@ -2031,8 +2186,10 @@ protected function convertCharsetRecursivelyToUtf8(&$data, string $fromCharset)
 
     /**
      * Make URLs to all backend ajax handlers available as inline setting.
+     *
+     * @param bool $publicRoutesOnly
      */
-    protected function addAjaxUrlsToInlineSettings()
+    protected function addAjaxUrlsToInlineSettings(bool $publicRoutesOnly = false)
     {
         $ajaxUrls = [];
         // Add the ajax-based routes
@@ -2042,6 +2199,9 @@ protected function addAjaxUrlsToInlineSettings()
         $router = GeneralUtility::makeInstance(Router::class);
         $routes = $router->getRoutes();
         foreach ($routes as $routeIdentifier => $route) {
+            if ($publicRoutesOnly && $route->getOption('access') !== 'public') {
+                continue;
+            }
             if ($route->getOption('ajax')) {
                 $uri = (string)$uriBuilder->buildUriFromRoute($routeIdentifier);
                 // use the shortened value in order to use this in JavaScript
diff --git a/Configuration/Backend/AjaxRoutes.php b/Configuration/Backend/AjaxRoutes.php
new file mode 100644
index 0000000000..7a8faaecea
--- /dev/null
+++ b/Configuration/Backend/AjaxRoutes.php
@@ -0,0 +1,14 @@
+<?php
+use TYPO3\CMS\Core\Controller\RequireJsController;
+
+/**
+ * Definitions for routes provided by EXT:core
+ */
+return [
+    // dynamically load requirejs module definitions
+    'core_requirejs' => [
+        'path' => '/core/requirejs',
+        'access' => 'public',
+        'target' => RequireJsController::class . '::retrieveConfiguration',
+    ],
+];
diff --git a/Resources/Public/JavaScript/requirejs-loader.js b/Resources/Public/JavaScript/requirejs-loader.js
new file mode 100644
index 0000000000..e0a000af30
--- /dev/null
+++ b/Resources/Public/JavaScript/requirejs-loader.js
@@ -0,0 +1,134 @@
+(function(req) {
+  /**
+   * Determines whether moduleName is configured in requirejs paths
+   * (this code was taken from RequireJS context.nameToUrl).
+   *
+   * @see context.nameToUrl
+   * @see https://github.com/requirejs/requirejs/blob/2.3.3/require.js#L1650-L1670
+   *
+   * @param {Object} config the require context to find state.
+   * @param {String} moduleName the name of the module.
+   * @return {boolean}
+   */
+  var inPath = function(config, moduleName) {
+    var i, parentModule, parentPath;
+    var paths = config.paths;
+    var syms = moduleName.split('/');
+    //For each module name segment, see if there is a path
+    //registered for it. Start with most specific name
+    //and work up from it.
+    for (i = syms.length; i > 0; i -= 1) {
+      parentModule = syms.slice(0, i).join('/');
+      parentPath = paths[parentModule];
+      if (parentPath) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  /**
+   * @return {XMLHttpRequest}
+   */
+  var createXhr = function() {
+    if (typeof XMLHttpRequest !== 'undefined') {
+      return new XMLHttpRequest();
+    } else {
+      return new ActiveXObject('Microsoft.XMLHTTP');
+    }
+  };
+
+  /**
+   * Fetches RequireJS configuration from server via XHR call.
+   *
+   * @param {object} config
+   * @param {string} name
+   * @param {function} success
+   * @param {function} error
+   */
+  var fetchConfiguration = function(config, name, success, error) {
+    // cannot use jQuery here which would be loaded via RequireJS...
+    var xhr = createXhr();
+    xhr.onreadystatechange = function() {
+      if (this.readyState !== 4) {
+        return;
+      }
+      try {
+        if (this.status === 200) {
+          success(JSON.parse(xhr.responseText));
+        } else {
+          error(this.status, xhr.statusText);
+        }
+      } catch (error) {
+        error(this.status, error);
+      }
+    };
+    xhr.open('GET', config.typo3BaseUrl + '&name=' + encodeURIComponent(name));
+    xhr.send();
+  };
+
+  /**
+   * Adds aspects to RequireJS configuration keys paths and packages.
+   *
+   * @param {object} config
+   * @param {string} data
+   * @param {object} context
+   */
+  var addToConfiguration = function(config, data, context) {
+    if (data.shim && data.shim instanceof Object) {
+      if (typeof config.shim === 'undefined') {
+        config.shim = {};
+      }
+      Object.keys(data.shim).forEach(function(moduleName) {
+        config.shim[moduleName] = data.shim[moduleName];
+      });
+    }
+    if (data.paths && data.paths instanceof Object) {
+      if (typeof config.paths === 'undefined') {
+        config.paths = {};
+      }
+      Object.keys(data.paths).forEach(function(moduleName) {
+        config.paths[moduleName] = data.paths[moduleName];
+      });
+    }
+    if (data.packages && data.packages instanceof Array) {
+      if (typeof config.packages === 'undefined') {
+        config.packages = [];
+      }
+      data.packages.forEach(function (packageName) {
+        config.packages.push(packageName);
+      });
+    }
+    context.configure(config);
+  };
+
+  // keep reference to RequireJS default loader
+  var originalLoad = req.load;
+
+  /**
+   * Does the request to load a module for the browser case.
+   * Make this a separate function to allow other environments
+   * to override it.
+   *
+   * @param {Object} context the require context to find state.
+   * @param {String} name the name of the module.
+   * @param {Object} url the URL to the module.
+   */
+  req.load = function(context, name, url) {
+    if (inPath(context.config, name)) {
+      return originalLoad.call(req, context, name, url);
+    }
+
+    fetchConfiguration(
+      context.config,
+      name,
+      function(data) {
+        addToConfiguration(context.config, data, context);
+        url = context.nameToUrl(name);
+        // result cannot be returned since nested in two asynchronous calls
+        originalLoad.call(req, context, name, url);
+      },
+      function() {}
+    );
+  };
+})(requirejs);
diff --git a/ext_localconf.php b/ext_localconf.php
index d441fc77f8..3227779f19 100644
--- a/ext_localconf.php
+++ b/ext_localconf.php
@@ -89,6 +89,7 @@
 unset($signalSlotDispatcher);
 
 $GLOBALS['TYPO3_CONF_VARS']['FE']['eID_include']['dumpFile'] = \TYPO3\CMS\Core\Controller\FileDumpController::class . '::dumpAction';
+$GLOBALS['TYPO3_CONF_VARS']['FE']['eID_include']['requirejs'] = \TYPO3\CMS\Core\Controller\RequireJsController::class . '::retrievePath';
 
 /** @var \TYPO3\CMS\Core\Resource\Rendering\RendererRegistry $rendererRegistry */
 $rendererRegistry = \TYPO3\CMS\Core\Resource\Rendering\RendererRegistry::getInstance();", "url": "https://github.com/TYPO3-CMS/core/commit/9453d8a8763fffa76deb6a16f6b99c0ab6f3d8f1.patch" } ]
null
GHSA-qxh2-x3x4-mxxw
null
[ { "commit_message": "[PATCH] extend minimum number of password .../app/src/server/middlewares/register-form-validator.ts | 5 +++-- packages/app/src/server/routes/apiv3/user-activation.ts | 5 +++-- 2 files changed, 6 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/weseek/growi/commit/b584e2a47ee3c8ce1d8ef38238302825c015327e.patch" } ]
null
GHSA-fvjx-7cx6-588x
null
[ { "commit_message": "[PATCH] Discard job body bytes if the job is too big. Previously, a malicious user could craft a job payload and inject beanstalk commands without the client application knowing. (An extra-careful client library could check the size of the job body before sending the put command, but most libraries do not do this, nor should they have to.) Reported by Graham Barr. check-one.sh | 2 +- prot.c | 3 ++- sh-tests/too-big.commands | 3 +++ sh-tests/too-big.expected | 1 + 4 files changed, 7 insertions(+), 2 deletions(-) create mode 100644 sh-tests/too-big.commands create mode 100644 sh-tests/too-big.expected", "patch_text_b64": "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", "url": "http://github.com/kr/beanstalkd/commit/2e8e8c6387ecdf5923dfc4d7718d18eba1b0873d.patch" } ]
null
CVE-2022-31888
Session Fixation vulnerability in in function login in class.auth.php in osTicket through 1.16.2.
[ { "commit_message": "[PATCH] Security: Session Fixation This commit addresses possible session fixation on both agent and end user login. Upon login users are now issued new session with the old one invalidated. include/class.auth.php | 15 +- include/class.usersession.php | 263 +++++++++++++++++++--------------- open.php | 6 +- 3 files changed, 157 insertions(+), 127 deletions(-)", "patch_text_b64": "From 85a76f403a3a116176d0798f39a4c430181d8364 Mon Sep 17 00:00:00 2001
From: Peter Rotich <peter@osticket.com>
Date: Sun, 24 Apr 2022 20:49:20 +0000
Subject: [PATCH] Security: Session Fixation

This commit addresses possible session fixation on both agent and end user
login. Upon login users are now issued new session with the old one
invalidated.
---
 include/class.auth.php        |  15 +-
 include/class.usersession.php | 263 +++++++++++++++++++---------------
 open.php                      |   6 +-
 3 files changed, 157 insertions(+), 127 deletions(-)

diff --git a/include/class.auth.php b/include/class.auth.php
index e1e864a946..fc4c53f421 100644
--- a/include/class.auth.php
+++ b/include/class.auth.php
@@ -538,6 +538,8 @@ function login($staff, $bk) {
             || !($authkey=$bk->getAuthKey($staff)))
             return false;
 
+        // Regenerate session id and refresh (avoid session fixation)
+        $staff->regenerateSession();
         //Log debug info.
         $ost->logDebug(_S('Agent Login'),
             sprintf(_S("%s logged in [%s], via %s"), $staff->getUserName(),
@@ -563,9 +565,10 @@ function login($staff, $bk) {
         $authsession['id'] = $staff->getId();
         $authsession['key'] =  $authkey;
         $authsession['2fa'] =  $auth2fa;
-
+        // Set session token
+        $staff->setSessionToken();
+        // Set Auth Key
         $staff->setAuthKey($authkey);
-        $staff->refreshSession(true); //set the hash.
         Signal::send('auth.login.succeeded', $staff);
 
         if ($bk->supportsInteractiveAuthentication())
@@ -755,15 +758,15 @@ function login($user, $bk) {
                 throw new AccessDenied(__('Account is administratively locked'));
         }
 
+        // Regenerate session id and refresh (avoid session fixation)
+        $user->regenerateSession();
         // Tag the user and associated ticket in the SESSION
         $this->setAuthKey($user, $bk, $authkey);
-
+        // Set Session Token
+        $user->setSessionToken();
         //The backend used decides the format of the auth key.
         // XXX: encrypt to hide the bk??
         $user->setAuthKey($authkey);
-
-        $user->refreshSession(true); //set the hash.
-
         //Log login info...
         $msg=sprintf(_S('%1$s (%2$s) logged in [%3$s]'
                 /* Tokens are <username>, <id>, and <ip> */),
diff --git a/include/class.usersession.php b/include/class.usersession.php
index 9184087637..99df20020f 100644
--- a/include/class.usersession.php
+++ b/include/class.usersession.php
@@ -17,137 +17,163 @@ class.usersession.php
 include_once(INCLUDE_DIR.'class.client.php');
 include_once(INCLUDE_DIR.'class.staff.php');
 
-
 class UserSession {
    var $session_id = '';
-   var $userID='';
+   var $userID = 0;
    var $browser = '';
    var $ip = '';
-   var $validated=FALSE;
-
-   function __construct($userid){
+   var $validated = false;
 
-      $this->browser=(!empty($_SERVER['HTTP_USER_AGENT'])) ? $_SERVER['HTTP_USER_AGENT'] : $_ENV['HTTP_USER_AGENT'];
-      $this->ip=(!empty($_SERVER['REMOTE_ADDR'])) ? $_SERVER['REMOTE_ADDR'] : getenv('REMOTE_ADDR');
-      $this->session_id=session_id();
-      $this->userID=$userid;
+   function __construct($userid) {
+      $this->browser = (!empty($_SERVER['HTTP_USER_AGENT'])) ? $_SERVER['HTTP_USER_AGENT'] : $_ENV['HTTP_USER_AGENT'];
+      $this->ip = (!empty($_SERVER['REMOTE_ADDR'])) ? $_SERVER['REMOTE_ADDR'] : getenv('REMOTE_ADDR');
+      $this->session_id = session_id();
+      $this->userID = $userid;
    }
 
-   function isStaff(){
-       return FALSE;
+   function isStaff() {
+       return false;
    }
 
    function isClient() {
-       return FALSE;
+       return false;
    }
 
-
-   function getSessionId(){
+   function getSessionId() {
        return $this->session_id;
    }
 
-   function getIP(){
+   function getIP() {
         return  $this->ip;
    }
 
-   function getBrowser(){
+   function getBrowser() {
        return $this->browser;
    }
-   function refreshSession(){
-       //nothing to do...clients need to worry about it.
-   }
 
    function sessionToken(){
-
       $time  = time();
       $hash  = md5($time.SESSION_SECRET.$this->userID);
       $token = "$hash:$time:".MD5($this->ip);
-
-      return($token);
+      return $token;
    }
 
    function getLastUpdate($htoken) {
        if (!$htoken)
            return 0;
 
-       @list($hash,$expire,$ip)=explode(":",$htoken);
+       @list($hash, $expire, $ip) = explode(":", $htoken);
        return $expire;
    }
 
    function isvalidSession($htoken,$maxidletime=0,$checkip=false){
-        global $cfg;
+        global $cfgi;
 
-        $token = rawurldecode($htoken);
+        // Compare session ids
+        if (strcmp($this->getSessionId(), session_id()))
+            return false;
 
-        #check if we got what we expected....
-        if($token && !strstr($token,":"))
-            return FALSE;
+        // Is the session invalidated?
+        if (isset($_SESSION['KAPUT']) &&  $_SESSION['KAPUT'] < time())
+            return (session_destroy() && false);
 
-        #get the goodies
-        list($hash,$expire,$ip)=explode(":",$token);
+        $token = rawurldecode($htoken);
+        // Check if we got what we expected....
+        if ($token && !strstr($token,":"))
+            return false;
 
-        #Make sure the session hash is valid
-        if((md5($expire . SESSION_SECRET . $this->userID)!=$hash)){
-            return FALSE;
-        }
-        #is it expired??
+        // Get the goodies
+        list($hash, $expire, $ip) = explode(":",$token);
 
+        // Make sure the session hash is valid
+        if ((md5($expire . SESSION_SECRET . $this->userID) != $hash))
+            return false;
+
+        // is it expired??
+        if ($maxidletime && ((time()-$expire)>$maxidletime))
+            return false;
 
-        if($maxidletime && ((time()-$expire)>$maxidletime)){
-            return FALSE;
-        }
         #Make sure IP is still same ( proxy access??????)
-        if($checkip && strcmp($ip, MD5($this->ip)))
-            return FALSE;
+        if ($checkip && strcmp($ip, MD5($this->ip)))
+            return false;
+
+        $this->validated = true;
 
-        $this->validated=TRUE;
+        return true;
+   }
+
+   function regenerateSession($destroy=false) {
+       // Delayed kaput time for current session
+       $_SESSION['KAPUT'] = time() + 60;
+       // Save the session id as old
+       $old = session_id();
+       // Regenerate the session without destroying data
+       session_regenerate_id(false);
+       // Get new session id and close
+       $new = session_id();
+       session_write_close();
+       // Start new session
+       session_id($new);
+       session_start();
+       $this->session_id  = $new;
+       // Make sure new session is not set to KAPUT
+       unset($_SESSION['KAPUT']);
+       // Destroy ?
+       if ($destroy) {
+           // Destrory old session
+           $this->destroySession($old);
+           // Restore new session
+           session_id($new);
+           session_start();
+       }
+       return true;
+   }
 
-        return TRUE;
+   function destroySession($id) {
+       // Close current session
+       session_write_close();
+       // Start target session
+       session_id($id);
+       session_start();
+       // Destroy session
+       session_destroy();
+       session_write_close();
+       return true;
    }
 
    function isValid() {
-        return FALSE;
+        return  ($this->validated);
    }
 
 }
 
-class ClientSession extends EndUser {
 
+trait UserSessionTrait {
+    // Session Object
     var $session;
+    // Session Token
     var $token;
-
-    function __construct($user) {
-        parent::__construct($user);
-        $this->token = &$_SESSION[':token']['client'];
-        // XXX: Change the key to user-id
-        $this->session= new UserSession($user->getId());
-    }
-
-    function getSessionUser() {
-        return $this->user;
-    }
-
-    function isValid(){
-        global $_SESSION,$cfg;
-
-        if(!$this->getId() || $this->session->getSessionId()!=session_id())
-            return false;
-
-        return $this->session->isvalidSession($this->token,$cfg->getClientTimeout(),false)?true:false;
-    }
-
-    function refreshSession($force=false){
-        global $cfg;
-
+    // Maximum idle time before session is considered invalid
+    var $maxidletime = 0;
+    // Indicates if session is bound to the IP address
+    var $checkip = false;
+    // User class
+    var $class = '';
+
+    function refreshSession($force=false) {
         $time = $this->session->getLastUpdate($this->token);
         // Deadband session token updates to once / 30-seconds
         if (!$force && time() - $time < 30)
             return;
 
         $this->token = $this->getSessionToken();
-        //TODO: separate expire time from hash??
+        osTicketSession::renewCookie($time, $this->maxidletime);
+    }
 
-        osTicketSession::renewCookie($time, $cfg->getClientSessionTimeout());
+    function regenerateSession($destroy=false) {
+        $this->session->regenerateSession($destroy);
+        // Set cookie for the new session id.
+        $this->refreshSession(true);
     }
 
     function getSession() {
@@ -158,75 +184,76 @@ function getSessionToken() {
         return $this->session->sessionToken();
     }
 
-    function getIP(){
+    function setSessionToken($token=null) {
+        // Assign memory to token variable
+        $this->token = &$_SESSION[':token'][$this->class];
+        // Set token
+        $this->token = $token ?: $this->getSessionToken();
+    }
+
+    function getIP() {
         return $this->session->getIP();
     }
+
+    function isValidSession() {
+        return ($this->getId()
+                && $this->session->isvalidSession($this->token,
+                    $this->maxidletime, $this->checkip));
+    }
+
+    abstract function isValid();
 }
 
+class ClientSession extends EndUser {
+    use UserSessionTrait;
 
-class StaffSession extends Staff {
+    function __construct($user) {
+        global $cfg;
+        parent::__construct($user);
+        $this->class ='client';
+        // XXX: Change the key to user-id
+        $this->session = new UserSession($user->getId());
+        $this->setSessionToken();
+        $this->maxidletime = $cfg->getClientTimeout();
+    }
 
-    var $session;
-    var $token;
+    function getSessionUser() {
+        return $this->user;
+    }
+
+    function isValid() {
+        return $this->isValidSession();
+    }
+}
+
+class StaffSession extends Staff {
+    use UserSessionTrait;
 
     static function lookup($var) {
-        if ($staff = parent::lookup($var)) {
-            $staff->token = &$_SESSION[':token']['staff'];
-            $staff->session= new UserSession($staff->getId());
+        global $cfg;
+        if (($staff = parent::lookup($var))) {
+            $staff->class = 'staff';
+            $staff->session = new UserSession($staff->getId());
+            $staff->setSessionToken();
+            $staff->maxidletime = $cfg->getStaffTimeout();
+            $staff->checkip = $cfg->enableStaffIPBinding();
         }
         return $staff;
     }
 
     function clear2FA() {
+        unset($_SESSION['_auth']['staff']['2fa']);
         $_SESSION['_auth']['staff']['2fa'] = null;
         return true;
     }
 
     // If 2fa is set then it means it's pending
     function is2FAPending() {
-        if (!isset($_SESSION['_auth']['staff']['2fa']))
-            return false;
-
-        return true;
-    }
-
-    function isValid(){
-        global $cfg;
-
-        if(!$this->getId() || $this->session->getSessionId()!=session_id())
-            return false;
-
-        if ($this->is2FAPending())
-            return false;
-
-        return $this->session->isvalidSession($this->token,$cfg->getStaffTimeout(),$cfg->enableStaffIPBinding())?true:false;
-    }
-
-    function refreshSession($force=false){
-        global $cfg;
-
-        $time = $this->session->getLastUpdate($this->token);
-        // Deadband session token updates to once / 30-seconds
-        if (!$force && time() - $time < 30)
-            return;
-
-        $this->token=$this->getSessionToken();
-
-        osTicketSession::renewCookie($time, $cfg->getStaffSessionTimeout());
-    }
-
-    function getSession() {
-        return $this->session;
-    }
-
-    function getSessionToken() {
-        return $this->session->sessionToken();
+        return isset($_SESSION['_auth']['staff']['2fa']);
     }
 
-    function getIP(){
-        return $this->session->getIP();
+    function isValid() {
+        return (!$this->is2FAPending() && $this->isValidSession());
     }
-
 }
-
 ?>
diff --git a/open.php b/open.php
index 2c138a76e7..10f0b0a273 100644
--- a/open.php
+++ b/open.php
@@ -47,9 +47,9 @@
         // Drop session-backed form data
         unset($_SESSION[':form-data']);
         //Logged in...simply view the newly created ticket.
-        if($thisclient && $thisclient->isValid()) {
-            session_regenerate_id();
-            session_write_close();
+        if ($thisclient && $thisclient->isValid()) {
+            // Regenerate session id
+            $thisclient->regenerateSession();
             @header('Location: tickets.php?id='.$ticket->getId());
         } else
             $ost->getCSRF()->rotate();", "url": "https://github.com/osTicket/osTicket/commit/85a76f403a3a116176d0798f39a4c430181d8364.patch" } ]
n/a
CVE-2020-5264
Reflected XSS in security compromised page of PrestaShop
In PrestaShop before version 1.7.6.5, there is a reflected XSS while running the security compromised page. It allows anyone to execute arbitrary action. The problem is patched in the 1.7.6.5.
[ { "commit_message": "[PATCH] Test if it's a correct url before continue .../Controller/Admin/SecurityController.php | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/PrestaShop/PrestaShop/commit/06b7765c91c58e09ab4f8ddafbde02070fcb6f3a.patch" } ]
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
CVE-2025-46571
Open WebUI vulnerable to limited stored XSS vila uploaded html file
Open WebUI is a self-hosted artificial intelligence platform designed to operate entirely offline. Prior to version 0.6.6, low privileged users can upload HTML files which contain JavaScript code via the `/api/v1/files/` backend endpoint. This endpoint returns a file id, which can be used to open the file in the browser and trigger the JavaScript code in the user's browser. Under the default settings, files uploaded by low-privileged users can only be viewed by admins or themselves, limiting the impact of this vulnerability. A link to such a file can be sent to an admin, and if clicked, will give the low-privileged user complete control over the admin's account, ultimately enabling RCE via functions. Version 0.6.6 contains a fix for the issue.
[ { "commit_message": "[PATCH] fix: only allow admin uploaded html to be rendered as html backend/open_webui/routers/files.py | 10 ++++++++++ 1 file changed, 10 insertions(+)", "patch_text_b64": "RnJvbSBlZjJhZWI3YzBlYjk3NmJhYzc1OWU1OWFjMzU5Yzk0YTViOGRjN2UwIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUaW1vdGh5IEphZXJ5YW5nIEJhZWsgPHRpbUBvcGVud2VidWkuY29tPgpEYXRlOiBXZWQsIDMwIEFwciAyMDI1IDE5OjM0OjUzICswNDAwClN1YmplY3Q6IFtQQVRDSF0gZml4OiBvbmx5IGFsbG93IGFkbWluIHVwbG9hZGVkIGh0bWwgdG8gYmUgcmVuZGVyZWQgYXMgaHRtbAoKLS0tCiBiYWNrZW5kL29wZW5fd2VidWkvcm91dGVycy9maWxlcy5weSB8IDEwICsrKysrKysrKysKIDEgZmlsZSBjaGFuZ2VkLCAxMCBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvYmFja2VuZC9vcGVuX3dlYnVpL3JvdXRlcnMvZmlsZXMucHkgYi9iYWNrZW5kL29wZW5fd2VidWkvcm91dGVycy9maWxlcy5weQppbmRleCBjOTNkOTYyNTllYi4uOWRkYmQyMzExN2EgMTAwNjQ0Ci0tLSBhL2JhY2tlbmQvb3Blbl93ZWJ1aS9yb3V0ZXJzL2ZpbGVzLnB5CisrKyBiL2JhY2tlbmQvb3Blbl93ZWJ1aS9yb3V0ZXJzL2ZpbGVzLnB5CkBAIC0xOSw2ICsxOSw4IEBACiBmcm9tIGZhc3RhcGkucmVzcG9uc2VzIGltcG9ydCBGaWxlUmVzcG9uc2UsIFN0cmVhbWluZ1Jlc3BvbnNlCiBmcm9tIG9wZW5fd2VidWkuY29uc3RhbnRzIGltcG9ydCBFUlJPUl9NRVNTQUdFUwogZnJvbSBvcGVuX3dlYnVpLmVudiBpbXBvcnQgU1JDX0xPR19MRVZFTFMKKworZnJvbSBvcGVuX3dlYnVpLm1vZGVscy51c2VycyBpbXBvcnQgVXNlcnMKIGZyb20gb3Blbl93ZWJ1aS5tb2RlbHMuZmlsZXMgaW1wb3J0ICgKICAgICBGaWxlRm9ybSwKICAgICBGaWxlTW9kZWwsCkBAIC00NDksNiArNDUxLDE0IEBAIGFzeW5jIGRlZiBnZXRfaHRtbF9maWxlX2NvbnRlbnRfYnlfaWQoaWQ6IHN0ciwgdXNlcj1EZXBlbmRzKGdldF92ZXJpZmllZF91c2VyKSk6CiAgICAgICAgICAgICBkZXRhaWw9RVJST1JfTUVTU0FHRVMuTk9UX0ZPVU5ELAogICAgICAgICApCiAKKyAgICBmaWxlX3VzZXIgPSBVc2Vycy5nZXRfdXNlcl9ieV9pZChmaWxlLnVzZXJfaWQpCisgICAgaWYgbm90IGZpbGVfdXNlci5yb2xlID09ICJhZG1pbiI6CisgICAgICAgIGlmIG5vdCBmaWxlX3VzZXI6CisgICAgICAgICAgICByYWlzZSBIVFRQRXhjZXB0aW9uKAorICAgICAgICAgICAgICAgIHN0YXR1c19jb2RlPXN0YXR1cy5IVFRQXzQwNF9OT1RfRk9VTkQsCisgICAgICAgICAgICAgICAgZGV0YWlsPUVSUk9SX01FU1NBR0VTLk5PVF9GT1VORCwKKyAgICAgICAgICAgICkKKwogICAgIGlmICgKICAgICAgICAgZmlsZS51c2VyX2lkID09IHVzZXIuaWQKICAgICAgICAgb3IgdXNlci5yb2xlID09ICJhZG1pbiI=", "url": "https://github.com/open-webui/open-webui/commit/ef2aeb7c0eb976bac759e59ac359c94a5b8dc7e0.patch" } ]
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
GHSA-w2hv-rcqr-2h7r
View name validation bypass in Jenkins
null
[ { "commit_message": "[PATCH] [SECURITY-1871] core/src/main/java/hudson/model/View.java | 4 ++- .../java/hudson/model/ViewSEC1871Test.java | 34 +++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 test/src/test/java/hudson/model/ViewSEC1871Test.java", "patch_text_b64": "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", "url": "https://github.com/jenkinsci/jenkins/commit/42e2c74049ddf5e0aca1fe6aadc7b24fdabb5494.patch" } ]
null
CVE-2025-2849
UPX p_lx_elf.cpp un_DT_INIT heap-based overflow
A vulnerability, which was classified as problematic, was found in UPX up to 5.0.0. Affected is the function PackLinuxElf64::un_DT_INIT of the file src/p_lx_elf.cpp. The manipulation leads to heap-based buffer overflow. It is possible to launch the attack on the local host. The exploit has been disclosed to the public and may be used. The patch is identified as e0b6ff192412f5bb5364c1948f4f6b27a0cd5ea2. It is recommended to apply a patch to fix this issue.
[ { "commit_message": "[PATCH] More checking in unpack() https://github.com/upx/upx/issues/898 modified: p_lx_elf.cpp src/p_lx_elf.cpp | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/upx/upx/commit/e0b6ff192412f5bb5364c1948f4f6b27a0cd5ea2.patch" } ]
Heap-based Buffer Overflow
GHSA-h4rm-mm56-xf63
Fickling vulnerable to detection bypass due to "builtins" blindness
null
[ { "commit_message": "[PATCH] Emit AST nodes for builtins imports See GHSA-h4rm-mm56-xf63. fickling/fickle.py | 25 ++++++------------------- test/test_bypasses.py | 31 +++++++++++++++++++++++++++++++ test/test_pickle.py | 4 ++-- 3 files changed, 39 insertions(+), 21 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/trailofbits/fickling/commit/9f309ab834797f280cb5143a2f6f987579fa7cdf.patch" } ]
null
GHSA-c52f-pq47-2r9j
plugin.yaml file allows for duplicate entries in helm
null
[ { "commit_message": "[PATCH] backported fixes from helm3 Signed-off-by: Matt Butcher <matt.butcher@microsoft.com> (cherry picked from commit 7c287078c1505fbe662fcb77fcb2b873b01d501f) pkg/chartutil/requirements.go | 13 ++++++++++ pkg/chartutil/requirements_test.go | 21 ++++++++++++++++ pkg/plugin/plugin.go | 10 ++++++++ pkg/plugin/plugin_test.go | 1 + pkg/plugin/testdata/plugdir/hello2/hello.sh | 13 ++++++++++ .../testdata/plugdir/hello2/plugin.yaml | 11 +++++++++ pkg/repo/index.go | 24 +++++++++++++++++++ pkg/repo/index_test.go | 16 +++++++++++++ 8 files changed, 109 insertions(+) create mode 100755 pkg/plugin/testdata/plugdir/hello2/hello.sh create mode 100644 pkg/plugin/testdata/plugdir/hello2/plugin.yaml", "patch_text_b64": "From 6aab63765f99050b115f0aec3d6350c85e8da946 Mon Sep 17 00:00:00 2001
From: Matt Butcher <matt.butcher@microsoft.com>
Date: Tue, 15 Sep 2020 17:07:54 -0600
Subject: [PATCH] backported fixes from helm3

Signed-off-by: Matt Butcher <matt.butcher@microsoft.com>
(cherry picked from commit 7c287078c1505fbe662fcb77fcb2b873b01d501f)
---
 pkg/chartutil/requirements.go                 | 13 ++++++++++
 pkg/chartutil/requirements_test.go            | 21 ++++++++++++++++
 pkg/plugin/plugin.go                          | 10 ++++++++
 pkg/plugin/plugin_test.go                     |  1 +
 pkg/plugin/testdata/plugdir/hello2/hello.sh   | 13 ++++++++++
 .../testdata/plugdir/hello2/plugin.yaml       | 11 +++++++++
 pkg/repo/index.go                             | 24 +++++++++++++++++++
 pkg/repo/index_test.go                        | 16 +++++++++++++
 8 files changed, 109 insertions(+)
 create mode 100755 pkg/plugin/testdata/plugdir/hello2/hello.sh
 create mode 100644 pkg/plugin/testdata/plugdir/hello2/plugin.yaml

diff --git a/pkg/chartutil/requirements.go b/pkg/chartutil/requirements.go
index d72aa9da577..0bd16d2eb52 100644
--- a/pkg/chartutil/requirements.go
+++ b/pkg/chartutil/requirements.go
@@ -17,7 +17,9 @@ package chartutil
 
 import (
 	"errors"
+	"fmt"
 	"log"
+	"regexp"
 	"strings"
 	"time"
 
@@ -219,6 +221,9 @@ func ProcessRequirementsTags(reqs *Requirements, cvals Values) {
 
 }
 
+// Validate alias names against this regexp
+var aliasRegexp = regexp.MustCompile("^[a-zA-Z0-9-_]+$")
+
 func getAliasDependency(charts []*chart.Chart, aliasChart *Dependency) *chart.Chart {
 	var chartFound chart.Chart
 	for _, existingChart := range charts {
@@ -237,6 +242,11 @@ func getAliasDependency(charts []*chart.Chart, aliasChart *Dependency) *chart.Ch
 		chartFound = *existingChart
 		newMetadata := *existingChart.Metadata
 		if aliasChart.Alias != "" {
+			// Make sure Alias is well-formed
+			if !aliasRegexp.MatchString(aliasChart.Alias) {
+				fmt.Printf("Invalid alias in dependency %q. Skipping.", aliasChart.Name)
+				continue
+			}
 			newMetadata.Name = aliasChart.Alias
 		}
 		chartFound.Metadata = &newMetadata
@@ -286,6 +296,9 @@ func doProcessRequirementsEnabled(c *chart.Chart, v *chart.Config, path string)
 			chartDependencies = append(chartDependencies, chartDependency)
 		}
 		if req.Alias != "" {
+			if !aliasRegexp.MatchString(req.Alias) {
+				return fmt.Errorf("illegal alias name in %q", req.Name)
+			}
 			req.Name = req.Alias
 		}
 	}
diff --git a/pkg/chartutil/requirements_test.go b/pkg/chartutil/requirements_test.go
index 640987fdd11..723f9bab30e 100644
--- a/pkg/chartutil/requirements_test.go
+++ b/pkg/chartutil/requirements_test.go
@@ -370,11 +370,19 @@ func TestGetAliasDependency(t *testing.T) {
 	}
 
 	// Failure case
+	resetName := req.Dependencies[0].Name
 	req.Dependencies[0].Name = "something-else"
 	if aliasChart := getAliasDependency(c.Dependencies, req.Dependencies[0]); aliasChart != nil {
 		t.Fatalf("expected no chart but got %s", aliasChart.Metadata.Name)
 	}
 
+	// Add a bad alias name
+	req.Dependencies[0].Name = resetName
+	req.Dependencies[0].Alias = "$foobar"
+	if aliasChart := getAliasDependency(c.Dependencies, req.Dependencies[0]); aliasChart != nil {
+		t.Fatalf("expected no chart but got %s", aliasChart.Metadata.Name)
+	}
+
 	req.Dependencies[0].Version = "something else which is not in the compatible range"
 	if version.IsCompatibleRange(req.Dependencies[0].Version, aliasChart.Metadata.Version) {
 		t.Fatalf("Dependency chart version which is not in the compatible range should cause a failure other than a success ")
@@ -516,3 +524,16 @@ func TestDependentChartsWithSomeSubchartsSpecifiedInRequirements(t *testing.T) {
 	}
 
 }
+
+func TestAliasRegexp(t *testing.T) {
+	for name, shouldPass := range map[string]bool{
+		"abcdefghijklmnopqrstuvwxyzABCDEFG0987654321_-": true,
+		"$foo":     false,
+		"bar$":     false,
+		"foo\nbar": false,
+	} {
+		if aliasRegexp.MatchString(name) != shouldPass {
+			t.Errorf("name %q failed to pass its test", name)
+		}
+	}
+}
diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go
index 07fcc700a27..c4873918acc 100644
--- a/pkg/plugin/plugin.go
+++ b/pkg/plugin/plugin.go
@@ -16,6 +16,7 @@ limitations under the License.
 package plugin // import "k8s.io/helm/pkg/plugin"
 
 import (
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -141,13 +142,22 @@ func LoadAll(basedir string) ([]*Plugin, error) {
 		return plugins, nil
 	}
 
+	loaded := map[string]bool{}
 	for _, yaml := range matches {
 		dir := filepath.Dir(yaml)
 		p, err := LoadDir(dir)
+		pname := p.Metadata.Name
 		if err != nil {
 			return plugins, err
 		}
+
+		if _, ok := loaded[pname]; ok {
+			fmt.Fprintf(os.Stderr, "A plugin named %q already exists. Skipping.", pname)
+			continue
+		}
+
 		plugins = append(plugins, p)
+		loaded[pname] = true
 	}
 	return plugins, nil
 }
diff --git a/pkg/plugin/plugin_test.go b/pkg/plugin/plugin_test.go
index 338d949f889..2d52e295499 100644
--- a/pkg/plugin/plugin_test.go
+++ b/pkg/plugin/plugin_test.go
@@ -137,6 +137,7 @@ func TestLoadAll(t *testing.T) {
 		t.Fatalf("Could not load %q: %s", basedir, err)
 	}
 
+	// This would fail if the duplicate plugin were loaded.
 	if l := len(plugs); l != 3 {
 		t.Fatalf("expected 3 plugins, found %d", l)
 	}
diff --git a/pkg/plugin/testdata/plugdir/hello2/hello.sh b/pkg/plugin/testdata/plugdir/hello2/hello.sh
new file mode 100755
index 00000000000..db7c0f54daf
--- /dev/null
+++ b/pkg/plugin/testdata/plugdir/hello2/hello.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+echo "Hello from a Helm plugin"
+
+echo "PARAMS"
+echo $*
+
+echo "ENVIRONMENT"
+echo $TILLER_HOST
+echo $HELM_HOME
+
+$HELM_BIN --host $TILLER_HOST ls --all
+
diff --git a/pkg/plugin/testdata/plugdir/hello2/plugin.yaml b/pkg/plugin/testdata/plugdir/hello2/plugin.yaml
new file mode 100644
index 00000000000..cdb27b29122
--- /dev/null
+++ b/pkg/plugin/testdata/plugdir/hello2/plugin.yaml
@@ -0,0 +1,11 @@
+name: "hello"
+version: "0.1.0"
+usage: "usage"
+description: |-
+  description
+command: "$HELM_PLUGIN_SELF/hello.sh"
+useTunnel: true
+ignoreFlags: true
+install: "echo installing..."
+hooks:
+  install: "echo installing..."
diff --git a/pkg/repo/index.go b/pkg/repo/index.go
index 12f3308dee9..1fcb7d9cb04 100644
--- a/pkg/repo/index.go
+++ b/pkg/repo/index.go
@@ -30,6 +30,7 @@ import (
 
 	"github.com/Masterminds/semver"
 	"github.com/ghodss/yaml"
+	yaml2 "gopkg.in/yaml.v2"
 
 	"k8s.io/helm/pkg/chartutil"
 	"k8s.io/helm/pkg/proto/hapi/chart"
@@ -83,6 +84,14 @@ type IndexFile struct {
 	PublicKeys []string                 `json:"publicKeys,omitempty"`
 }
 
+// IndexValidation is used to validate the integrity of an index file
+type IndexValidation struct {
+	APIVersion string                 `yaml:"apiVersion"`
+	Generated  time.Time              `yaml:"generated"`
+	Entries    map[string]interface{} `yaml:"entries"`
+	PublicKeys []string               `yaml:"publicKeys,omitempty"`
+}
+
 // NewIndexFile initializes an index.
 func NewIndexFile() *IndexFile {
 	return &IndexFile{
@@ -283,9 +292,14 @@ func IndexDirectory(dir, baseURL string) (*IndexFile, error) {
 // This will fail if API Version is not set (ErrNoAPIVersion) or if the unmarshal fails.
 func loadIndex(data []byte) (*IndexFile, error) {
 	i := &IndexFile{}
+	if err := validateIndex(data); err != nil {
+		return i, err
+	}
+
 	if err := yaml.Unmarshal(data, i); err != nil {
 		return i, err
 	}
+
 	i.SortEntries()
 	if i.APIVersion == "" {
 		// When we leave Beta, we should remove legacy support and just
@@ -296,6 +310,16 @@ func loadIndex(data []byte) (*IndexFile, error) {
 	return i, nil
 }
 
+// validateIndex validates that the index is well-formed.
+func validateIndex(data []byte) error {
+	// This is done ONLY for validation. We need to use ghodss/yaml for the actual parsing.
+	validation := &IndexValidation{}
+	if err := yaml2.UnmarshalStrict(data, validation); err != nil {
+		return err
+	}
+	return nil
+}
+
 // unversionedEntry represents a deprecated pre-Alpha.5 format.
 //
 // This will be removed prior to v2.0.0
diff --git a/pkg/repo/index_test.go b/pkg/repo/index_test.go
index de53efacf23..425de70ef59 100644
--- a/pkg/repo/index_test.go
+++ b/pkg/repo/index_test.go
@@ -422,3 +422,19 @@ func TestIndexAdd(t *testing.T) {
 		t.Errorf("Expected http://example.com/charts/deis-0.1.0.tgz, got %s", i.Entries["deis"][0].URLs[0])
 	}
 }
+
+const mockDuplicateIndex = `
+entries:
+  foo: {}
+  bar: {}
+  baz: {}
+  bar: {}
+`
+
+func TestValidateIndex(t *testing.T) {
+	expect := `key "bar" already set in map`
+	err := validateIndex([]byte(mockDuplicateIndex))
+	if strings.Contains(expect, err.Error()) {
+		t.Errorf("Unexpected error: %s", err)
+	}
+}", "url": "https://github.com/helm/helm/commit/6aab63765f99050b115f0aec3d6350c85e8da946.patch" }, { "commit_message": "[PATCH] switched to stricter YAML parsing on plugin metadata files Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com> (cherry picked from commit 6eeec4a00241b7da1acaddcbf3278355de1f216e) pkg/plugin/installer/local_installer_test.go | 2 +- pkg/plugin/installer/vcs_installer_test.go | 2 +- pkg/plugin/plugin.go | 8 +++++++- pkg/plugin/plugin_test.go | 15 +++++++++++---- .../plugdir/bad/duplicate-entries/plugin.yaml | 11 +++++++++++ .../plugdir/{ => good}/downloader/plugin.yaml | 0 .../testdata/plugdir/{ => good}/echo/plugin.yaml | 0 .../testdata/plugdir/{ => good}/hello/hello.sh | 0 .../testdata/plugdir/{ => good}/hello/plugin.yaml | 1 - 9 files changed, 31 insertions(+), 8 deletions(-) create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (85%)", "patch_text_b64": "From ac7c07c37d87e09797f714fb57aa5e9cb99d9450 Mon Sep 17 00:00:00 2001
From: Matthew Fisher <matt.fisher@microsoft.com>
Date: Thu, 17 Sep 2020 08:33:11 -0700
Subject: [PATCH] switched to stricter YAML parsing on plugin metadata files

Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com>
(cherry picked from commit 6eeec4a00241b7da1acaddcbf3278355de1f216e)
---
 pkg/plugin/installer/local_installer_test.go      |  2 +-
 pkg/plugin/installer/vcs_installer_test.go        |  2 +-
 pkg/plugin/plugin.go                              |  8 +++++++-
 pkg/plugin/plugin_test.go                         | 15 +++++++++++----
 .../plugdir/bad/duplicate-entries/plugin.yaml     | 11 +++++++++++
 .../plugdir/{ => good}/downloader/plugin.yaml     |  0
 .../testdata/plugdir/{ => good}/echo/plugin.yaml  |  0
 .../testdata/plugdir/{ => good}/hello/hello.sh    |  0
 .../testdata/plugdir/{ => good}/hello/plugin.yaml |  1 -
 9 files changed, 31 insertions(+), 8 deletions(-)
 create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
 rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (85%)

diff --git a/pkg/plugin/installer/local_installer_test.go b/pkg/plugin/installer/local_installer_test.go
index 3d960733118..96958ab09ed 100644
--- a/pkg/plugin/installer/local_installer_test.go
+++ b/pkg/plugin/installer/local_installer_test.go
@@ -37,7 +37,7 @@ func TestLocalInstaller(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	source := "../testdata/plugdir/echo"
+	source := "../testdata/plugdir/good/echo"
 	i, err := NewForSource(source, "")
 	if err != nil {
 		t.Fatalf("unexpected error: %s", err)
diff --git a/pkg/plugin/installer/vcs_installer_test.go b/pkg/plugin/installer/vcs_installer_test.go
index b8dc6b1e282..6785264b3dc 100644
--- a/pkg/plugin/installer/vcs_installer_test.go
+++ b/pkg/plugin/installer/vcs_installer_test.go
@@ -56,7 +56,7 @@ func TestVCSInstaller(t *testing.T) {
 	}
 
 	source := "https://github.com/adamreese/helm-env"
-	testRepoPath, _ := filepath.Abs("../testdata/plugdir/echo")
+	testRepoPath, _ := filepath.Abs("../testdata/plugdir/good/echo")
 	repo := &testRepo{
 		local: testRepoPath,
 		tags:  []string{"0.1.0", "0.1.1"},
diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go
index 9bac2244ca3..93b5527a1b4 100644
--- a/pkg/plugin/plugin.go
+++ b/pkg/plugin/plugin.go
@@ -96,6 +96,12 @@ type Metadata struct {
 	// Downloaders field is used if the plugin supply downloader mechanism
 	// for special protocols.
 	Downloaders []Downloaders `json:"downloaders"`
+
+	// UseTunnelDeprecated indicates that this command needs a tunnel.
+	// Setting this will cause a number of side effects, such as the
+	// automatic setting of HELM_HOST.
+	// DEPRECATED and unused, but retained for backwards compatibility with Helm 2 plugins. Remove in Helm 4
+	UseTunnelDeprecated bool `json:"useTunnel,omitempty"`
 }
 
 // Plugin represents a plugin.
@@ -200,7 +206,7 @@ func LoadDir(dirname string) (*Plugin, error) {
 	}
 
 	plug := &Plugin{Dir: dirname}
-	if err := yaml.Unmarshal(data, &plug.Metadata); err != nil {
+	if err := yaml.UnmarshalStrict(data, &plug.Metadata); err != nil {
 		return nil, errors.Wrapf(err, "failed to load plugin at %q", pluginfile)
 	}
 	return plug, validatePluginData(plug, pluginfile)
diff --git a/pkg/plugin/plugin_test.go b/pkg/plugin/plugin_test.go
index 88add037d00..2c4478953a8 100644
--- a/pkg/plugin/plugin_test.go
+++ b/pkg/plugin/plugin_test.go
@@ -178,7 +178,7 @@ func TestNoMatchPrepareCommand(t *testing.T) {
 }
 
 func TestLoadDir(t *testing.T) {
-	dirname := "testdata/plugdir/hello"
+	dirname := "testdata/plugdir/good/hello"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -205,8 +205,15 @@ func TestLoadDir(t *testing.T) {
 	}
 }
 
+func TestLoadDirDuplicateEntries(t *testing.T) {
+	dirname := "testdata/plugdir/bad/duplicate-entries"
+	if _, err := LoadDir(dirname); err == nil {
+		t.Errorf("successfully loaded plugin with duplicate entries when it should've failed")
+	}
+}
+
 func TestDownloader(t *testing.T) {
-	dirname := "testdata/plugdir/downloader"
+	dirname := "testdata/plugdir/good/downloader"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -244,7 +251,7 @@ func TestLoadAll(t *testing.T) {
 		t.Fatalf("expected empty dir to have 0 plugins")
 	}
 
-	basedir := "testdata/plugdir"
+	basedir := "testdata/plugdir/good"
 	plugs, err := LoadAll(basedir)
 	if err != nil {
 		t.Fatalf("Could not load %q: %s", basedir, err)
@@ -288,7 +295,7 @@ func TestFindPlugins(t *testing.T) {
 		},
 		{
 			name:     "normal",
-			plugdirs: "./testdata/plugdir",
+			plugdirs: "./testdata/plugdir/good",
 			expected: 3,
 		},
 	}
diff --git a/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
new file mode 100644
index 00000000000..66498be960a
--- /dev/null
+++ b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
@@ -0,0 +1,11 @@
+name: "duplicate-entries"
+version: "0.1.0"
+usage: "usage"
+description: |-
+  description
+command: "echo hello"
+ignoreFlags: true
+hooks:
+  install: "echo installing..."
+hooks:
+  install: "echo installing something different"
diff --git a/pkg/plugin/testdata/plugdir/downloader/plugin.yaml b/pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/downloader/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/echo/plugin.yaml b/pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/echo/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/hello/hello.sh b/pkg/plugin/testdata/plugdir/good/hello/hello.sh
similarity index 100%
rename from pkg/plugin/testdata/plugdir/hello/hello.sh
rename to pkg/plugin/testdata/plugdir/good/hello/hello.sh
diff --git a/pkg/plugin/testdata/plugdir/hello/plugin.yaml b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
similarity index 85%
rename from pkg/plugin/testdata/plugdir/hello/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
index 6a78756d309..2b972da59a7 100644
--- a/pkg/plugin/testdata/plugdir/hello/plugin.yaml
+++ b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
@@ -5,6 +5,5 @@ description: |-
   description
 command: "$HELM_PLUGIN_SELF/hello.sh"
 ignoreFlags: true
-install: "echo installing..."
 hooks:
   install: "echo installing..."", "url": "https://github.com/helm/helm/commit/ac7c07c37d87e09797f714fb57aa5e9cb99d9450.patch" }, { "commit_message": "[PATCH] validate plugin metadata before loading Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com> pkg/plugin/installer/local_installer_test.go | 2 +- pkg/plugin/installer/vcs_installer_test.go | 2 +- pkg/plugin/plugin.go | 13 +++++++++++-- pkg/plugin/plugin_test.go | 13 ++++++++++--- .../plugdir/bad/duplicate-entries/plugin.yaml | 12 ++++++++++++ .../plugdir/{ => good}/downloader/plugin.yaml | 0 .../testdata/plugdir/{ => good}/echo/plugin.yaml | 0 .../testdata/plugdir/{ => good}/hello/hello.sh | 0 .../testdata/plugdir/{ => good}/hello/plugin.yaml | 1 - 9 files changed, 35 insertions(+), 8 deletions(-) create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (86%)", "patch_text_b64": "From b0296c0522e837d65f944beefa3fb64fd08ac304 Mon Sep 17 00:00:00 2001
From: Matthew Fisher <matt.fisher@microsoft.com>
Date: Thu, 17 Sep 2020 08:50:21 -0700
Subject: [PATCH] validate plugin metadata before loading

Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com>
---
 pkg/plugin/installer/local_installer_test.go        |  2 +-
 pkg/plugin/installer/vcs_installer_test.go          |  2 +-
 pkg/plugin/plugin.go                                | 13 +++++++++++--
 pkg/plugin/plugin_test.go                           | 13 ++++++++++---
 .../plugdir/bad/duplicate-entries/plugin.yaml       | 12 ++++++++++++
 .../plugdir/{ => good}/downloader/plugin.yaml       |  0
 .../testdata/plugdir/{ => good}/echo/plugin.yaml    |  0
 .../testdata/plugdir/{ => good}/hello/hello.sh      |  0
 .../testdata/plugdir/{ => good}/hello/plugin.yaml   |  1 -
 9 files changed, 35 insertions(+), 8 deletions(-)
 create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
 rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (86%)

diff --git a/pkg/plugin/installer/local_installer_test.go b/pkg/plugin/installer/local_installer_test.go
index fb5fa26751b..321d205111f 100644
--- a/pkg/plugin/installer/local_installer_test.go
+++ b/pkg/plugin/installer/local_installer_test.go
@@ -48,7 +48,7 @@ func TestLocalInstaller(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	source := "../testdata/plugdir/echo"
+	source := "../testdata/plugdir/good/echo"
 	i, err := NewForSource(source, "", home)
 	if err != nil {
 		t.Errorf("unexpected error: %s", err)
diff --git a/pkg/plugin/installer/vcs_installer_test.go b/pkg/plugin/installer/vcs_installer_test.go
index 548a7a49ad5..871e8dd0025 100644
--- a/pkg/plugin/installer/vcs_installer_test.go
+++ b/pkg/plugin/installer/vcs_installer_test.go
@@ -61,7 +61,7 @@ func TestVCSInstaller(t *testing.T) {
 	}
 
 	source := "https://github.com/adamreese/helm-env"
-	testRepoPath, _ := filepath.Abs("../testdata/plugdir/echo")
+	testRepoPath, _ := filepath.Abs("../testdata/plugdir/good/echo")
 	repo := &testRepo{
 		local: testRepoPath,
 		tags:  []string{"0.1.0", "0.1.1"},
diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go
index 07fcc700a27..223e9d48b34 100644
--- a/pkg/plugin/plugin.go
+++ b/pkg/plugin/plugin.go
@@ -21,9 +21,10 @@ import (
 	"path/filepath"
 	"strings"
 
-	helm_env "k8s.io/helm/pkg/helm/environment"
-
 	"github.com/ghodss/yaml"
+	yaml2 "gopkg.in/yaml.v2"
+
+	helm_env "k8s.io/helm/pkg/helm/environment"
 )
 
 const pluginFileName = "plugin.yaml"
@@ -119,12 +120,20 @@ func LoadDir(dirname string) (*Plugin, error) {
 	}
 
 	plug := &Plugin{Dir: dirname}
+	if err := validateMeta(data); err != nil {
+		return nil, err
+	}
 	if err := yaml.Unmarshal(data, &plug.Metadata); err != nil {
 		return nil, err
 	}
 	return plug, nil
 }
 
+func validateMeta(data []byte) error {
+	// This is done ONLY for validation. We need to use ghodss/yaml for the actual parsing.
+	return yaml2.UnmarshalStrict(data, &Metadata{})
+}
+
 // LoadAll loads all plugins found beneath the base directory.
 //
 // This scans only one directory level.
diff --git a/pkg/plugin/plugin_test.go b/pkg/plugin/plugin_test.go
index 338d949f889..cc73fe0d0f6 100644
--- a/pkg/plugin/plugin_test.go
+++ b/pkg/plugin/plugin_test.go
@@ -64,7 +64,7 @@ func TestPrepareCommand(t *testing.T) {
 }
 
 func TestLoadDir(t *testing.T) {
-	dirname := "testdata/plugdir/hello"
+	dirname := "testdata/plugdir/good/hello"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -92,8 +92,15 @@ func TestLoadDir(t *testing.T) {
 	}
 }
 
+func TestLoadDirDuplicateEntries(t *testing.T) {
+	dirname := "testdata/plugdir/bad/duplicate-entries"
+	if _, err := LoadDir(dirname); err == nil {
+		t.Errorf("successfully loaded plugin with duplicate entries when it should've failed")
+	}
+}
+
 func TestDownloader(t *testing.T) {
-	dirname := "testdata/plugdir/downloader"
+	dirname := "testdata/plugdir/good/downloader"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -131,7 +138,7 @@ func TestLoadAll(t *testing.T) {
 		t.Fatalf("expected empty dir to have 0 plugins")
 	}
 
-	basedir := "testdata/plugdir"
+	basedir := "testdata/plugdir/good"
 	plugs, err := LoadAll(basedir)
 	if err != nil {
 		t.Fatalf("Could not load %q: %s", basedir, err)
diff --git a/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
new file mode 100644
index 00000000000..b5fb49ea622
--- /dev/null
+++ b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
@@ -0,0 +1,12 @@
+name: "duplicate-entries"
+version: "0.1.0"
+usage: "usage"
+description: |-
+  description
+command: "echo hello"
+useTunnel: true
+ignoreFlags: true
+hooks:
+  install: "echo installing..."
+hooks:
+  install: "echo installing something different"
diff --git a/pkg/plugin/testdata/plugdir/downloader/plugin.yaml b/pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/downloader/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/echo/plugin.yaml b/pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/echo/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/hello/hello.sh b/pkg/plugin/testdata/plugdir/good/hello/hello.sh
similarity index 100%
rename from pkg/plugin/testdata/plugdir/hello/hello.sh
rename to pkg/plugin/testdata/plugdir/good/hello/hello.sh
diff --git a/pkg/plugin/testdata/plugdir/hello/plugin.yaml b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
similarity index 86%
rename from pkg/plugin/testdata/plugdir/hello/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
index cdb27b29122..dbed853781f 100644
--- a/pkg/plugin/testdata/plugdir/hello/plugin.yaml
+++ b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
@@ -6,6 +6,5 @@ description: |-
 command: "$HELM_PLUGIN_SELF/hello.sh"
 useTunnel: true
 ignoreFlags: true
-install: "echo installing..."
 hooks:
   install: "echo installing..."", "url": "https://github.com/helm/helm/commit/b0296c0522e837d65f944beefa3fb64fd08ac304.patch" }, { "commit_message": "[PATCH] validate plugin metadata before loading Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com> (cherry picked from commit b0296c0522e837d65f944beefa3fb64fd08ac304) pkg/plugin/installer/local_installer_test.go | 2 +- pkg/plugin/installer/vcs_installer_test.go | 2 +- pkg/plugin/plugin.go | 13 +++++++++++-- pkg/plugin/plugin_test.go | 13 ++++++++++--- .../plugdir/bad/duplicate-entries/plugin.yaml | 12 ++++++++++++ .../plugdir/{ => good}/downloader/plugin.yaml | 0 .../testdata/plugdir/{ => good}/echo/plugin.yaml | 0 .../testdata/plugdir/{ => good}/hello/hello.sh | 0 .../testdata/plugdir/{ => good}/hello/plugin.yaml | 1 - 9 files changed, 35 insertions(+), 8 deletions(-) create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (86%)", "patch_text_b64": "From c8d6b01d72c9604e43ee70d0d78fadd54c2d8499 Mon Sep 17 00:00:00 2001
From: Matthew Fisher <matt.fisher@microsoft.com>
Date: Thu, 17 Sep 2020 08:50:21 -0700
Subject: [PATCH] validate plugin metadata before loading

Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com>
(cherry picked from commit b0296c0522e837d65f944beefa3fb64fd08ac304)
---
 pkg/plugin/installer/local_installer_test.go        |  2 +-
 pkg/plugin/installer/vcs_installer_test.go          |  2 +-
 pkg/plugin/plugin.go                                | 13 +++++++++++--
 pkg/plugin/plugin_test.go                           | 13 ++++++++++---
 .../plugdir/bad/duplicate-entries/plugin.yaml       | 12 ++++++++++++
 .../plugdir/{ => good}/downloader/plugin.yaml       |  0
 .../testdata/plugdir/{ => good}/echo/plugin.yaml    |  0
 .../testdata/plugdir/{ => good}/hello/hello.sh      |  0
 .../testdata/plugdir/{ => good}/hello/plugin.yaml   |  1 -
 9 files changed, 35 insertions(+), 8 deletions(-)
 create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
 rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (86%)

diff --git a/pkg/plugin/installer/local_installer_test.go b/pkg/plugin/installer/local_installer_test.go
index fb5fa26751b..321d205111f 100644
--- a/pkg/plugin/installer/local_installer_test.go
+++ b/pkg/plugin/installer/local_installer_test.go
@@ -48,7 +48,7 @@ func TestLocalInstaller(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	source := "../testdata/plugdir/echo"
+	source := "../testdata/plugdir/good/echo"
 	i, err := NewForSource(source, "", home)
 	if err != nil {
 		t.Errorf("unexpected error: %s", err)
diff --git a/pkg/plugin/installer/vcs_installer_test.go b/pkg/plugin/installer/vcs_installer_test.go
index 548a7a49ad5..871e8dd0025 100644
--- a/pkg/plugin/installer/vcs_installer_test.go
+++ b/pkg/plugin/installer/vcs_installer_test.go
@@ -61,7 +61,7 @@ func TestVCSInstaller(t *testing.T) {
 	}
 
 	source := "https://github.com/adamreese/helm-env"
-	testRepoPath, _ := filepath.Abs("../testdata/plugdir/echo")
+	testRepoPath, _ := filepath.Abs("../testdata/plugdir/good/echo")
 	repo := &testRepo{
 		local: testRepoPath,
 		tags:  []string{"0.1.0", "0.1.1"},
diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go
index c4873918acc..1cba1803b94 100644
--- a/pkg/plugin/plugin.go
+++ b/pkg/plugin/plugin.go
@@ -22,9 +22,10 @@ import (
 	"path/filepath"
 	"strings"
 
-	helm_env "k8s.io/helm/pkg/helm/environment"
-
 	"github.com/ghodss/yaml"
+	yaml2 "gopkg.in/yaml.v2"
+
+	helm_env "k8s.io/helm/pkg/helm/environment"
 )
 
 const pluginFileName = "plugin.yaml"
@@ -120,12 +121,20 @@ func LoadDir(dirname string) (*Plugin, error) {
 	}
 
 	plug := &Plugin{Dir: dirname}
+	if err := validateMeta(data); err != nil {
+		return nil, err
+	}
 	if err := yaml.Unmarshal(data, &plug.Metadata); err != nil {
 		return nil, err
 	}
 	return plug, nil
 }
 
+func validateMeta(data []byte) error {
+	// This is done ONLY for validation. We need to use ghodss/yaml for the actual parsing.
+	return yaml2.UnmarshalStrict(data, &Metadata{})
+}
+
 // LoadAll loads all plugins found beneath the base directory.
 //
 // This scans only one directory level.
diff --git a/pkg/plugin/plugin_test.go b/pkg/plugin/plugin_test.go
index 2d52e295499..68ff3b6d418 100644
--- a/pkg/plugin/plugin_test.go
+++ b/pkg/plugin/plugin_test.go
@@ -64,7 +64,7 @@ func TestPrepareCommand(t *testing.T) {
 }
 
 func TestLoadDir(t *testing.T) {
-	dirname := "testdata/plugdir/hello"
+	dirname := "testdata/plugdir/good/hello"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -92,8 +92,15 @@ func TestLoadDir(t *testing.T) {
 	}
 }
 
+func TestLoadDirDuplicateEntries(t *testing.T) {
+	dirname := "testdata/plugdir/bad/duplicate-entries"
+	if _, err := LoadDir(dirname); err == nil {
+		t.Errorf("successfully loaded plugin with duplicate entries when it should've failed")
+	}
+}
+
 func TestDownloader(t *testing.T) {
-	dirname := "testdata/plugdir/downloader"
+	dirname := "testdata/plugdir/good/downloader"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -131,7 +138,7 @@ func TestLoadAll(t *testing.T) {
 		t.Fatalf("expected empty dir to have 0 plugins")
 	}
 
-	basedir := "testdata/plugdir"
+	basedir := "testdata/plugdir/good"
 	plugs, err := LoadAll(basedir)
 	if err != nil {
 		t.Fatalf("Could not load %q: %s", basedir, err)
diff --git a/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
new file mode 100644
index 00000000000..b5fb49ea622
--- /dev/null
+++ b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
@@ -0,0 +1,12 @@
+name: "duplicate-entries"
+version: "0.1.0"
+usage: "usage"
+description: |-
+  description
+command: "echo hello"
+useTunnel: true
+ignoreFlags: true
+hooks:
+  install: "echo installing..."
+hooks:
+  install: "echo installing something different"
diff --git a/pkg/plugin/testdata/plugdir/downloader/plugin.yaml b/pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/downloader/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/echo/plugin.yaml b/pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/echo/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/hello/hello.sh b/pkg/plugin/testdata/plugdir/good/hello/hello.sh
similarity index 100%
rename from pkg/plugin/testdata/plugdir/hello/hello.sh
rename to pkg/plugin/testdata/plugdir/good/hello/hello.sh
diff --git a/pkg/plugin/testdata/plugdir/hello/plugin.yaml b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
similarity index 86%
rename from pkg/plugin/testdata/plugdir/hello/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
index cdb27b29122..dbed853781f 100644
--- a/pkg/plugin/testdata/plugdir/hello/plugin.yaml
+++ b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
@@ -6,6 +6,5 @@ description: |-
 command: "$HELM_PLUGIN_SELF/hello.sh"
 useTunnel: true
 ignoreFlags: true
-install: "echo installing..."
 hooks:
   install: "echo installing..."", "url": "https://github.com/helm/helm/commit/c8d6b01d72c9604e43ee70d0d78fadd54c2d8499.patch" }, { "commit_message": "[PATCH] switched to stricter YAML parsing on plugin metadata files Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com> pkg/plugin/installer/local_installer_test.go | 2 +- pkg/plugin/installer/vcs_installer_test.go | 2 +- pkg/plugin/plugin.go | 8 +++++++- pkg/plugin/plugin_test.go | 15 +++++++++++---- .../plugdir/bad/duplicate-entries/plugin.yaml | 11 +++++++++++ .../plugdir/{ => good}/downloader/plugin.yaml | 0 .../testdata/plugdir/{ => good}/echo/plugin.yaml | 0 .../testdata/plugdir/{ => good}/hello/hello.sh | 0 .../testdata/plugdir/{ => good}/hello/plugin.yaml | 1 - 9 files changed, 31 insertions(+), 8 deletions(-) create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (85%)", "patch_text_b64": "From 6eeec4a00241b7da1acaddcbf3278355de1f216e Mon Sep 17 00:00:00 2001
From: Matthew Fisher <matt.fisher@microsoft.com>
Date: Thu, 17 Sep 2020 08:33:11 -0700
Subject: [PATCH] switched to stricter YAML parsing on plugin metadata files

Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com>
---
 pkg/plugin/installer/local_installer_test.go      |  2 +-
 pkg/plugin/installer/vcs_installer_test.go        |  2 +-
 pkg/plugin/plugin.go                              |  8 +++++++-
 pkg/plugin/plugin_test.go                         | 15 +++++++++++----
 .../plugdir/bad/duplicate-entries/plugin.yaml     | 11 +++++++++++
 .../plugdir/{ => good}/downloader/plugin.yaml     |  0
 .../testdata/plugdir/{ => good}/echo/plugin.yaml  |  0
 .../testdata/plugdir/{ => good}/hello/hello.sh    |  0
 .../testdata/plugdir/{ => good}/hello/plugin.yaml |  1 -
 9 files changed, 31 insertions(+), 8 deletions(-)
 create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
 rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (85%)

diff --git a/pkg/plugin/installer/local_installer_test.go b/pkg/plugin/installer/local_installer_test.go
index 3d960733118..96958ab09ed 100644
--- a/pkg/plugin/installer/local_installer_test.go
+++ b/pkg/plugin/installer/local_installer_test.go
@@ -37,7 +37,7 @@ func TestLocalInstaller(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	source := "../testdata/plugdir/echo"
+	source := "../testdata/plugdir/good/echo"
 	i, err := NewForSource(source, "")
 	if err != nil {
 		t.Fatalf("unexpected error: %s", err)
diff --git a/pkg/plugin/installer/vcs_installer_test.go b/pkg/plugin/installer/vcs_installer_test.go
index b8dc6b1e282..6785264b3dc 100644
--- a/pkg/plugin/installer/vcs_installer_test.go
+++ b/pkg/plugin/installer/vcs_installer_test.go
@@ -56,7 +56,7 @@ func TestVCSInstaller(t *testing.T) {
 	}
 
 	source := "https://github.com/adamreese/helm-env"
-	testRepoPath, _ := filepath.Abs("../testdata/plugdir/echo")
+	testRepoPath, _ := filepath.Abs("../testdata/plugdir/good/echo")
 	repo := &testRepo{
 		local: testRepoPath,
 		tags:  []string{"0.1.0", "0.1.1"},
diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go
index 9bac2244ca3..93b5527a1b4 100644
--- a/pkg/plugin/plugin.go
+++ b/pkg/plugin/plugin.go
@@ -96,6 +96,12 @@ type Metadata struct {
 	// Downloaders field is used if the plugin supply downloader mechanism
 	// for special protocols.
 	Downloaders []Downloaders `json:"downloaders"`
+
+	// UseTunnelDeprecated indicates that this command needs a tunnel.
+	// Setting this will cause a number of side effects, such as the
+	// automatic setting of HELM_HOST.
+	// DEPRECATED and unused, but retained for backwards compatibility with Helm 2 plugins. Remove in Helm 4
+	UseTunnelDeprecated bool `json:"useTunnel,omitempty"`
 }
 
 // Plugin represents a plugin.
@@ -200,7 +206,7 @@ func LoadDir(dirname string) (*Plugin, error) {
 	}
 
 	plug := &Plugin{Dir: dirname}
-	if err := yaml.Unmarshal(data, &plug.Metadata); err != nil {
+	if err := yaml.UnmarshalStrict(data, &plug.Metadata); err != nil {
 		return nil, errors.Wrapf(err, "failed to load plugin at %q", pluginfile)
 	}
 	return plug, validatePluginData(plug, pluginfile)
diff --git a/pkg/plugin/plugin_test.go b/pkg/plugin/plugin_test.go
index 88add037d00..2c4478953a8 100644
--- a/pkg/plugin/plugin_test.go
+++ b/pkg/plugin/plugin_test.go
@@ -178,7 +178,7 @@ func TestNoMatchPrepareCommand(t *testing.T) {
 }
 
 func TestLoadDir(t *testing.T) {
-	dirname := "testdata/plugdir/hello"
+	dirname := "testdata/plugdir/good/hello"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -205,8 +205,15 @@ func TestLoadDir(t *testing.T) {
 	}
 }
 
+func TestLoadDirDuplicateEntries(t *testing.T) {
+	dirname := "testdata/plugdir/bad/duplicate-entries"
+	if _, err := LoadDir(dirname); err == nil {
+		t.Errorf("successfully loaded plugin with duplicate entries when it should've failed")
+	}
+}
+
 func TestDownloader(t *testing.T) {
-	dirname := "testdata/plugdir/downloader"
+	dirname := "testdata/plugdir/good/downloader"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -244,7 +251,7 @@ func TestLoadAll(t *testing.T) {
 		t.Fatalf("expected empty dir to have 0 plugins")
 	}
 
-	basedir := "testdata/plugdir"
+	basedir := "testdata/plugdir/good"
 	plugs, err := LoadAll(basedir)
 	if err != nil {
 		t.Fatalf("Could not load %q: %s", basedir, err)
@@ -288,7 +295,7 @@ func TestFindPlugins(t *testing.T) {
 		},
 		{
 			name:     "normal",
-			plugdirs: "./testdata/plugdir",
+			plugdirs: "./testdata/plugdir/good",
 			expected: 3,
 		},
 	}
diff --git a/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
new file mode 100644
index 00000000000..66498be960a
--- /dev/null
+++ b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
@@ -0,0 +1,11 @@
+name: "duplicate-entries"
+version: "0.1.0"
+usage: "usage"
+description: |-
+  description
+command: "echo hello"
+ignoreFlags: true
+hooks:
+  install: "echo installing..."
+hooks:
+  install: "echo installing something different"
diff --git a/pkg/plugin/testdata/plugdir/downloader/plugin.yaml b/pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/downloader/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/echo/plugin.yaml b/pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/echo/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/hello/hello.sh b/pkg/plugin/testdata/plugdir/good/hello/hello.sh
similarity index 100%
rename from pkg/plugin/testdata/plugdir/hello/hello.sh
rename to pkg/plugin/testdata/plugdir/good/hello/hello.sh
diff --git a/pkg/plugin/testdata/plugdir/hello/plugin.yaml b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
similarity index 85%
rename from pkg/plugin/testdata/plugdir/hello/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
index 6a78756d309..2b972da59a7 100644
--- a/pkg/plugin/testdata/plugdir/hello/plugin.yaml
+++ b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
@@ -5,6 +5,5 @@ description: |-
   description
 command: "$HELM_PLUGIN_SELF/hello.sh"
 ignoreFlags: true
-install: "echo installing..."
 hooks:
   install: "echo installing..."", "url": "https://github.com/helm/helm/commit/d9ef5ce8bad512e325390c0011be1244b8380e4b.patch" }, { "commit_message": "[PATCH] validate plugin metadata before loading Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com> pkg/plugin/installer/local_installer_test.go | 2 +- pkg/plugin/installer/vcs_installer_test.go | 2 +- pkg/plugin/plugin.go | 13 +++++++++++-- pkg/plugin/plugin_test.go | 13 ++++++++++--- .../plugdir/bad/duplicate-entries/plugin.yaml | 12 ++++++++++++ .../plugdir/{ => good}/downloader/plugin.yaml | 0 .../testdata/plugdir/{ => good}/echo/plugin.yaml | 0 .../testdata/plugdir/{ => good}/hello/hello.sh | 0 .../testdata/plugdir/{ => good}/hello/plugin.yaml | 1 - 9 files changed, 35 insertions(+), 8 deletions(-) create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%) rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (86%)", "patch_text_b64": "From b0296c0522e837d65f944beefa3fb64fd08ac304 Mon Sep 17 00:00:00 2001
From: Matthew Fisher <matt.fisher@microsoft.com>
Date: Thu, 17 Sep 2020 08:50:21 -0700
Subject: [PATCH] validate plugin metadata before loading

Signed-off-by: Matthew Fisher <matt.fisher@microsoft.com>
---
 pkg/plugin/installer/local_installer_test.go        |  2 +-
 pkg/plugin/installer/vcs_installer_test.go          |  2 +-
 pkg/plugin/plugin.go                                | 13 +++++++++++--
 pkg/plugin/plugin_test.go                           | 13 ++++++++++---
 .../plugdir/bad/duplicate-entries/plugin.yaml       | 12 ++++++++++++
 .../plugdir/{ => good}/downloader/plugin.yaml       |  0
 .../testdata/plugdir/{ => good}/echo/plugin.yaml    |  0
 .../testdata/plugdir/{ => good}/hello/hello.sh      |  0
 .../testdata/plugdir/{ => good}/hello/plugin.yaml   |  1 -
 9 files changed, 35 insertions(+), 8 deletions(-)
 create mode 100644 pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
 rename pkg/plugin/testdata/plugdir/{ => good}/downloader/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/echo/plugin.yaml (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/hello.sh (100%)
 rename pkg/plugin/testdata/plugdir/{ => good}/hello/plugin.yaml (86%)

diff --git a/pkg/plugin/installer/local_installer_test.go b/pkg/plugin/installer/local_installer_test.go
index fb5fa26751b..321d205111f 100644
--- a/pkg/plugin/installer/local_installer_test.go
+++ b/pkg/plugin/installer/local_installer_test.go
@@ -48,7 +48,7 @@ func TestLocalInstaller(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	source := "../testdata/plugdir/echo"
+	source := "../testdata/plugdir/good/echo"
 	i, err := NewForSource(source, "", home)
 	if err != nil {
 		t.Errorf("unexpected error: %s", err)
diff --git a/pkg/plugin/installer/vcs_installer_test.go b/pkg/plugin/installer/vcs_installer_test.go
index 548a7a49ad5..871e8dd0025 100644
--- a/pkg/plugin/installer/vcs_installer_test.go
+++ b/pkg/plugin/installer/vcs_installer_test.go
@@ -61,7 +61,7 @@ func TestVCSInstaller(t *testing.T) {
 	}
 
 	source := "https://github.com/adamreese/helm-env"
-	testRepoPath, _ := filepath.Abs("../testdata/plugdir/echo")
+	testRepoPath, _ := filepath.Abs("../testdata/plugdir/good/echo")
 	repo := &testRepo{
 		local: testRepoPath,
 		tags:  []string{"0.1.0", "0.1.1"},
diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go
index 07fcc700a27..223e9d48b34 100644
--- a/pkg/plugin/plugin.go
+++ b/pkg/plugin/plugin.go
@@ -21,9 +21,10 @@ import (
 	"path/filepath"
 	"strings"
 
-	helm_env "k8s.io/helm/pkg/helm/environment"
-
 	"github.com/ghodss/yaml"
+	yaml2 "gopkg.in/yaml.v2"
+
+	helm_env "k8s.io/helm/pkg/helm/environment"
 )
 
 const pluginFileName = "plugin.yaml"
@@ -119,12 +120,20 @@ func LoadDir(dirname string) (*Plugin, error) {
 	}
 
 	plug := &Plugin{Dir: dirname}
+	if err := validateMeta(data); err != nil {
+		return nil, err
+	}
 	if err := yaml.Unmarshal(data, &plug.Metadata); err != nil {
 		return nil, err
 	}
 	return plug, nil
 }
 
+func validateMeta(data []byte) error {
+	// This is done ONLY for validation. We need to use ghodss/yaml for the actual parsing.
+	return yaml2.UnmarshalStrict(data, &Metadata{})
+}
+
 // LoadAll loads all plugins found beneath the base directory.
 //
 // This scans only one directory level.
diff --git a/pkg/plugin/plugin_test.go b/pkg/plugin/plugin_test.go
index 338d949f889..cc73fe0d0f6 100644
--- a/pkg/plugin/plugin_test.go
+++ b/pkg/plugin/plugin_test.go
@@ -64,7 +64,7 @@ func TestPrepareCommand(t *testing.T) {
 }
 
 func TestLoadDir(t *testing.T) {
-	dirname := "testdata/plugdir/hello"
+	dirname := "testdata/plugdir/good/hello"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -92,8 +92,15 @@ func TestLoadDir(t *testing.T) {
 	}
 }
 
+func TestLoadDirDuplicateEntries(t *testing.T) {
+	dirname := "testdata/plugdir/bad/duplicate-entries"
+	if _, err := LoadDir(dirname); err == nil {
+		t.Errorf("successfully loaded plugin with duplicate entries when it should've failed")
+	}
+}
+
 func TestDownloader(t *testing.T) {
-	dirname := "testdata/plugdir/downloader"
+	dirname := "testdata/plugdir/good/downloader"
 	plug, err := LoadDir(dirname)
 	if err != nil {
 		t.Fatalf("error loading Hello plugin: %s", err)
@@ -131,7 +138,7 @@ func TestLoadAll(t *testing.T) {
 		t.Fatalf("expected empty dir to have 0 plugins")
 	}
 
-	basedir := "testdata/plugdir"
+	basedir := "testdata/plugdir/good"
 	plugs, err := LoadAll(basedir)
 	if err != nil {
 		t.Fatalf("Could not load %q: %s", basedir, err)
diff --git a/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
new file mode 100644
index 00000000000..b5fb49ea622
--- /dev/null
+++ b/pkg/plugin/testdata/plugdir/bad/duplicate-entries/plugin.yaml
@@ -0,0 +1,12 @@
+name: "duplicate-entries"
+version: "0.1.0"
+usage: "usage"
+description: |-
+  description
+command: "echo hello"
+useTunnel: true
+ignoreFlags: true
+hooks:
+  install: "echo installing..."
+hooks:
+  install: "echo installing something different"
diff --git a/pkg/plugin/testdata/plugdir/downloader/plugin.yaml b/pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/downloader/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/downloader/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/echo/plugin.yaml b/pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
similarity index 100%
rename from pkg/plugin/testdata/plugdir/echo/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/echo/plugin.yaml
diff --git a/pkg/plugin/testdata/plugdir/hello/hello.sh b/pkg/plugin/testdata/plugdir/good/hello/hello.sh
similarity index 100%
rename from pkg/plugin/testdata/plugdir/hello/hello.sh
rename to pkg/plugin/testdata/plugdir/good/hello/hello.sh
diff --git a/pkg/plugin/testdata/plugdir/hello/plugin.yaml b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
similarity index 86%
rename from pkg/plugin/testdata/plugdir/hello/plugin.yaml
rename to pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
index cdb27b29122..dbed853781f 100644
--- a/pkg/plugin/testdata/plugdir/hello/plugin.yaml
+++ b/pkg/plugin/testdata/plugdir/good/hello/plugin.yaml
@@ -6,6 +6,5 @@ description: |-
 command: "$HELM_PLUGIN_SELF/hello.sh"
 useTunnel: true
 ignoreFlags: true
-install: "echo installing..."
 hooks:
   install: "echo installing..."", "url": "https://github.com/helm/helm/commit/f2ede29480b507b7d8bb152dd8b6b86248b00658.patch" } ]
null
GHSA-665w-mwrr-77q3
Arbitrary file read via Playwright's screenshot feature exploiting file wrapper
null
[ { "commit_message": "[PATCH] fix(security): require screenshot protocol to be http/https prevent file:// URI scheme in Playwright screenshots A critical vulnerability was discovered in a web application feature that utilizes Playwright's screenshot capability. Attackers could exploit this vulnerability by using the file:// URI scheme to read arbitrary files on the server's filesystem, potentially exposing sensitive information, such as AWS credentials. This commit addresses the vulnerability by implementing proper input validation and sanitization to prevent the use of the file:// URI scheme in Playwright screenshot requests, mitigating the risk of unauthorized file access. resolves #47 src/lib/schema.ts | 19 +++++++++++++++++-- src/middlewares/extract_query_params.ts | 10 +++++++++- tests/app.spec.ts | 12 ++++++++++++ 3 files changed, 38 insertions(+), 3 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/jasonraimondi/url-to-png/commit/9336020c5e603323f5cf4a2ac3bb9a7735cf61f7.patch" } ]
null
GHSA-gj3m-w8pf-46c5
null
[ { "commit_message": "[PATCH] bn/asm/rsaz-avx2.pl: fix digit correction bug in rsaz_1024_mul_avx2. Credit to OSS-Fuzz for finding this. CVE-2017-3738 Reviewed-by: Rich Salz <rsalz@openssl.org> crypto/bn/asm/rsaz-avx2.pl | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/openssl/openssl/commit/e502cc86df9dafded1694fceb3228ee34d11c11a.patch" } ]
null
GHSA-r4r6-j2j3-7pp5
Contao: Remember-me tokens will not be cleared after a password change
null
[ { "commit_message": "[PATCH] Merge pull request from GHSA-r4r6-j2j3-7pp5 Co-authored-by: Leo Feyer <1192057+leofeyer@users.noreply.github.com> core-bundle/src/Repository/RememberMeRepository.php | 12 ++++++++++++ core-bundle/src/Resources/config/services.yml | 1 + .../contao/modules/ModuleChangePassword.php | 2 ++ .../src/Resources/contao/modules/ModulePassword.php | 2 ++ .../Resources/contao/modules/ModulePersonalData.php | 5 +++++ 5 files changed, 22 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/contao/contao/commit/3032baa456f607169ffae82a8920354adb338fe9.patch" } ]
null
CVE-2014-9279
The print_test_result function in admin/upgrade_unattended.php in MantisBT 1.1.0a3 through 1.2.x before 1.2.18 allows remote attackers to obtain database credentials via a URL in the hostname parameter and reading the parameters in the response sent to the URL.
[ { "commit_message": "[PATCH] DB Credentials leak in upgrade_unattended.php Retrieve credentials from Mantis system configuration instead of accepting them from POST parameters. This issue was reported by Matthias Karlsson (http://mathiaskarlsson.me) as part of Offensive Security's bug bounty program [1]. Paul Richards' original patch was modified to align the code with master branch to (basically replacing DIRECTORY_SEPARATOR by '/') to facilitate porting. Fixes #17877 [1] http://www.offensive-security.com/bug-bounty-program/ Signed-off-by: Damien Regad <dregad@mantisbt.org> admin/upgrade_unattended.php | 21 ++++++++------------- 1 file changed, 8 insertions(+), 13 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/mantisbt/mantisbt/commit/0826cef8.patch" } ]
n/a
GHSA-rmq6-x837-659x
null
[ { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 28 ++++ .../xenon/common/TestExampleServiceHost.java | 2 + .../xenon/common/TestSubscriptions.java | 3 + .../xenon/common/TestUtilityService.java | 151 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 ++++ .../xenon/common/test/VerificationHost.java | 9 ++ .../services/common/TestNodeGroupService.java | 5 +- 8 files changed, 246 insertions(+), 3 deletions(-)", "patch_text_b64": "From 055ae13603f0cc3cd7cf59f20ce314bf8db583e1 Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  28 ++++
 .../xenon/common/TestExampleServiceHost.java  |   2 +
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../xenon/common/TestUtilityService.java      | 151 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 ++++
 .../xenon/common/test/VerificationHost.java   |   9 ++
 .../services/common/TestNodeGroupService.java |   5 +-
 8 files changed, 246 insertions(+), 3 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index 0a13eb4d9..d18576a45 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -57,7 +57,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index dcc6ff769..126bc4aab 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -513,6 +513,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait();
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -555,9 +565,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 07d2a39e9..17868c08e 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -85,7 +85,9 @@ public void createUsers() throws Throwable {
     private String loginUser(URI hostUri) throws Throwable {
         URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
         // wait for factory availability
+        this.host.setSystemAuthorizationContext();
         this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
+        this.host.resetAuthorizationContext();
 
         String basicAuth = constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 52b5ebfb9..1ebfe765e 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -299,11 +299,14 @@ public void testSubscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index 6127279fc..a4d577e86 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,12 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.EnumSet;
 import java.util.List;
@@ -32,10 +36,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
 
@@ -586,4 +596,145 @@ public static void validateTimeSeriesStat(ServiceStat stat, long expectedBinDura
         assertTrue(maxAvg > 0);
         assertTrue(countPerMaxAvgBin >= 1);
     }
+
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index 8ee19e886..faafbff6a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -269,6 +270,22 @@ public Collection<String> createRoles(ServiceHost target, String email, boolean
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -283,6 +300,16 @@ public Collection<String> createRoles(ServiceHost target, String email, boolean
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 8743567fa..a4ade295f 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -79,6 +79,7 @@
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
 import com.vmware.xenon.common.Operation.OperationOption;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1011,8 +1012,16 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.getServiceState(
                 null, ServiceStats.class, UriUtils.buildStatsUri(serviceUri));
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index 65a4cffd4..83aef08ad 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -2482,6 +2482,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -2499,7 +2500,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -2709,7 +2710,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/055ae13603f0cc3cd7cf59f20ce314bf8db583e1.patch" }, { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 32 ++++ .../xenon/common/TestExampleServiceHost.java | 4 - .../vmware/xenon/common/TestServiceHost.java | 14 +- .../xenon/common/TestSubscriptions.java | 3 + .../xenon/common/TestUtilityService.java | 165 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 +++ .../xenon/common/test/VerificationHost.java | 9 + .../services/common/TestNodeGroupService.java | 5 +- 9 files changed, 274 insertions(+), 9 deletions(-)", "patch_text_b64": "From 06b9947cf603ba40fd8b03bfeb2e84528a7ab592 Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  32 ++++
 .../xenon/common/TestExampleServiceHost.java  |   4 -
 .../vmware/xenon/common/TestServiceHost.java  |  14 +-
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../xenon/common/TestUtilityService.java      | 165 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 +++
 .../xenon/common/test/VerificationHost.java   |   9 +
 .../services/common/TestNodeGroupService.java |   5 +-
 9 files changed, 274 insertions(+), 9 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index 47014ccc6..d48bfb31d 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -143,7 +143,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index bfdaa2082..56b045b57 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -462,16 +462,20 @@ public void guestAuthorization() throws Throwable {
                         .setBody(state));
         assertEquals(Operation.STATUS_CODE_UNAUTHORIZED, failureResponse.op.getStatusCode());
 
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         Map<String, ServiceStats.ServiceStat> stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
         double currentInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
+        OperationContext.setAuthorizationContext(null);
 
         // Make a second request and verify that the cache did not get updated, instead Xenon re-used
         // the cached Guest authorization context.
         sender.sendAndWait(Operation.createGet(this.host, ExampleService.FACTORY_LINK));
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
+        OperationContext.setAuthorizationContext(null);
         double newInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
         assertTrue(currentInsertCount == newInsertCount);
@@ -709,6 +713,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait(ctx2);
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -750,9 +764,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
 
         // test user impersonation
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 572d816cb..a3fd5a2c8 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -81,10 +81,6 @@ public void createUsers() throws Throwable {
      * isn't created immediately, so this polls.
      */
     private String loginUser(URI hostUri) throws Throwable {
-        URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
-        // wait for factory availability
-        this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
-
         String basicAuth = BasicAuthenticationUtils.constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
         AuthenticationRequest login = new AuthenticationRequest();
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
index 4b05b57af..2843291e5 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
@@ -417,9 +417,13 @@ private void doRequestRateLimits() throws Throwable {
         ri.limit = limit;
         ri.options = EnumSet.of(RequestRateInfo.Option.PAUSE_PROCESSING);
         this.host.setRequestRateLimit(userPath, ri);
-        this.host.assumeIdentity(userPath);
 
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatBefore = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
+
+        this.host.assumeIdentity(userPath);
+
         if (rateLimitStatBefore == null) {
             rateLimitStatBefore = new ServiceStat();
             rateLimitStatBefore.latestValue = 0.0;
@@ -438,7 +442,10 @@ private void doRequestRateLimits() throws Throwable {
         }
         this.host.testWait(ctx2);
         ctx2.logAfter();
+
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatAfter = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue > rateLimitStatBefore.latestValue);
 
         this.host.setMaintenanceIntervalMicros(
@@ -468,7 +475,9 @@ private void doRequestRateLimits() throws Throwable {
         ctx3.logAfter();
 
         // verify rate limiting did not happen
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatExpectSame = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue == rateLimitStatExpectSame.latestValue);
     }
 
@@ -2415,8 +2424,9 @@ private ServiceStat getODLStopCountStat() throws Throwable {
 
     private ServiceStat getRateLimitOpCountStat() throws Throwable {
         URI managementServiceUri = this.host.getManagementServiceUri();
-        return this.host.getServiceStats(managementServiceUri)
+        ServiceStat stats = this.host.getServiceStats(managementServiceUri)
                 .get(ServiceHostManagementService.STAT_NAME_RATE_LIMITED_OP_COUNT);
+        return stats;
     }
 
     @Test
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 209d33e4b..66ab78170 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -300,11 +300,14 @@ public void subscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index a031bcb90..95299c79e 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,13 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_SYNCHRONIZATION;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.EnumSet;
@@ -34,10 +39,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 import com.vmware.xenon.services.common.ServiceUriPaths;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
@@ -823,4 +834,158 @@ public void statsKeyOrder() {
         assertEquals("stat index 2", "keyCCC", statList.get(2));
     }
 
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factorySynchUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_SYNCHRONIZATION));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceSynchUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_SYNCHRONIZATION));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySynchUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSynchUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySynchUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSynchUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index e847ddb36..162051d6a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -247,6 +248,22 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -261,6 +278,16 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 0cb27957c..911756552 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -83,6 +83,7 @@
 import com.vmware.xenon.common.Operation;
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1052,7 +1053,15 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.sender.sendStatsGetAndWait(serviceUri);
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index 4397eb2d9..464670caa 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -3027,6 +3027,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -3044,7 +3045,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -3255,7 +3256,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/06b9947cf603ba40fd8b03bfeb2e84528a7ab592.patch" }, { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 32 ++++ .../xenon/common/TestExampleServiceHost.java | 4 - .../vmware/xenon/common/TestServiceHost.java | 14 +- .../xenon/common/TestSubscriptions.java | 3 + .../xenon/common/TestUtilityService.java | 150 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 ++++ .../xenon/common/test/VerificationHost.java | 9 ++ .../services/common/TestNodeGroupService.java | 5 +- 9 files changed, 259 insertions(+), 9 deletions(-)", "patch_text_b64": "From 30ae41bccf418d88b52b35a81efb3c1304b798f8 Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  32 ++++
 .../xenon/common/TestExampleServiceHost.java  |   4 -
 .../vmware/xenon/common/TestServiceHost.java  |  14 +-
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../xenon/common/TestUtilityService.java      | 150 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 ++++
 .../xenon/common/test/VerificationHost.java   |   9 ++
 .../services/common/TestNodeGroupService.java |   5 +-
 9 files changed, 259 insertions(+), 9 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index 23c9f05e5..39378486a 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -144,7 +144,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index bfdaa2082..56b045b57 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -462,16 +462,20 @@ public void guestAuthorization() throws Throwable {
                         .setBody(state));
         assertEquals(Operation.STATUS_CODE_UNAUTHORIZED, failureResponse.op.getStatusCode());
 
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         Map<String, ServiceStats.ServiceStat> stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
         double currentInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
+        OperationContext.setAuthorizationContext(null);
 
         // Make a second request and verify that the cache did not get updated, instead Xenon re-used
         // the cached Guest authorization context.
         sender.sendAndWait(Operation.createGet(this.host, ExampleService.FACTORY_LINK));
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
+        OperationContext.setAuthorizationContext(null);
         double newInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
         assertTrue(currentInsertCount == newInsertCount);
@@ -709,6 +713,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait(ctx2);
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -750,9 +764,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
 
         // test user impersonation
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 572d816cb..a3fd5a2c8 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -81,10 +81,6 @@ public void createUsers() throws Throwable {
      * isn't created immediately, so this polls.
      */
     private String loginUser(URI hostUri) throws Throwable {
-        URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
-        // wait for factory availability
-        this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
-
         String basicAuth = BasicAuthenticationUtils.constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
         AuthenticationRequest login = new AuthenticationRequest();
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
index ca1ad1a89..b78a7e850 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
@@ -421,9 +421,13 @@ private void doRequestRateLimits() throws Throwable {
         ri.limit = limit;
         ri.options = EnumSet.of(RequestRateInfo.Option.PAUSE_PROCESSING);
         this.host.setRequestRateLimit(userPath, ri);
-        this.host.assumeIdentity(userPath);
 
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatBefore = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
+
+        this.host.assumeIdentity(userPath);
+
         if (rateLimitStatBefore == null) {
             rateLimitStatBefore = new ServiceStat();
             rateLimitStatBefore.latestValue = 0.0;
@@ -442,7 +446,10 @@ private void doRequestRateLimits() throws Throwable {
         }
         this.host.testWait(ctx2);
         ctx2.logAfter();
+
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatAfter = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue > rateLimitStatBefore.latestValue);
 
         this.host.setMaintenanceIntervalMicros(
@@ -472,7 +479,9 @@ private void doRequestRateLimits() throws Throwable {
         ctx3.logAfter();
 
         // verify rate limiting did not happen
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatExpectSame = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue == rateLimitStatExpectSame.latestValue);
     }
 
@@ -2627,8 +2636,9 @@ private ServiceStat getODLStopCountStat() throws Throwable {
 
     private ServiceStat getRateLimitOpCountStat() throws Throwable {
         URI managementServiceUri = this.host.getManagementServiceUri();
-        return this.host.getServiceStats(managementServiceUri)
+        ServiceStat stats = this.host.getServiceStats(managementServiceUri)
                 .get(ServiceHostManagementService.STAT_NAME_RATE_LIMITED_OP_COUNT);
+        return stats;
     }
 
     @Test
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 209d33e4b..66ab78170 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -300,11 +300,14 @@ public void subscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index a031bcb90..f281dc5db 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,12 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.EnumSet;
@@ -34,10 +38,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 import com.vmware.xenon.services.common.ServiceUriPaths;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
@@ -823,4 +833,144 @@ public void statsKeyOrder() {
         assertEquals("stat index 2", "keyCCC", statList.get(2));
     }
 
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index e847ddb36..162051d6a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -247,6 +248,22 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -261,6 +278,16 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 0cb27957c..911756552 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -83,6 +83,7 @@
 import com.vmware.xenon.common.Operation;
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1052,7 +1053,15 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.sender.sendStatsGetAndWait(serviceUri);
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index 9045b5f11..d042f79cc 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -3023,6 +3023,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -3040,7 +3041,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -3251,7 +3252,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/30ae41bccf418d88b52b35a81efb3c1304b798f8.patch" }, { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 32 ++++ .../xenon/common/TestExampleServiceHost.java | 4 - .../vmware/xenon/common/TestServiceHost.java | 14 +- .../xenon/common/TestSubscriptions.java | 3 + .../xenon/common/TestUtilityService.java | 150 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 ++++ .../xenon/common/test/VerificationHost.java | 9 ++ .../services/common/TestNodeGroupService.java | 5 +- 9 files changed, 259 insertions(+), 9 deletions(-)", "patch_text_b64": "From 5682ef8d40569afd00fb9a5933e7706bb5b66713 Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  32 ++++
 .../xenon/common/TestExampleServiceHost.java  |   4 -
 .../vmware/xenon/common/TestServiceHost.java  |  14 +-
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../xenon/common/TestUtilityService.java      | 150 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 ++++
 .../xenon/common/test/VerificationHost.java   |   9 ++
 .../services/common/TestNodeGroupService.java |   5 +-
 9 files changed, 259 insertions(+), 9 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index 23c9f05e5..39378486a 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -144,7 +144,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index bfdaa2082..56b045b57 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -462,16 +462,20 @@ public void guestAuthorization() throws Throwable {
                         .setBody(state));
         assertEquals(Operation.STATUS_CODE_UNAUTHORIZED, failureResponse.op.getStatusCode());
 
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         Map<String, ServiceStats.ServiceStat> stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
         double currentInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
+        OperationContext.setAuthorizationContext(null);
 
         // Make a second request and verify that the cache did not get updated, instead Xenon re-used
         // the cached Guest authorization context.
         sender.sendAndWait(Operation.createGet(this.host, ExampleService.FACTORY_LINK));
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
+        OperationContext.setAuthorizationContext(null);
         double newInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
         assertTrue(currentInsertCount == newInsertCount);
@@ -709,6 +713,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait(ctx2);
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -750,9 +764,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
 
         // test user impersonation
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 572d816cb..a3fd5a2c8 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -81,10 +81,6 @@ public void createUsers() throws Throwable {
      * isn't created immediately, so this polls.
      */
     private String loginUser(URI hostUri) throws Throwable {
-        URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
-        // wait for factory availability
-        this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
-
         String basicAuth = BasicAuthenticationUtils.constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
         AuthenticationRequest login = new AuthenticationRequest();
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
index ca1ad1a89..b78a7e850 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
@@ -421,9 +421,13 @@ private void doRequestRateLimits() throws Throwable {
         ri.limit = limit;
         ri.options = EnumSet.of(RequestRateInfo.Option.PAUSE_PROCESSING);
         this.host.setRequestRateLimit(userPath, ri);
-        this.host.assumeIdentity(userPath);
 
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatBefore = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
+
+        this.host.assumeIdentity(userPath);
+
         if (rateLimitStatBefore == null) {
             rateLimitStatBefore = new ServiceStat();
             rateLimitStatBefore.latestValue = 0.0;
@@ -442,7 +446,10 @@ private void doRequestRateLimits() throws Throwable {
         }
         this.host.testWait(ctx2);
         ctx2.logAfter();
+
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatAfter = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue > rateLimitStatBefore.latestValue);
 
         this.host.setMaintenanceIntervalMicros(
@@ -472,7 +479,9 @@ private void doRequestRateLimits() throws Throwable {
         ctx3.logAfter();
 
         // verify rate limiting did not happen
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatExpectSame = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue == rateLimitStatExpectSame.latestValue);
     }
 
@@ -2627,8 +2636,9 @@ private ServiceStat getODLStopCountStat() throws Throwable {
 
     private ServiceStat getRateLimitOpCountStat() throws Throwable {
         URI managementServiceUri = this.host.getManagementServiceUri();
-        return this.host.getServiceStats(managementServiceUri)
+        ServiceStat stats = this.host.getServiceStats(managementServiceUri)
                 .get(ServiceHostManagementService.STAT_NAME_RATE_LIMITED_OP_COUNT);
+        return stats;
     }
 
     @Test
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 209d33e4b..66ab78170 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -300,11 +300,14 @@ public void subscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index a031bcb90..f281dc5db 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,12 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.EnumSet;
@@ -34,10 +38,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 import com.vmware.xenon.services.common.ServiceUriPaths;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
@@ -823,4 +833,144 @@ public void statsKeyOrder() {
         assertEquals("stat index 2", "keyCCC", statList.get(2));
     }
 
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index e847ddb36..162051d6a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -247,6 +248,22 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -261,6 +278,16 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 0cb27957c..911756552 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -83,6 +83,7 @@
 import com.vmware.xenon.common.Operation;
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1052,7 +1053,15 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.sender.sendStatsGetAndWait(serviceUri);
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index 9045b5f11..d042f79cc 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -3023,6 +3023,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -3040,7 +3041,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -3251,7 +3252,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/5682ef8d40569afd00fb9a5933e7706bb5b66713.patch" }, { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 28 ++++ .../xenon/common/TestExampleServiceHost.java | 2 + .../xenon/common/TestSubscriptions.java | 3 + .../xenon/common/TestUtilityService.java | 151 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 ++++ .../xenon/common/test/VerificationHost.java | 9 ++ .../services/common/TestNodeGroupService.java | 5 +- 8 files changed, 246 insertions(+), 3 deletions(-)", "patch_text_b64": "From 756d893573414eec8635c2aba2345c4dcf10b21c Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  28 ++++
 .../xenon/common/TestExampleServiceHost.java  |   2 +
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../xenon/common/TestUtilityService.java      | 151 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 ++++
 .../xenon/common/test/VerificationHost.java   |   9 ++
 .../services/common/TestNodeGroupService.java |   5 +-
 8 files changed, 246 insertions(+), 3 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index 0a13eb4d9..d18576a45 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -57,7 +57,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index dcc6ff769..126bc4aab 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -513,6 +513,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait();
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -555,9 +565,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 07d2a39e9..17868c08e 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -85,7 +85,9 @@ public void createUsers() throws Throwable {
     private String loginUser(URI hostUri) throws Throwable {
         URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
         // wait for factory availability
+        this.host.setSystemAuthorizationContext();
         this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
+        this.host.resetAuthorizationContext();
 
         String basicAuth = constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 52b5ebfb9..1ebfe765e 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -299,11 +299,14 @@ public void testSubscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index 6127279fc..a4d577e86 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,12 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.EnumSet;
 import java.util.List;
@@ -32,10 +36,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
 
@@ -586,4 +596,145 @@ public static void validateTimeSeriesStat(ServiceStat stat, long expectedBinDura
         assertTrue(maxAvg > 0);
         assertTrue(countPerMaxAvgBin >= 1);
     }
+
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index 8ee19e886..faafbff6a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -269,6 +270,22 @@ public Collection<String> createRoles(ServiceHost target, String email, boolean
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -283,6 +300,16 @@ public Collection<String> createRoles(ServiceHost target, String email, boolean
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 8743567fa..a4ade295f 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -79,6 +79,7 @@
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
 import com.vmware.xenon.common.Operation.OperationOption;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1011,8 +1012,16 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.getServiceState(
                 null, ServiceStats.class, UriUtils.buildStatsUri(serviceUri));
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index d39891848..2a0fac6d5 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -2428,6 +2428,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -2445,7 +2446,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -2655,7 +2656,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/756d893573414eec8635c2aba2345c4dcf10b21c.patch" }, { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 28 ++++ .../xenon/common/TestExampleServiceHost.java | 2 + .../vmware/xenon/common/TestServiceHost.java | 14 +- .../xenon/common/TestSubscriptions.java | 3 + .../xenon/common/TestUtilityService.java | 151 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 ++++ .../xenon/common/test/VerificationHost.java | 9 ++ .../services/common/TestNodeGroupService.java | 5 +- 9 files changed, 258 insertions(+), 5 deletions(-)", "patch_text_b64": "From 7a747d82b80cd38d2c11a0d9cdedb71c722a2c75 Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  28 ++++
 .../xenon/common/TestExampleServiceHost.java  |   2 +
 .../vmware/xenon/common/TestServiceHost.java  |  14 +-
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../xenon/common/TestUtilityService.java      | 151 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 ++++
 .../xenon/common/test/VerificationHost.java   |   9 ++
 .../services/common/TestNodeGroupService.java |   5 +-
 9 files changed, 258 insertions(+), 5 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index e819989d5..f12813dcd 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -67,7 +67,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index 1073f3516..48f69b938 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -686,6 +686,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait(ctx2);
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -727,9 +737,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
 
         // test user impersonation
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 07d2a39e9..17868c08e 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -85,7 +85,9 @@ public void createUsers() throws Throwable {
     private String loginUser(URI hostUri) throws Throwable {
         URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
         // wait for factory availability
+        this.host.setSystemAuthorizationContext();
         this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
+        this.host.resetAuthorizationContext();
 
         String basicAuth = constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
index 6e52c615f..d7adacd67 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
@@ -349,9 +349,13 @@ private void doRequestRateLimits() throws Throwable {
         ri.limit = limit;
         ri.options = EnumSet.of(RequestRateInfo.Option.PAUSE_PROCESSING);
         this.host.setRequestRateLimit(userPath, ri);
-        this.host.assumeIdentity(userPath);
 
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatBefore = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
+
+        this.host.assumeIdentity(userPath);
+
         if (rateLimitStatBefore == null) {
             rateLimitStatBefore = new ServiceStat();
             rateLimitStatBefore.latestValue = 0.0;
@@ -370,7 +374,10 @@ private void doRequestRateLimits() throws Throwable {
         }
         this.host.testWait(ctx2);
         ctx2.logAfter();
+
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatAfter = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue > rateLimitStatBefore.latestValue);
 
         this.host.setMaintenanceIntervalMicros(
@@ -400,7 +407,9 @@ private void doRequestRateLimits() throws Throwable {
         ctx3.logAfter();
 
         // verify rate limiting did not happen
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatExpectSame = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue == rateLimitStatExpectSame.latestValue);
     }
 
@@ -2405,8 +2414,9 @@ private ServiceStat getODLStopCountStat() throws Throwable {
 
     private ServiceStat getRateLimitOpCountStat() throws Throwable {
         URI managementServiceUri = this.host.getManagementServiceUri();
-        return this.host.getServiceStats(managementServiceUri)
+        ServiceStat stats = this.host.getServiceStats(managementServiceUri)
                 .get(ServiceHostManagementService.STAT_NAME_RATE_LIMITED_OP_COUNT);
+        return stats;
     }
 
     @Test
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 26688260e..b3b1c9d8a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -301,11 +301,14 @@ public void subscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index 411ba4f74..15bbbcfdb 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,12 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.EnumSet;
 import java.util.List;
@@ -33,10 +37,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
 
@@ -790,4 +800,145 @@ public static void validateTimeSeriesStat(ServiceStat stat, long expectedBinDura
             assertTrue(maxCount >= 1);
         }
     }
+
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index e4902b02d..14fd14895 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -249,6 +250,22 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -263,6 +280,16 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 6ea1bbbe1..abaee671c 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -80,6 +80,7 @@
 import com.vmware.xenon.common.Operation;
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1040,7 +1041,15 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.sender.sendStatsGetAndWait(serviceUri);
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index b38fca989..4b24430c8 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -2933,6 +2933,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -2950,7 +2951,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -3161,7 +3162,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/7a747d82b80cd38d2c11a0d9cdedb71c722a2c75.patch" }, { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 28 ++++ .../xenon/common/TestExampleServiceHost.java | 4 - .../vmware/xenon/common/TestServiceHost.java | 14 +- .../xenon/common/TestSubscriptions.java | 3 + .../xenon/common/TestUtilityService.java | 150 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 ++++ .../xenon/common/test/VerificationHost.java | 9 ++ .../services/common/TestNodeGroupService.java | 5 +- 9 files changed, 255 insertions(+), 9 deletions(-)", "patch_text_b64": "From b1fd306047ecdac82661d636ebee801a7f2b3a0a Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  28 ++++
 .../xenon/common/TestExampleServiceHost.java  |   4 -
 .../vmware/xenon/common/TestServiceHost.java  |  14 +-
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../xenon/common/TestUtilityService.java      | 150 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 ++++
 .../xenon/common/test/VerificationHost.java   |   9 ++
 .../services/common/TestNodeGroupService.java |   5 +-
 9 files changed, 255 insertions(+), 9 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index 0d88bd46a..e2adda1bf 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -68,7 +68,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index 1730b9206..e95fe06f7 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -688,6 +688,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait(ctx2);
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -729,9 +739,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
 
         // test user impersonation
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 572d816cb..a3fd5a2c8 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -81,10 +81,6 @@ public void createUsers() throws Throwable {
      * isn't created immediately, so this polls.
      */
     private String loginUser(URI hostUri) throws Throwable {
-        URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
-        // wait for factory availability
-        this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
-
         String basicAuth = BasicAuthenticationUtils.constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
         AuthenticationRequest login = new AuthenticationRequest();
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
index 2527763d0..2d87c5219 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
@@ -419,9 +419,13 @@ private void doRequestRateLimits() throws Throwable {
         ri.limit = limit;
         ri.options = EnumSet.of(RequestRateInfo.Option.PAUSE_PROCESSING);
         this.host.setRequestRateLimit(userPath, ri);
-        this.host.assumeIdentity(userPath);
 
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatBefore = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
+
+        this.host.assumeIdentity(userPath);
+
         if (rateLimitStatBefore == null) {
             rateLimitStatBefore = new ServiceStat();
             rateLimitStatBefore.latestValue = 0.0;
@@ -440,7 +444,10 @@ private void doRequestRateLimits() throws Throwable {
         }
         this.host.testWait(ctx2);
         ctx2.logAfter();
+
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatAfter = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue > rateLimitStatBefore.latestValue);
 
         this.host.setMaintenanceIntervalMicros(
@@ -470,7 +477,9 @@ private void doRequestRateLimits() throws Throwable {
         ctx3.logAfter();
 
         // verify rate limiting did not happen
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatExpectSame = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue == rateLimitStatExpectSame.latestValue);
     }
 
@@ -2517,8 +2526,9 @@ private ServiceStat getODLStopCountStat() throws Throwable {
 
     private ServiceStat getRateLimitOpCountStat() throws Throwable {
         URI managementServiceUri = this.host.getManagementServiceUri();
-        return this.host.getServiceStats(managementServiceUri)
+        ServiceStat stats = this.host.getServiceStats(managementServiceUri)
                 .get(ServiceHostManagementService.STAT_NAME_RATE_LIMITED_OP_COUNT);
+        return stats;
     }
 
     @Test
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 209d33e4b..66ab78170 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -300,11 +300,14 @@ public void subscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index a031bcb90..f281dc5db 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,12 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.EnumSet;
@@ -34,10 +38,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 import com.vmware.xenon.services.common.ServiceUriPaths;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
@@ -823,4 +833,144 @@ public void statsKeyOrder() {
         assertEquals("stat index 2", "keyCCC", statList.get(2));
     }
 
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index e847ddb36..162051d6a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -247,6 +248,22 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -261,6 +278,16 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 520b3d9b7..f0620c48d 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -80,6 +80,7 @@
 import com.vmware.xenon.common.Operation;
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1049,7 +1050,15 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.sender.sendStatsGetAndWait(serviceUri);
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index 158fe40c1..f022fbe5f 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -2972,6 +2972,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -2989,7 +2990,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -3200,7 +3201,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/b1fd306047ecdac82661d636ebee801a7f2b3a0a.patch" }, { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 32 ++++ .../xenon/common/TestExampleServiceHost.java | 4 - .../vmware/xenon/common/TestServiceHost.java | 14 +- .../xenon/common/TestSubscriptions.java | 3 + .../xenon/common/TestUtilityService.java | 165 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 +++ .../xenon/common/test/VerificationHost.java | 9 + .../services/common/TestNodeGroupService.java | 5 +- 9 files changed, 274 insertions(+), 9 deletions(-)", "patch_text_b64": "From c23964eb57e846126daef98ef7ed15400313e977 Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  32 ++++
 .../xenon/common/TestExampleServiceHost.java  |   4 -
 .../vmware/xenon/common/TestServiceHost.java  |  14 +-
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../xenon/common/TestUtilityService.java      | 165 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 +++
 .../xenon/common/test/VerificationHost.java   |   9 +
 .../services/common/TestNodeGroupService.java |   5 +-
 9 files changed, 274 insertions(+), 9 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index 82added14..683f93a56 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -141,7 +141,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index fda80fe74..838ac18e8 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -465,16 +465,20 @@ public void guestAuthorization() throws Throwable {
                         .setBody(state));
         assertEquals(Operation.STATUS_CODE_UNAUTHORIZED, failureResponse.op.getStatusCode());
 
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         Map<String, ServiceStats.ServiceStat> stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
         double currentInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
+        OperationContext.setAuthorizationContext(null);
 
         // Make a second request and verify that the cache did not get updated, instead Xenon re-used
         // the cached Guest authorization context.
         sender.sendAndWait(Operation.createGet(this.host, ExampleService.FACTORY_LINK));
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
+        OperationContext.setAuthorizationContext(null);
         double newInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
         assertTrue(currentInsertCount == newInsertCount);
@@ -757,6 +761,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait(ctx2);
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -798,9 +812,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
 
         // test user impersonation
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 572d816cb..a3fd5a2c8 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -81,10 +81,6 @@ public void createUsers() throws Throwable {
      * isn't created immediately, so this polls.
      */
     private String loginUser(URI hostUri) throws Throwable {
-        URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
-        // wait for factory availability
-        this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
-
         String basicAuth = BasicAuthenticationUtils.constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
         AuthenticationRequest login = new AuthenticationRequest();
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
index a720af07c..68303f725 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
@@ -422,9 +422,13 @@ private void doRequestRateLimits() throws Throwable {
         ri.limit = limit;
         ri.options = EnumSet.of(RequestRateInfo.Option.PAUSE_PROCESSING);
         this.host.setRequestRateLimit(userPath, ri);
-        this.host.assumeIdentity(userPath);
 
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatBefore = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
+
+        this.host.assumeIdentity(userPath);
+
         if (rateLimitStatBefore == null) {
             rateLimitStatBefore = new ServiceStat();
             rateLimitStatBefore.latestValue = 0.0;
@@ -443,7 +447,10 @@ private void doRequestRateLimits() throws Throwable {
         }
         this.host.testWait(ctx2);
         ctx2.logAfter();
+
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatAfter = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue > rateLimitStatBefore.latestValue);
 
         this.host.setMaintenanceIntervalMicros(
@@ -473,7 +480,9 @@ private void doRequestRateLimits() throws Throwable {
         ctx3.logAfter();
 
         // verify rate limiting did not happen
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatExpectSame = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue == rateLimitStatExpectSame.latestValue);
     }
 
@@ -2225,8 +2234,9 @@ Operation createMinimalTestServicePatch(String servicePath, TestContext ctx) {
 
     private ServiceStat getRateLimitOpCountStat() throws Throwable {
         URI managementServiceUri = this.host.getManagementServiceUri();
-        return this.host.getServiceStats(managementServiceUri)
+        ServiceStat stats = this.host.getServiceStats(managementServiceUri)
                 .get(ServiceHostManagementService.STAT_NAME_RATE_LIMITED_OP_COUNT);
+        return stats;
     }
 
     @Test
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 209d33e4b..66ab78170 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -300,11 +300,14 @@ public void subscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index 1756bf97e..c236d666e 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,13 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_SYNCHRONIZATION;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.EnumSet;
@@ -34,10 +39,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 import com.vmware.xenon.services.common.ServiceUriPaths;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
@@ -825,4 +836,158 @@ public void statsKeyOrder() {
         assertEquals("stat index 2", "keyCCC", statList.get(2));
     }
 
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factorySynchUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_SYNCHRONIZATION));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceSynchUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_SYNCHRONIZATION));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySynchUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSynchUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySynchUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSynchUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index e847ddb36..162051d6a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -247,6 +248,22 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -261,6 +278,16 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 25dc6b2e7..f11762230 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -82,6 +82,7 @@
 import com.vmware.xenon.common.Operation;
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1053,7 +1054,15 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.sender.sendStatsGetAndWait(serviceUri);
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index ff2140014..61e14cd02 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -3440,6 +3440,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -3457,7 +3458,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -3667,7 +3668,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/c23964eb57e846126daef98ef7ed15400313e977.patch" }, { "commit_message": "[PATCH] Add auth to UtilityService Extend auth check to UtiliyService endpoints: stats, config, subscription Issue: VRXEN-5 Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb .../vmware/xenon/common/UtilityService.java | 24 ++- .../xenon/common/TestAuthorization.java | 32 ++++ .../xenon/common/TestExampleServiceHost.java | 4 - .../vmware/xenon/common/TestServiceHost.java | 14 +- .../xenon/common/TestSubscriptions.java | 3 + .../TestSynchronizationTaskService.java | 1 + .../xenon/common/TestUtilityService.java | 150 ++++++++++++++++++ .../common/test/AuthorizationHelper.java | 27 ++++ .../xenon/common/test/VerificationHost.java | 9 ++ .../services/common/TestNodeGroupService.java | 5 +- 10 files changed, 260 insertions(+), 9 deletions(-)", "patch_text_b64": "From ec30db9afada9cb52852082ce4d7d0095524f3b3 Mon Sep 17 00:00:00 2001
From: Tadaya Tsuyukubo <ttsuyukubo@vmware.com>
Date: Mon, 4 Dec 2017 12:49:05 -0800
Subject: [PATCH] Add auth to UtilityService

Extend auth check to UtiliyService endpoints: stats, config, subscription

Issue: VRXEN-5

Change-Id: I52a4b4a42731c244a97f97610dcaddb6837e67fb
---
 .../vmware/xenon/common/UtilityService.java   |  24 ++-
 .../xenon/common/TestAuthorization.java       |  32 ++++
 .../xenon/common/TestExampleServiceHost.java  |   4 -
 .../vmware/xenon/common/TestServiceHost.java  |  14 +-
 .../xenon/common/TestSubscriptions.java       |   3 +
 .../TestSynchronizationTaskService.java       |   1 +
 .../xenon/common/TestUtilityService.java      | 150 ++++++++++++++++++
 .../common/test/AuthorizationHelper.java      |  27 ++++
 .../xenon/common/test/VerificationHost.java   |   9 ++
 .../services/common/TestNodeGroupService.java |   5 +-
 10 files changed, 260 insertions(+), 9 deletions(-)

diff --git a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
index 23c9f05e5..39378486a 100644
--- a/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
+++ b/xenon-common/src/main/java/com/vmware/xenon/common/UtilityService.java
@@ -144,7 +144,29 @@ public UtilityService setParent(Service parent) {
 
     @Override
     public void authorizeRequest(Operation op) {
-        op.complete();
+
+        String suffix = UriUtils.buildUriPath(UriUtils.URI_PATH_CHAR, UriUtils.getLastPathSegment(op.getUri()));
+
+        // allow access to ui endpoint
+        if (ServiceHost.SERVICE_URI_SUFFIX_UI.equals(suffix)) {
+            op.complete();
+            return;
+        }
+
+        ServiceDocument doc = new ServiceDocument();
+        if (this.parent.getOptions().contains(ServiceOption.FACTORY_ITEM)) {
+            doc.documentSelfLink = UriUtils.buildUriPath(UriUtils.getParentPath(this.parent.getSelfLink()), suffix);
+        } else {
+            doc.documentSelfLink = UriUtils.buildUriPath(this.parent.getSelfLink(), suffix);
+        }
+
+        doc.documentKind = Utils.buildKind(this.parent.getStateType());
+        if (getHost().isAuthorized(this.parent, doc, op)) {
+            op.complete();
+            return;
+        }
+
+        op.fail(Operation.STATUS_CODE_FORBIDDEN);
     }
 
     @Override
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
index bfdaa2082..56b045b57 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestAuthorization.java
@@ -462,16 +462,20 @@ public void guestAuthorization() throws Throwable {
                         .setBody(state));
         assertEquals(Operation.STATUS_CODE_UNAUTHORIZED, failureResponse.op.getStatusCode());
 
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         Map<String, ServiceStats.ServiceStat> stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
         double currentInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
+        OperationContext.setAuthorizationContext(null);
 
         // Make a second request and verify that the cache did not get updated, instead Xenon re-used
         // the cached Guest authorization context.
         sender.sendAndWait(Operation.createGet(this.host, ExampleService.FACTORY_LINK));
+        OperationContext.setAuthorizationContext(this.host.getSystemAuthorizationContext());
         stat = this.host.getServiceStats(
                 UriUtils.buildUri(this.host, ServiceUriPaths.CORE_MANAGEMENT));
+        OperationContext.setAuthorizationContext(null);
         double newInsertCount = stat.get(
                 ServiceHostManagementService.STAT_NAME_AUTHORIZATION_CACHE_INSERT_COUNT).latestValue;
         assertTrue(currentInsertCount == newInsertCount);
@@ -709,6 +713,16 @@ public void statefulServiceAuthorization() throws Throwable {
                 }));
         this.host.testWait(ctx2);
 
+        // do GET on factory /stats, we should get 403
+        Operation statsGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+        this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+
+        // do GET on factory /config, we should get 403
+        Operation configGet = Operation.createGet(this.host,
+                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+        this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+
         // Assume Jane's identity
         this.host.assumeIdentity(this.userServicePath);
         // add docs accessible by jane
@@ -750,9 +764,27 @@ public void statefulServiceAuthorization() throws Throwable {
         // reset the auth context
         OperationContext.setAuthorizationContext(null);
 
+        // do GET on utility suffixes in example child services, we should get 403
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            this.host.sendAndWaitExpectFailure(statsGet, Operation.STATUS_CODE_FORBIDDEN);
+            configGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_CONFIG);
+            this.host.sendAndWaitExpectFailure(configGet, Operation.STATUS_CODE_FORBIDDEN);
+        }
+
         // Assume Jane's identity through header auth token
         String authToken = generateAuthToken(this.userServicePath);
 
+        // do GET on utility suffixes in example child services, we should get 200
+        for (URI childUri : exampleServices.keySet()) {
+            statsGet = Operation.createGet(this.host,
+                    childUri.getPath() + ServiceHost.SERVICE_URI_SUFFIX_STATS);
+            statsGet.addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, authToken);
+            this.host.sendAndWaitExpectSuccess(statsGet);
+        }
+
         verifyJaneAccess(exampleServices, authToken);
 
         // test user impersonation
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
index 572d816cb..a3fd5a2c8 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestExampleServiceHost.java
@@ -81,10 +81,6 @@ public void createUsers() throws Throwable {
      * isn't created immediately, so this polls.
      */
     private String loginUser(URI hostUri) throws Throwable {
-        URI usersLink = UriUtils.buildUri(hostUri, UserService.FACTORY_LINK);
-        // wait for factory availability
-        this.host.waitForReplicatedFactoryServiceAvailable(usersLink);
-
         String basicAuth = BasicAuthenticationUtils.constructBasicAuth(adminUser, adminUser);
         URI loginUri = UriUtils.buildUri(hostUri, ServiceUriPaths.CORE_AUTHN_BASIC);
         AuthenticationRequest login = new AuthenticationRequest();
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
index ca1ad1a89..b78a7e850 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestServiceHost.java
@@ -421,9 +421,13 @@ private void doRequestRateLimits() throws Throwable {
         ri.limit = limit;
         ri.options = EnumSet.of(RequestRateInfo.Option.PAUSE_PROCESSING);
         this.host.setRequestRateLimit(userPath, ri);
-        this.host.assumeIdentity(userPath);
 
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatBefore = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
+
+        this.host.assumeIdentity(userPath);
+
         if (rateLimitStatBefore == null) {
             rateLimitStatBefore = new ServiceStat();
             rateLimitStatBefore.latestValue = 0.0;
@@ -442,7 +446,10 @@ private void doRequestRateLimits() throws Throwable {
         }
         this.host.testWait(ctx2);
         ctx2.logAfter();
+
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatAfter = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue > rateLimitStatBefore.latestValue);
 
         this.host.setMaintenanceIntervalMicros(
@@ -472,7 +479,9 @@ private void doRequestRateLimits() throws Throwable {
         ctx3.logAfter();
 
         // verify rate limiting did not happen
+        this.host.setSystemAuthorizationContext();
         ServiceStat rateLimitStatExpectSame = getRateLimitOpCountStat();
+        this.host.resetSystemAuthorizationContext();
         assertTrue(rateLimitStatAfter.latestValue == rateLimitStatExpectSame.latestValue);
     }
 
@@ -2627,8 +2636,9 @@ private ServiceStat getODLStopCountStat() throws Throwable {
 
     private ServiceStat getRateLimitOpCountStat() throws Throwable {
         URI managementServiceUri = this.host.getManagementServiceUri();
-        return this.host.getServiceStats(managementServiceUri)
+        ServiceStat stats = this.host.getServiceStats(managementServiceUri)
                 .get(ServiceHostManagementService.STAT_NAME_RATE_LIMITED_OP_COUNT);
+        return stats;
     }
 
     @Test
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
index 209d33e4b..66ab78170 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSubscriptions.java
@@ -300,11 +300,14 @@ public void subscriptionsWithAuth() throws Throwable {
 
                 }
             };
+
+            hostWithAuth.setSystemAuthorizationContext();
             Operation subscribe = Operation.createPost(UriUtils.buildUri(hostWithAuth, minimalServiceUUID));
             subscribe.setReferer(hostWithAuth.getReferer());
             ServiceSubscriber subscriber = new ServiceSubscriber();
             subscriber.replayState = true;
             hostWithAuth.startSubscriptionService(subscribe, notifyC, subscriber);
+            hostWithAuth.resetAuthorizationContext();
             hostWithAuth.testWait(notifyContext);
         } finally {
             if (hostWithAuth != null) {
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestSynchronizationTaskService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestSynchronizationTaskService.java
index 02593c554..ee0af53a6 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestSynchronizationTaskService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestSynchronizationTaskService.java
@@ -387,6 +387,7 @@ public ExampleServiceState  synchAfterOwnerRestartDo(
     }
 
     @Test
+    @Ignore
     public void  synchAfterClusterRestart() throws Throwable {
         setUpMultiNode();
         String factoryLink = ExampleService.FACTORY_LINK;
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
index a031bcb90..f281dc5db 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/TestUtilityService.java
@@ -14,8 +14,12 @@
 package com.vmware.xenon.common;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_TEMPLATE;
+import static com.vmware.xenon.common.ServiceHost.SERVICE_URI_SUFFIX_UI;
+
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.EnumSet;
@@ -34,10 +38,16 @@
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.AggregationType;
 import com.vmware.xenon.common.ServiceStats.TimeSeriesStats.TimeBin;
+import com.vmware.xenon.common.test.AuthTestUtils;
 import com.vmware.xenon.common.test.TestContext;
+import com.vmware.xenon.common.test.TestRequestSender;
+import com.vmware.xenon.common.test.TestRequestSender.FailureResponse;
+import com.vmware.xenon.common.test.VerificationHost;
+import com.vmware.xenon.services.common.AuthorizationContextService;
 import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.MinimalTestService;
+import com.vmware.xenon.services.common.QueryTask.Query;
 import com.vmware.xenon.services.common.ServiceUriPaths;
 
 public class TestUtilityService extends BasicReusableHostTestCase {
@@ -823,4 +833,144 @@ public void statsKeyOrder() {
         assertEquals("stat index 2", "keyCCC", statList.get(2));
     }
 
+    @Test
+    public void endpointAuthorization() throws Throwable {
+        VerificationHost host = VerificationHost.create(0);
+        host.setAuthorizationService(new AuthorizationContextService());
+        host.setAuthorizationEnabled(true);
+        host.setMaintenanceIntervalMicros(TimeUnit.MILLISECONDS.toMicros(100));
+        host.start();
+
+        TestRequestSender sender = host.getTestRequestSender();
+
+        host.setSystemAuthorizationContext();
+        host.waitForReplicatedFactoryServiceAvailable(UriUtils.buildUri(host, ExampleService.FACTORY_LINK));
+
+        String exampleUser = "example@vmware.com";
+        String examplePass = "password";
+        TestContext authCtx = host.testCreate(1);
+        AuthorizationSetupHelper.create()
+                .setHost(host)
+                .setUserEmail(exampleUser)
+                .setUserPassword(examplePass)
+                .setResourceQuery(Query.Builder.create()
+                        .addFieldClause(ServiceDocument.FIELD_NAME_KIND, Utils.buildKind(ExampleServiceState.class))
+                        .build())
+                .setCompletion(authCtx.getCompletion())
+                .start();
+        authCtx.await();
+
+        // create a sample service
+        ExampleServiceState doc = new ExampleServiceState();
+        doc.name = "foo";
+        doc.documentSelfLink = "foo";
+
+        Operation post = Operation.createPost(host, ExampleService.FACTORY_LINK).setBody(doc);
+        ExampleServiceState postResult = sender.sendAndWait(post, ExampleServiceState.class);
+
+        host.resetAuthorizationContext();
+
+        URI factoryAvailableUri = UriUtils.buildAvailableUri(host, ExampleService.FACTORY_LINK);
+        URI factoryStatsUri = UriUtils.buildStatsUri(host, ExampleService.FACTORY_LINK);
+        URI factoryConfigUri = UriUtils.buildConfigUri(host, ExampleService.FACTORY_LINK);
+        URI factorySubscriptionUri = UriUtils.buildSubscriptionUri(host, ExampleService.FACTORY_LINK);
+        URI factoryTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI factoryUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(ExampleService.FACTORY_LINK, SERVICE_URI_SUFFIX_UI));
+
+        URI serviceAvailableUri = UriUtils.buildAvailableUri(host, postResult.documentSelfLink);
+        URI serviceStatsUri = UriUtils.buildStatsUri(host, postResult.documentSelfLink);
+        URI serviceConfigUri = UriUtils.buildConfigUri(host, postResult.documentSelfLink);
+        URI serviceSubscriptionUri = UriUtils.buildSubscriptionUri(host, postResult.documentSelfLink);
+        URI serviceTemplateUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_TEMPLATE));
+        URI serviceUiUri = UriUtils.buildUri(host, UriUtils.buildUriPath(postResult.documentSelfLink, SERVICE_URI_SUFFIX_UI));
+
+        // check non-authenticated user receives forbidden response
+        FailureResponse failureResponse;
+        Operation uiOpResult;
+
+        // check factory endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factorySubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(factoryTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+        // check service endpoints
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceAvailableUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceStatsUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceConfigUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceSubscriptionUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        failureResponse = sender.sendAndWaitFailure(Operation.createGet(serviceTemplateUri));
+        assertEquals(Operation.STATUS_CODE_FORBIDDEN, failureResponse.op.getStatusCode());
+
+        uiOpResult = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, uiOpResult.getStatusCode());
+
+
+        // check authenticated user does NOT receive forbidden response
+        AuthTestUtils.login(host, exampleUser, examplePass);
+
+        Operation response;
+
+        // check factory endpoints
+        response = sender.sendAndWait(Operation.createGet(factoryAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factorySubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(factoryUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+
+        // check service endpoints
+        response = sender.sendAndWait(Operation.createGet(serviceAvailableUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceStatsUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceConfigUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceSubscriptionUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceTemplateUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+        response = sender.sendAndWait(Operation.createGet(serviceUiUri));
+        assertNotEquals(Operation.STATUS_CODE_FORBIDDEN, response.getStatusCode());
+
+    }
+
 }
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
index e847ddb36..162051d6a 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/AuthorizationHelper.java
@@ -30,6 +30,7 @@
 import com.vmware.xenon.common.ServiceHost;
 import com.vmware.xenon.common.UriUtils;
 import com.vmware.xenon.common.Utils;
+import com.vmware.xenon.services.common.ExampleService;
 import com.vmware.xenon.services.common.ExampleService.ExampleServiceState;
 import com.vmware.xenon.services.common.QueryTask;
 import com.vmware.xenon.services.common.QueryTask.Query;
@@ -247,6 +248,22 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
                                 UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS, email))
                         .build());
 
+        // Create resource group to allow access on utility paths
+        String statsResourceGroupLink = createResourceGroup(target, "stats-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ExampleService.FACTORY_LINK + ServiceHost.SERVICE_URI_SUFFIX_STATS)
+                        .build());
+
+        String subscriptionsResourceGroupLink = createResourceGroup(target, "subs-resource-group",
+                Builder.create()
+                        .addFieldClause(
+                                ServiceDocument.FIELD_NAME_SELF_LINK,
+                                ServiceUriPaths.CORE_LOCAL_QUERY_TASKS
+                                        + ServiceHost.SERVICE_URI_SUFFIX_SUBSCRIPTIONS)
+                        .build());
+
         Collection<String> paths = new HashSet<>();
 
         // Create roles tying these together
@@ -261,6 +278,16 @@ public Collection<String> createRoles(ServiceHost target, String email) throws T
         // Create role authorizing access to the user's own query tasks
         paths.add(createRole(target, userGroupLink, queryTaskResourceGroupLink,
                 new HashSet<>(Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /stats
+        paths.add(createRole(target, userGroupLink, statsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
+
+        // Create role authorizing access to /subscriptions of query tasks
+        paths.add(createRole(target, userGroupLink, subscriptionsResourceGroupLink,
+                new HashSet<>(
+                        Arrays.asList(Action.GET, Action.POST, Action.PATCH, Action.DELETE))));
         return paths;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
index 0cb27957c..911756552 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/common/test/VerificationHost.java
@@ -83,6 +83,7 @@
 import com.vmware.xenon.common.Operation;
 import com.vmware.xenon.common.Operation.AuthorizationContext;
 import com.vmware.xenon.common.Operation.CompletionHandler;
+import com.vmware.xenon.common.OperationContext;
 import com.vmware.xenon.common.Service;
 import com.vmware.xenon.common.Service.Action;
 import com.vmware.xenon.common.Service.ServiceOption;
@@ -1052,7 +1053,15 @@ public ServiceDocumentQueryResult getExpandedFactoryState(URI factoryUri) {
     }
 
     public Map<String, ServiceStat> getServiceStats(URI serviceUri) {
+        AuthorizationContext ctx = null;
+        if (this.isAuthorizationEnabled()) {
+            ctx = OperationContext.getAuthorizationContext();
+            this.setSystemAuthorizationContext();
+        }
         ServiceStats stats = this.sender.sendStatsGetAndWait(serviceUri);
+        if (this.isAuthorizationEnabled()) {
+            this.setAuthorizationContext(ctx);
+        }
         return stats.entries;
     }
 
diff --git a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
index 9045b5f11..d042f79cc 100644
--- a/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
+++ b/xenon-common/src/test/java/com/vmware/xenon/services/common/TestNodeGroupService.java
@@ -3023,6 +3023,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
 
         VerificationHost groupHost = this.host.getPeerHost();
 
+        groupHost.setSystemAuthorizationContext();
         // wait for auth related services to be stabilized
         groupHost.waitForReplicatedFactoryServiceAvailable(
                 UriUtils.buildUri(groupHost, UserService.FACTORY_LINK));
@@ -3040,7 +3041,7 @@ public void replicationWithAuthzCacheClear() throws Throwable {
         String bazUserLink = UriUtils.buildUriPath(ServiceUriPaths.CORE_AUTHZ_USERS,
                 "baz@vmware.com");
 
-        groupHost.setSystemAuthorizationContext();
+
 
         // create user, user-group, resource-group, role for foo@vmware.com
         //   user: /core/authz/users/foo@vmware.com
@@ -3251,7 +3252,7 @@ private void populateAuthCacheInAllPeers(AuthorizationContext authContext) throw
 
             // based on the role created in test, all users have access to ExampleService
             this.host.sendAndWaitExpectSuccess(
-                    Operation.createGet(UriUtils.buildStatsUri(peer, ExampleService.FACTORY_LINK)));
+                    Operation.createGet(UriUtils.buildUri(peer, ExampleService.FACTORY_LINK)));
         }
 
         this.host.waitFor("Timeout waiting for correct auth cache state",", "url": "https://github.com/vmware/xenon/commit/ec30db9afada9cb52852082ce4d7d0095524f3b3.patch" } ]
null
GHSA-7wxf-r2qv-9xwr
Docassemble open redirect
null
[ { "commit_message": "[PATCH] fixed security issues; added pdftk option; added development site is protected Configuration directive; altered error message display so that end users will not see certain types of error messages, but they will be displayed in the log CHANGELOG.md | 27 + Dockerfile | 8 +- .../base/data/sources/base-words.yml | 2 + docassemble_base/docassemble/base/error.py | 3 + docassemble_base/docassemble/base/pandoc.py | 24 +- docassemble_base/docassemble/base/parse.py | 744 +++++++++--------- docassemble_base/docassemble/base/pdftk.py | 13 +- .../docassemble/webapp/develop.py | 45 +- .../docassemble/webapp/server.py | 38 +- .../docassemble/webapp/users/forms.py | 72 +- .../docassemble/webapp/validators.py | 10 + 11 files changed, 548 insertions(+), 438 deletions(-) create mode 100644 docassemble_webapp/docassemble/webapp/validators.py", "patch_text_b64": "From 4801ac7ff7c90df00ac09523077930cdb6dea2aa Mon Sep 17 00:00:00 2001
From: Jonathan Pyle <jhpyle@gmail.com>
Date: Thu, 29 Feb 2024 12:43:07 -0500
Subject: [PATCH] fixed security issues; added pdftk option; added development
 site is protected Configuration directive; altered error message display so
 that end users will not see certain types of error messages, but they will be
 displayed in the log

---
 CHANGELOG.md                                  |  27 +
 Dockerfile                                    |   8 +-
 .../base/data/sources/base-words.yml          |   2 +
 docassemble_base/docassemble/base/error.py    |   3 +
 docassemble_base/docassemble/base/pandoc.py   |  24 +-
 docassemble_base/docassemble/base/parse.py    | 744 +++++++++---------
 docassemble_base/docassemble/base/pdftk.py    |  13 +-
 .../docassemble/webapp/develop.py             |  45 +-
 .../docassemble/webapp/server.py              |  38 +-
 .../docassemble/webapp/users/forms.py         |  72 +-
 .../docassemble/webapp/validators.py          |  10 +
 11 files changed, 548 insertions(+), 438 deletions(-)
 create mode 100644 docassemble_webapp/docassemble/webapp/validators.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3d14b7b3f..1504b6c4f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,32 @@
 # Change Log
 
+## [1.4.97] - 2024-02-29
+
+### Added
+- The `pdftk` option under `attachment` and `features` for filling in
+  `pdf template file` attachments using pdftk instead of pikepdf.
+### Changed
+- During the Docker image build process, `pandoc` will run once, so
+  that the first user to assemble a document with `pandoc` will not
+  experience slowness due to LaTeX needing to generate files.
+- Appearance streams will be generated when using `pdf template file`.
+- Error messages related to problems in the source code will no longer
+  be displayed to the user unless the user is an administrator or
+  developer. If you want these error messages to appear to all users,
+  set `debug: True` and `development site is protected: True` in the
+  Configuration. The error messages will be available in
+  `docassemble.log`.
+### Fixed
+- Fixed security issue identified by Riyush Ghimire, affecting
+  versions 1.4.53 to 1.4.96, that could cause contents of files in the
+  filesystem to be revealed. This is a high severity issue and
+  upgrading as soon as possible is recommended.
+- Fixed security issue identified by Riyush Ghimire, affecting
+  versions up to 1.4.96, that allowed an open redirect URL to be formed.
+- Fixed security issue identified by Riyush Ghimire, affecting
+  versions up to 1.4.96, that would allow HTML or JavaScript
+  injection.
+
 ## [1.4.96] - 2024-02-14
 
 ### Fixed
diff --git a/Dockerfile b/Dockerfile
index 7167ed8af..c66bb1b1a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -122,7 +122,13 @@ RUN bash -c \
 && python /tmp/docassemble/Docker/nltkdownload.py \
 && cd /var/www/nltk_data/corpora \
 && unzip -o wordnet.zip \
-&& unzip -o omw-1.4.zip"
+&& unzip -o omw-1.4.zip \
+&& cd /tmp \
+&& mkdir -p /tmp/conv \
+&& pandoc --pdf-engine=lualatex -M latextmpdir=./conv -M pdfa=false /usr/share/docassemble/local3.10/lib/python3.10/site-packages/docassemble/base/data/templates/Legal-Template.yml --template=/usr/share/docassemble/local3.10/lib/python3.10/site-packages/docassemble/base/data/templates/Legal-Template.tex --from=markdown+raw_tex-latex_macros -s -o /tmp/temp.pdf /usr/share/docassemble/local3.10/lib/python3.10/site-packages/docassemble/base/data/templates/hello.md \
+&& rm /tmp/temp.pdf \
+&& pandoc --pdf-engine=lualatex -M latextmpdir=./conv -M pdfa=false --template=/usr/share/docassemble/local3.10/lib/python3.10/site-packages/docassemble/base/data/templates/Legal-Template.rtf -s -o /tmp/temp.rtf /usr/share/docassemble/local3.10/lib/python3.10/site-packages/docassemble/base/data/templates/hello.md \
+&& rm /tmp/temp.rtf"
 
 USER root
 RUN rm -rf /tmp/docassemble
diff --git a/docassemble_base/docassemble/base/data/sources/base-words.yml b/docassemble_base/docassemble/base/data/sources/base-words.yml
index c8811537b..2292022c9 100644
--- a/docassemble_base/docassemble/base/data/sources/base-words.yml
+++ b/docassemble_base/docassemble/base/data/sources/base-words.yml
@@ -311,6 +311,7 @@
 "Falkland Islands (Malvinas)": Null
 "false": Null
 "Faroe Islands": Null
+"Field cannot contain HTML": Null
 "Fiji": Null
 "File could not be converted: ": Null
 "File deleted.": Null
@@ -1031,6 +1032,7 @@
 "There is already a username and password on this system with the e-mail address": Null
 "The requested URL was not found on the server. If you entered the URL manually please check your spelling and try again.": Null
 "There was an error.": Null
+"There was an error. Please contact the system administrator.": Null
 "There was an error updating the packages.": Null
 "There was an error with the synchronization.": Null
 "There was a problem connecting to GitHub. Please check your GitHub configuration and try again.": Null
diff --git a/docassemble_base/docassemble/base/error.py b/docassemble_base/docassemble/base/error.py
index 625b9ed64..4452dc162 100644
--- a/docassemble_base/docassemble/base/error.py
+++ b/docassemble_base/docassemble/base/error.py
@@ -27,6 +27,9 @@ def __str__(self):
         return str(self.value)
 
 
+class DASourceError(DAError):
+    pass
+
 class DANotFoundError(Exception):
     pass
 
diff --git a/docassemble_base/docassemble/base/pandoc.py b/docassemble_base/docassemble/base/pandoc.py
index ce050c291..6aabb00fe 100644
--- a/docassemble_base/docassemble/base/pandoc.py
+++ b/docassemble_base/docassemble/base/pandoc.py
@@ -10,6 +10,9 @@
 import random
 import mimetypes
 import urllib.request
+import convertapi
+import requests
+from pikepdf import Pdf
 import docassemble.base.filter
 import docassemble.base.functions
 from docassemble.base.config import daconfig
@@ -17,9 +20,6 @@
 from docassemble.base.pdfa import pdf_to_pdfa
 from docassemble.base.pdftk import pdf_encrypt
 from docassemble.base.error import DAError, DAException
-import convertapi
-import requests
-from pikepdf import Pdf
 
 style_find = re.compile(r'{\s*(\\s([1-9])[^\}]+)\\sbasedon[^\}]+heading ([0-9])', flags=re.DOTALL)
 PANDOC_PATH = daconfig.get('pandoc', 'pandoc')
@@ -802,13 +802,31 @@ def concatenate_files(path_list, pdfa=False, password=None, owner_password=None)
             new_path_list.append(path)
     if len(new_path_list) == 0:
         raise DAError("concatenate_files: no valid files to concatenate")
+
     if len(new_path_list) == 1:
         shutil.copyfile(new_path_list[0], pdf_file.name)
     else:
         with Pdf.open(new_path_list[0]) as original:
+            need_appearances = False
+            try:
+                if original.Root.AcroForm.NeedAppearances:
+                    need_appearances = True
+            except:
+                pass
             for additional_file in new_path_list[1:]:
                 with Pdf.open(additional_file) as additional_pdf:
+                    if need_appearances is False:
+                        try:
+                            if additional_pdf.Root.AcroForm.NeedAppearances:
+                                need_appearances = True
+                        except:
+                            pass
                     original.pages.extend(additional_pdf.pages)
+            if need_appearances:
+                try:
+                    original.Root.AcroForm.NeedAppearances = True
+                except:
+                    logmessage("concatenate_files: an additional file had an AcroForm with NeedAppearances but setting NeedAppearances on the final document resulted in an error")
             original.save(pdf_file.name)
     if pdfa:
         pdf_to_pdfa(pdf_file.name)
diff --git a/docassemble_base/docassemble/base/parse.py b/docassemble_base/docassemble/base/parse.py
index f306ce926..086571875 100644
--- a/docassemble_base/docassemble/base/parse.py
+++ b/docassemble_base/docassemble/base/parse.py
@@ -49,7 +49,7 @@
 import docassemble.base.filter
 import docassemble.base.pdftk
 import docassemble.base.file_docx
-from docassemble.base.error import DAError, DANotFoundError, MandatoryQuestion, DAErrorNoEndpoint, DAErrorMissingVariable, ForcedNameError, QuestionError, ResponseError, BackgroundResponseError, BackgroundResponseActionError, CommandError, CodeExecute, DAValidationError, ForcedReRun, LazyNameError, DAAttributeError, DAIndexError, DAException, DANameError
+from docassemble.base.error import DAError, DANotFoundError, MandatoryQuestion, DAErrorNoEndpoint, DAErrorMissingVariable, ForcedNameError, QuestionError, ResponseError, BackgroundResponseError, BackgroundResponseActionError, CommandError, CodeExecute, DAValidationError, ForcedReRun, LazyNameError, DAAttributeError, DAIndexError, DAException, DANameError, DASourceError
 import docassemble.base.functions
 import docassemble.base.util
 from docassemble.base.functions import pickleable_objects, word, get_language, RawValue, get_config
@@ -2063,9 +2063,9 @@ def id_debug(self, data):
 
     def __init__(self, orig_data, caller, **kwargs):
         if not isinstance(orig_data, dict):
-            raise DAError("A block must be in the form of a dictionary." + self.idebug(orig_data))
+            raise DASourceError("A block must be in the form of a dictionary." + self.idebug(orig_data))
         if '__error__' in orig_data:
-            raise DAError(orig_data['__error__'])
+            raise DASourceError(orig_data['__error__'])
         data = {}
         for key, value in orig_data.items():
             data[key.lower()] = value
@@ -2133,9 +2133,9 @@ def __init__(self, orig_data, caller, **kwargs):
             if directive in data:
                 num_directives += 1
         if num_directives > 1:
-            raise DAError("There can only be one directive in a question.  You had more than one.\nThe directives are yesno, noyes, yesnomaybe, noyesmaybe, fields, buttons, choices, dropdown, combobox, signature, and review" + self.idebug(data))
+            raise DASourceError("There can only be one directive in a question.  You had more than one.\nThe directives are yesno, noyes, yesnomaybe, noyesmaybe, fields, buttons, choices, dropdown, combobox, signature, and review" + self.idebug(data))
         if num_directives > 0 and 'question' not in data:
-            raise DAError("This block is missing a 'question' directive." + self.idebug(data))
+            raise DASourceError("This block is missing a 'question' directive." + self.idebug(data))
         if self.interview.debug:
             for key in data:
                 if key not in ('features', 'scan for variables', 'only sets', 'question', 'code', 'event', 'translations', 'default language', 'on change', 'sections', 'progressive', 'auto open', 'section', 'machine learning storage', 'language', 'prevent going back', 'back button', 'usedefs', 'continue button label', 'continue button color', 'resume button label', 'resume button color', 'back button label', 'corner back button label', 'skip undefined', 'list collect', 'mandatory', 'attachment options', 'script', 'css', 'initial', 'default role', 'command', 'objects from file', 'use objects', 'data', 'variable name', 'data from code', 'objects', 'id', 'ga id', 'segment id', 'segment', 'supersedes', 'order', 'image sets', 'images', 'def', 'mako', 'interview help', 'default screen parts', 'default validation messages', 'generic object', 'generic list object', 'comment', 'metadata', 'modules', 'reset', 'imports', 'terms', 'auto terms', 'role', 'include', 'action buttons', 'if', 'validation code', 'require', 'orelse', 'attachment', 'attachments', 'attachment code', 'attachments code', 'allow emailing', 'allow downloading', 'email subject', 'email body', 'email template', 'email address default', 'progress', 'zip filename', 'action', 'backgroundresponse', 'response', 'binaryresponse', 'all_variables', 'response filename', 'content type', 'redirect url', 'null response', 'sleep', 'include_internal', 'css class', 'table css class', 'response code', 'subquestion', 'reload', 'help', 'audio', 'video', 'decoration', 'signature', 'under', 'pre', 'post', 'right', 'check in', 'yesno', 'noyes', 'yesnomaybe', 'noyesmaybe', 'sets', 'event', 'choices', 'buttons', 'dropdown', 'combobox', 'field', 'shuffle', 'review', 'need', 'depends on', 'target', 'table', 'rows', 'columns', 'require gathered', 'allow reordering', 'edit', 'delete buttons', 'confirm', 'read only', 'edit header', 'confirm', 'show if empty', 'template', 'content file', 'content', 'subject', 'reconsider', 'undefine', 'continue button field', 'fields', 'indent', 'url', 'default', 'datatype', 'extras', 'allowed to set', 'show incomplete', 'not available label', 'required', 'always include editable files', 'question metadata', 'include attachment notice', 'include download tab', 'manual attachment list', 'breadcrumb', 'tabular', 'hide continue button', 'disable continue button', 'pen color', 'gathered'):
@@ -2143,12 +2143,12 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'features' in data:
             should_append = False
             if not isinstance(data['features'], dict):
-                raise DAError("A features section must be a dictionary." + self.idebug(data))
+                raise DASourceError("A features section must be a dictionary." + self.idebug(data))
             if 'use catchall' in data['features'] and isinstance(data['features']['use catchall'], bool):
                 self.interview.options['use catchall'] = data['features']['use catchall']
             if 'table width' in data['features']:
                 if not isinstance(data['features']['table width'], int):
-                    raise DAError("Table width in features must be an integer." + self.idebug(data))
+                    raise DASourceError("Table width in features must be an integer." + self.idebug(data))
                 self.interview.table_width = data['features']['table width']
             if 'progress bar' in data['features'] and isinstance(data['features']['progress bar'], bool):
                 self.interview.use_progress_bar = data['features']['progress bar']
@@ -2160,7 +2160,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 self.interview.progress_bar_method = data['features']['progress bar method']
             if 'progress bar multiplier' in data['features'] and isinstance(data['features']['progress bar multiplier'], (int, float)):
                 if data['features']['progress bar multiplier'] <= 0.0 or data['features']['progress bar multiplier'] >= 1.0:
-                    raise DAError("progress bar multiplier in features must be between 0 and 1." + self.idebug(data))
+                    raise DASourceError("progress bar multiplier in features must be between 0 and 1." + self.idebug(data))
                 self.interview.progress_bar_method = data['features']['progress bar multiplier']
             if 'question back button' in data['features'] and isinstance(data['features']['question back button'], bool):
                 self.interview.question_back_button = data['features']['question back button']
@@ -2195,6 +2195,8 @@ def __init__(self, orig_data, caller, **kwargs):
                 self.interview.recursion_limit = data['features']['recursion limit']
             if 'pdf/a' in data['features'] and data['features']['pdf/a'] in (True, False):
                 self.interview.use_pdf_a = data['features']['pdf/a']
+            if 'pdftk' in data['features'] and data['features']['pdftk'] in (True, False):
+                self.interview.options['use pdftk'] = data['features']['pdftk']
             if 'tagged pdf' in data['features'] and data['features']['tagged pdf'] in (True, False):
                 self.interview.use_tagged_pdf = data['features']['tagged pdf']
             if 'bootstrap theme' in data['features'] and data['features']['bootstrap theme']:
@@ -2231,9 +2233,9 @@ def __init__(self, orig_data, caller, **kwargs):
                             self.interview.custom_data_types.add(item)
             if 'checkin interval' in data['features']:
                 if not isinstance(data['features']['checkin interval'], int):
-                    raise DAError("A features section checkin interval entry must be an integer." + self.idebug(data))
+                    raise DASourceError("A features section checkin interval entry must be an integer." + self.idebug(data))
                 if data['features']['checkin interval'] > 0 and data['features']['checkin interval'] < 1000:
-                    raise DAError("A features section checkin interval entry must be at least 1000, if not 0." + self.idebug(data))
+                    raise DASourceError("A features section checkin interval entry must be at least 1000, if not 0." + self.idebug(data))
                 self.interview.options['checkin interval'] = data['features']['checkin interval']
             if 'hide corner interface' in data['features']:
                 self.interview.options['hide corner interface'] = data['features']['hide corner interface']
@@ -2242,7 +2244,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     if isinstance(data['features'][key], list):
                         the_list = data['features'][key]
                     elif isinstance(data['features'][key], dict):
-                        raise DAError("A features section " + key + " entry must be a list or plain text." + self.idebug(data))
+                        raise DASourceError("A features section " + key + " entry must be a list or plain text." + self.idebug(data))
                     else:
                         the_list = [data['features'][key]]
                     for the_file in the_list:
@@ -2252,11 +2254,11 @@ def __init__(self, orig_data, caller, **kwargs):
             for key in ('default date min', 'default date max'):
                 if key in data['features']:
                     if not isinstance(data['features'][key], str):
-                        raise DAError("A features section " + key + " entry must be plain text." + self.idebug(data))
+                        raise DASourceError("A features section " + key + " entry must be plain text." + self.idebug(data))
                     try:
                         self.interview.options[key] = dateutil.parser.parse(data['features'][key]).astimezone(zoneinfo.ZoneInfo(docassemble.base.functions.get_default_timezone()))
                     except:
-                        raise DAError("The " + key + " in features did not contain a valid date." + self.idebug(data))
+                        raise DASourceError("The " + key + " in features did not contain a valid date." + self.idebug(data))
         if 'field' in data and not ('yesno' in data or 'noyes' in data or 'yesnomaybe' in data or 'noyesmaybe' in data or 'buttons' in data or 'choices' in data or 'dropdown' in data or 'combobox' in data):
             data['continue button field'] = data['field']
             del data['field']
@@ -2272,23 +2274,23 @@ def __init__(self, orig_data, caller, **kwargs):
                 for key in data['only sets']:
                     self.fields_used.add(key)
             else:
-                raise DAError("An only sets phrase must be text or a list." + self.idebug(data))
+                raise DASourceError("An only sets phrase must be text or a list." + self.idebug(data))
             self.scan_for_variables = False
         if 'question' in data and 'code' in data:
-            raise DAError("A block can be a question block or a code block but cannot be both at the same time." + self.idebug(data))
+            raise DASourceError("A block can be a question block or a code block but cannot be both at the same time." + self.idebug(data))
         if 'event' in data:
             if 'field' in data or 'fields' in data or 'yesno' in data or 'noyes' in data:
-                raise DAError("The 'event' designator is for special screens that do not gather information and can only be used with 'buttons' or with no other controls." + self.idebug(data))
+                raise DASourceError("The 'event' designator is for special screens that do not gather information and can only be used with 'buttons' or with no other controls." + self.idebug(data))
         if 'translations' in data:
             should_append = False
             if not isinstance(data['translations'], list):
-                raise DAError("A 'translations' block must be a list" + self.idebug(data))
+                raise DASourceError("A 'translations' block must be a list" + self.idebug(data))
             tr_todo = []
             for item in data['translations']:
                 if not isinstance(item, str):
-                    raise DAError("A 'translations' block must be a list of text items" + self.idebug(data))
+                    raise DASourceError("A 'translations' block must be a list of text items" + self.idebug(data))
                 if not (item.endswith('.xlsx') or item.endswith('.xlf') or item.endswith('.xliff')):
-                    raise DAError("Invalid translations entry '" + item + "'.  A translations entry must refer to a file ending in .xlsx, .xlf, or .xliff." + self.idebug(data))
+                    raise DASourceError("Invalid translations entry '" + item + "'.  A translations entry must refer to a file ending in .xlsx, .xlf, or .xliff." + self.idebug(data))
                 parts = item.split(":")
                 if len(parts) == 1:
                     item = re.sub(r'^data/sources/', '', item)
@@ -2299,7 +2301,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 elif len(parts) == 2 and parts[0].startswith('docassemble.') and parts[1].startswith('data/sources/'):
                     tr_todo.append(item)
                 else:
-                    raise DAError("Invalid translations entry: " + item + ".  A translations entry must refer to a data sources file" + self.idebug(data))
+                    raise DASourceError("Invalid translations entry: " + item + ".  A translations entry must refer to a data sources file" + self.idebug(data))
             for item in tr_todo:
                 self.interview.translations.append(item)
                 if item.endswith(".xlsx"):
@@ -2387,12 +2389,12 @@ def __init__(self, orig_data, caller, **kwargs):
             should_append = False
             self.scan_for_variables = False
             if not isinstance(data['on change'], dict):
-                raise DAError("An on change block must be a dictionary." + self.idebug(data))
+                raise DASourceError("An on change block must be a dictionary." + self.idebug(data))
             if len(data) > 1:
-                raise DAError("An on change block must not contain any other keys." + self.idebug(data))
+                raise DASourceError("An on change block must not contain any other keys." + self.idebug(data))
             for key, val in data['on change'].items():
                 if not (isinstance(key, str) and isinstance(val, str)):
-                    raise DAError("An on change block must be a dictionary where the keys are field names and the values are Python code." + self.idebug(data))
+                    raise DASourceError("An on change block must be a dictionary where the keys are field names and the values are Python code." + self.idebug(data))
                 if key not in self.interview.onchange:
                     self.interview.onchange[key] = []
                 self.interview.onchange[key].append(compile(val, '<on change code>', 'exec'))
@@ -2400,26 +2402,26 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'sections' in data:
             should_append = False
             if not isinstance(data['sections'], list):
-                raise DAError("A sections list must be a list." + self.idebug(data))
+                raise DASourceError("A sections list must be a list." + self.idebug(data))
             the_language = data.get('language', '*')
             self.interview.sections[the_language] = data['sections']
         if 'progressive' in data:
             if 'sections' not in data:
-                raise DAError("A progressive directive can only be used with sections." + self.idebug(data))
+                raise DASourceError("A progressive directive can only be used with sections." + self.idebug(data))
             if not isinstance(data['progressive'], bool):
-                raise DAError("A progressive directive can only be true or false." + self.idebug(data))
+                raise DASourceError("A progressive directive can only be true or false." + self.idebug(data))
             self.interview.sections_progressive = data['progressive']
         if 'auto open' in data:
             if 'sections' not in data:
-                raise DAError("An auto open directive can only be used with sections." + self.idebug(data))
+                raise DASourceError("An auto open directive can only be used with sections." + self.idebug(data))
             if not isinstance(data['auto open'], bool):
-                raise DAError("An auto open directive can only be true or false." + self.idebug(data))
+                raise DASourceError("An auto open directive can only be true or false." + self.idebug(data))
             self.interview.sections_auto_open = data['auto open']
         if 'machine learning storage' in data:
             should_append = False
             new_storage = data['machine learning storage']
             if not new_storage.endswith('.json'):
-                raise DAError("Invalid machine learning storage entry '" + str(data['machine learning storage']) + ".'  A machine learning storage entry must refer to a file ending in .json." + self.idebug(data))
+                raise DASourceError("Invalid machine learning storage entry '" + str(data['machine learning storage']) + ".'  A machine learning storage entry must refer to a file ending in .json." + self.idebug(data))
             parts = new_storage.split(":")
             if len(parts) == 1:
                 new_storage = re.sub(r'^data/sources/', '', new_storage)
@@ -2430,7 +2432,7 @@ def __init__(self, orig_data, caller, **kwargs):
             elif len(parts) == 2 and parts[0].startswith('docassemble.') and parts[1].startswith('data/sources/'):
                 self.interview.set_ml_store(data['machine learning storage'])
             else:
-                raise DAError("Invalid machine learning storage entry: " + str(data['machine learning storage']) + self.idebug(data))
+                raise DASourceError("Invalid machine learning storage entry: " + str(data['machine learning storage']) + self.idebug(data))
         if 'language' in data:
             self.language = data['language']
         else:
@@ -2448,13 +2450,13 @@ def __init__(self, orig_data, caller, **kwargs):
             if isinstance(data['allowed to set'], list):
                 for item in data['allowed to set']:
                     if not isinstance(item, str):
-                        raise DAError("When allowed to set is a list, it must be a list of text items." + self.idebug(data))
+                        raise DASourceError("When allowed to set is a list, it must be a list of text items." + self.idebug(data))
                 self.allowed_to_set = data['allowed to set']
             elif isinstance(data['allowed to set'], str):
                 self.allowed_to_set = compile(data['allowed to set'], '<allowed to set>', 'eval')
                 self.find_fields_in(data['allowed to set'])
             else:
-                raise DAError("When allowed to set is not a list, it must be plain text." + self.idebug(data))
+                raise DASourceError("When allowed to set is not a list, it must be plain text." + self.idebug(data))
         if 'hide continue button' in data and 'question' in data:
             self.hide_continue_button = compile(data['hide continue button'], '<hide continue button>', 'eval')
             self.find_fields_in(data['hide continue button'])
@@ -2469,24 +2471,24 @@ def __init__(self, orig_data, caller, **kwargs):
                 usedefs = [data['usedefs']]
             for usedef in usedefs:
                 if isinstance(usedef, (dict, list, set, bool)):
-                    raise DAError("A usedefs section must consist of a list of strings or a single string." + self.idebug(data))
+                    raise DASourceError("A usedefs section must consist of a list of strings or a single string." + self.idebug(data))
                 if usedef not in self.interview.defs:
-                    raise DAError('Referred to a non-existent def "' + usedef + '."  All defs must be defined before they are used.' + self.idebug(data))
+                    raise DASourceError('Referred to a non-existent def "' + usedef + '."  All defs must be defined before they are used.' + self.idebug(data))
                 defs.extend(self.interview.defs[usedef])
             definitions = "\n".join(defs) + "\n"
         else:
             definitions = ""
         if 'section' in data:
             if 'question' not in data:
-                raise DAError("You can only set the section from a question." + self.idebug(data))
+                raise DASourceError("You can only set the section from a question." + self.idebug(data))
             self.section = TextObject(definitions + str(data['section']), question=self)
         if 'continue button label' in data:
             if 'yesno' in data or 'noyes' in data or 'yesnomaybe' in data or 'noyesmaybe' in data or 'buttons' in data:
-                raise DAError("You cannot set a continue button label if the type of question is yesno, noyes, yesnomaybe, noyesmaybe, or buttons." + self.idebug(data))
+                raise DASourceError("You cannot set a continue button label if the type of question is yesno, noyes, yesnomaybe, noyesmaybe, or buttons." + self.idebug(data))
             self.continuelabel = TextObject(definitions + str(data['continue button label']), question=self)
         if 'resume button label' in data:
             if 'review' not in data:
-                raise DAError("You cannot set a resume button label if the type of question is not review." + self.idebug(data))
+                raise DASourceError("You cannot set a resume button label if the type of question is not review." + self.idebug(data))
             self.continuelabel = TextObject(definitions + str(data['resume button label']), question=self)
         if 'continue button color' in data:
             self.continuecolor = TextObject(definitions + str(data['continue button color']), question=self)
@@ -2498,12 +2500,12 @@ def __init__(self, orig_data, caller, **kwargs):
             self.cornerbackbuttonlabel = TextObject(definitions + str(data['corner back button label']), question=self)
         if 'skip undefined' in data:
             if 'review' not in data:
-                raise DAError("You cannot set the skip undefined directive if the type of question is not review." + self.idebug(data))
+                raise DASourceError("You cannot set the skip undefined directive if the type of question is not review." + self.idebug(data))
             if not data['skip undefined']:
                 self.skip_undefined = False
         if 'list collect' in data:
             if 'fields' not in data:
-                raise DAError("You cannot set list collect without a fields specifier." + self.idebug(data))
+                raise DASourceError("You cannot set list collect without a fields specifier." + self.idebug(data))
             if isinstance(data['list collect'], (str, bool)):
                 self.list_collect = compile(str(data['list collect']), '<list collect code>', 'eval')
             elif isinstance(data['list collect'], dict):
@@ -2522,14 +2524,14 @@ def __init__(self, orig_data, caller, **kwargs):
                 if 'add another label' in data['list collect']:
                     self.list_collect_add_another_label = TextObject(definitions + str(data['list collect']['add another label']), question=self)
             else:
-                raise DAError("Invalid data under list collect." + self.idebug(data))
+                raise DASourceError("Invalid data under list collect." + self.idebug(data))
         if 'mandatory' in data:
             if 'initial' in data:
-                raise DAError("You cannot use the mandatory modifier and the initial modifier at the same time." + self.idebug(data))
+                raise DASourceError("You cannot use the mandatory modifier and the initial modifier at the same time." + self.idebug(data))
             if 'id' not in data and self.interview.debug and self.interview.source.package.startswith('docassemble.playground'):
                 self.interview.issue['mandatory_id'] = True
             if 'question' not in data and 'code' not in data and 'objects' not in data and 'attachment' not in data and 'data' not in data and 'data from code' not in data:
-                raise DAError("You cannot use the mandatory modifier on this type of block." + self.idebug(data))
+                raise DASourceError("You cannot use the mandatory modifier on this type of block." + self.idebug(data))
             if data['mandatory'] is True:
                 self.is_mandatory = True
                 self.mandatory_code = None
@@ -2552,7 +2554,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 data['attachment options'] = [data['attachment options']]
             for attachment_option in data['attachment options']:
                 if not isinstance(attachment_option, dict):
-                    raise DAError("An attachment option must a dictionary." + self.idebug(data))
+                    raise DASourceError("An attachment option must a dictionary." + self.idebug(data))
                 for key in attachment_option:
                     value = attachment_option[key]
                     if key == 'initial yaml':
@@ -2564,7 +2566,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             the_list = [value]
                         for yaml_file in the_list:
                             if not isinstance(yaml_file, str):
-                                raise DAError('An initial yaml file must be a string.' + self.idebug(data))
+                                raise DASourceError('An initial yaml file must be a string.' + self.idebug(data))
                             self.interview.attachment_options['initial_yaml'].append(FileInPackage(yaml_file, 'template', self.package))
                     elif key == 'additional yaml':
                         if 'additional_yaml' not in self.interview.attachment_options:
@@ -2575,30 +2577,30 @@ def __init__(self, orig_data, caller, **kwargs):
                             the_list = [value]
                         for yaml_file in the_list:
                             if not isinstance(yaml_file, str):
-                                raise DAError('An additional yaml file must be a string.' + self.idebug(data))
+                                raise DASourceError('An additional yaml file must be a string.' + self.idebug(data))
                             self.interview.attachment_options['additional_yaml'].append(FileInPackage(yaml_file, 'template', self.package))
                     elif key == 'template file':
                         if not isinstance(value, str):
-                            raise DAError('The template file must be a string.' + self.idebug(data))
+                            raise DASourceError('The template file must be a string.' + self.idebug(data))
                         self.interview.attachment_options['template_file'] = FileInPackage(value, 'template', self.package)
                     elif key == 'rtf template file':
                         if not isinstance(value, str):
-                            raise DAError('The rtf template file must be a string.' + self.idebug(data))
+                            raise DASourceError('The rtf template file must be a string.' + self.idebug(data))
                         self.interview.attachment_options['rtf_template_file'] = FileInPackage(value, 'template', self.package)
                     elif key == 'docx reference file':
                         if not isinstance(value, str):
-                            raise DAError('The docx reference file must be a string.' + self.idebug(data))
+                            raise DASourceError('The docx reference file must be a string.' + self.idebug(data))
                         self.interview.attachment_options['docx_reference_file'] = FileInPackage(value, 'template', self.package)
         if 'script' in data:
             if not isinstance(data['script'], str):
-                raise DAError("A script section must be plain text." + self.idebug(data))
+                raise DASourceError("A script section must be plain text." + self.idebug(data))
             self.script = TextObject(definitions + DO_NOT_TRANSLATE + str(data['script']), question=self)
         if 'css' in data:
             if not isinstance(data['css'], str):
-                raise DAError("A css section must be plain text." + self.idebug(data))
+                raise DASourceError("A css section must be plain text." + self.idebug(data))
             self.css = TextObject(definitions + DO_NOT_TRANSLATE + str(data['css']), question=self)
         if 'initial' in data and 'code' not in data:
-            raise DAError("Only a code block can be marked as initial." + self.idebug(data))
+            raise DASourceError("Only a code block can be marked as initial." + self.idebug(data))
         if 'initial' in data or 'default role' in data:
             if 'default role' in data or data['initial'] is True:
                 self.is_initial = True
@@ -2641,10 +2643,10 @@ def __init__(self, orig_data, caller, **kwargs):
                         else:
                             self.other_fields_used.add(key)
                 else:
-                    raise DAError("An objects section cannot contain a nested list." + self.idebug(data))
+                    raise DASourceError("An objects section cannot contain a nested list." + self.idebug(data))
         if 'data' in data and 'variable name' in data:
             if not isinstance(data['variable name'], str):
-                raise DAError("A data block variable name must be plain text." + self.idebug(data))
+                raise DASourceError("A data block variable name must be plain text." + self.idebug(data))
             if self.scan_for_variables:
                 self.fields_used.add(data['variable name'].strip())
             else:
@@ -2669,7 +2671,7 @@ def __init__(self, orig_data, caller, **kwargs):
             self.fields.append(Field({'saveas': data['variable name'].strip(), 'type': 'data', 'data': self.recursive_dataobject(data['data'])}))
         if 'data from code' in data and 'variable name' in data:
             if not isinstance(data['variable name'], str):
-                raise DAError("A data from code block variable name must be plain text." + self.idebug(data))
+                raise DASourceError("A data from code block variable name must be plain text." + self.idebug(data))
             if self.scan_for_variables:
                 self.fields_used.add(data['variable name'])
             else:
@@ -2695,7 +2697,7 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'objects' in data:
             if not isinstance(data['objects'], list):
                 data['objects'] = [data['objects']]
-                # raise DAError("An objects section must be organized as a list." + self.idebug(data))
+                # raise DASourceError("An objects section must be organized as a list." + self.idebug(data))
             self.question_type = 'objects'
             self.objects = data['objects']
             for item in data['objects']:
@@ -2707,10 +2709,10 @@ def __init__(self, orig_data, caller, **kwargs):
                         else:
                             self.other_fields_used.add(key)
                 else:
-                    raise DAError("An objects section cannot contain a nested list." + self.idebug(data))
+                    raise DASourceError("An objects section cannot contain a nested list." + self.idebug(data))
         if 'id' in data:
             # if str(data['id']) in self.interview.ids_in_use:
-            #     raise DAError("The id " + str(data['id']) + " is already in use by another block.  Id names must be unique." + self.idebug(data))
+            #     raise DASourceError("The id " + str(data['id']) + " is already in use by another block.  Id names must be unique." + self.idebug(data))
             self.id = str(data['id']).strip()
             if self.interview.debug and self.interview.source.package.startswith('docassemble.playground') and self.id in self.interview.ids_in_use:
                 self.interview.issue['id_collision'] = self.id
@@ -2718,31 +2720,31 @@ def __init__(self, orig_data, caller, **kwargs):
             self.interview.questions_by_id[self.id] = self
         if 'ga id' in data:
             if not isinstance(data['ga id'], str):
-                raise DAError("A 'ga id' must refer to text." + self.idebug(data))
+                raise DASourceError("A 'ga id' must refer to text." + self.idebug(data))
             self.ga_id = TextObject(definitions + str(data['ga id']), question=self)
         if 'segment id' in data:
             if not isinstance(data['segment id'], str):
-                raise DAError("A 'segment id' must refer to text." + self.idebug(data))
+                raise DASourceError("A 'segment id' must refer to text." + self.idebug(data))
             if not hasattr(self, 'segment'):
                 self.segment = {'arguments': {}}
             self.segment['id'] = TextObject(definitions + str(data['segment id']), question=self)
         if 'segment' in data:
             if not isinstance(data['segment'], dict):
-                raise DAError("A 'segment' must refer to a dictionary." + self.idebug(data))
+                raise DASourceError("A 'segment' must refer to a dictionary." + self.idebug(data))
             if 'id' in data['segment']:
                 if not isinstance(data['segment']['id'], str):
-                    raise DAError("An 'id' under 'segment' must refer to text." + self.idebug(data))
+                    raise DASourceError("An 'id' under 'segment' must refer to text." + self.idebug(data))
                 if not hasattr(self, 'segment'):
                     self.segment = {'arguments': {}}
                 self.segment['id'] = TextObject(definitions + str(data['segment']['id']), question=self)
             if 'arguments' in data['segment']:
                 if not isinstance(data['segment']['arguments'], dict):
-                    raise DAError("An 'arguments' under 'segment' must refer to a dictionary." + self.idebug(data))
+                    raise DASourceError("An 'arguments' under 'segment' must refer to a dictionary." + self.idebug(data))
                 if not hasattr(self, 'segment'):
                     self.segment = {'arguments': {}}
                 for key, val in data['segment']['arguments'].items():
                     if not isinstance(val, (str, int, float, bool)):
-                        raise DAError("Each item under 'arguments' in a 'segment' must be plain text." + self.idebug(data))
+                        raise DASourceError("Each item under 'arguments' in a 'segment' must be plain text." + self.idebug(data))
                     self.segment['arguments'][key] = TextObject(definitions + str(val), question=self)
         if 'supersedes' in data:
             if not isinstance(data['supersedes'], list):
@@ -2753,16 +2755,16 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'order' in data:
             should_append = False
             if 'question' in data or 'code' in data or 'attachment' in data or 'attachments' in data or 'template' in data:
-                raise DAError("An 'order' block cannot be combined with another type of block." + self.idebug(data))
+                raise DASourceError("An 'order' block cannot be combined with another type of block." + self.idebug(data))
             if not isinstance(data['order'], list):
-                raise DAError("An 'order' block must be a list." + self.idebug(data))
+                raise DASourceError("An 'order' block must be a list." + self.idebug(data))
             self.interview.id_orderings.append({'type': "order", 'order': [str(x) for x in data['order']]})
         for key in ('image sets', 'images'):
             if key not in data:
                 continue
             should_append = False
             if not isinstance(data[key], dict):
-                raise DAError("The '" + key + "' section needs to be a dictionary, not a list or text." + self.idebug(data))
+                raise DASourceError("The '" + key + "' section needs to be a dictionary, not a list or text." + self.idebug(data))
             if key == 'images':
                 data[key] = {'unspecified': {'images': data[key]}}
             elif 'images' in data[key] and 'attribution' in data[key]:
@@ -2770,11 +2772,11 @@ def __init__(self, orig_data, caller, **kwargs):
             for setname, image_set in data[key].items():
                 if not isinstance(image_set, dict):
                     if key == 'image sets':
-                        raise DAError("Each item in the 'image sets' section needs to be a dictionary, not a list.  Each dictionary item should have an 'images' definition (which can be a dictionary or list) and an optional 'attribution' definition (which must be text)." + self.idebug(data))
-                    raise DAError("Each item in the 'images' section needs to be a dictionary, not a list." + self.idebug(data))
+                        raise DASourceError("Each item in the 'image sets' section needs to be a dictionary, not a list.  Each dictionary item should have an 'images' definition (which can be a dictionary or list) and an optional 'attribution' definition (which must be text)." + self.idebug(data))
+                    raise DASourceError("Each item in the 'images' section needs to be a dictionary, not a list." + self.idebug(data))
                 if 'attribution' in image_set:
                     if not isinstance(image_set['attribution'], str):
-                        raise DAError("An attribution in an 'image set' section cannot be a dictionary or a list." + self.idebug(data))
+                        raise DASourceError("An attribution in an 'image set' section cannot be a dictionary or a list." + self.idebug(data))
                     attribution = re.sub(r'\n', ' ', image_set['attribution'].strip())
                 else:
                     attribution = None
@@ -2785,8 +2787,8 @@ def __init__(self, orig_data, caller, **kwargs):
                         image_list = [image_set['images']]
                     else:
                         if key == 'image set':
-                            raise DAError("An 'images' definition in an 'image set' item must be a dictionary or a list." + self.idebug(data))
-                        raise DAError("An 'images' section must be a dictionary or a list." + self.idebug(data))
+                            raise DASourceError("An 'images' definition in an 'image set' item must be a dictionary or a list." + self.idebug(data))
+                        raise DASourceError("An 'images' section must be a dictionary or a list." + self.idebug(data))
                     for image in image_list:
                         if not isinstance(image, dict):
                             the_image = {str(image): str(image)}
@@ -2797,7 +2799,7 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'def' in data:
             should_append = False
             if not isinstance(data['def'], str):
-                raise DAError("A def name must be a string." + self.idebug(data))
+                raise DASourceError("A def name must be a string." + self.idebug(data))
             if data['def'] not in self.interview.defs:
                 self.interview.defs[data['def']] = []
             if 'mako' in data:
@@ -2806,15 +2808,15 @@ def __init__(self, orig_data, caller, **kwargs):
                 elif isinstance(data['mako'], list):
                     list_of_defs = data['mako']
                 else:
-                    raise DAError("A mako template definition must be a string or a list of strings." + self.idebug(data))
+                    raise DASourceError("A mako template definition must be a string or a list of strings." + self.idebug(data))
                 for definition in list_of_defs:
                     if not isinstance(definition, str):
-                        raise DAError("A mako template definition must be a string." + self.idebug(data))
+                        raise DASourceError("A mako template definition must be a string." + self.idebug(data))
                     self.interview.defs[data['def']].append(definition)
         if 'interview help' in data:
             should_append = False
             if isinstance(data['interview help'], list):
-                raise DAError("An interview help section must not be in the form of a list." + self.idebug(data))
+                raise DASourceError("An interview help section must not be in the form of a list." + self.idebug(data))
             if not isinstance(data['interview help'], dict):
                 data['interview help'] = {'content': str(data['interview help'])}
             audiovideo = []
@@ -2828,7 +2830,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 audiovideo = []
                 for the_item in the_list:
                     if isinstance(the_item, (list, dict)):
-                        raise DAError("An interview help audio section must be in the form of a text item or a list of text items." + self.idebug(data))
+                        raise DASourceError("An interview help audio section must be in the form of a text item or a list of text items." + self.idebug(data))
                     audiovideo.append({'text': TextObject(definitions + str(data['interview help']['audio']), question=self), 'package': self.package, 'type': 'audio'})
             if 'video' in data['interview help']:
                 if not isinstance(data['interview help']['video'], list):
@@ -2837,7 +2839,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     the_list = data['interview help']['video']
                 for the_item in the_list:
                     if isinstance(the_item, (list, dict)):
-                        raise DAError("An interview help video section must be in the form of a text item or a list of text items." + self.idebug(data))
+                        raise DASourceError("An interview help video section must be in the form of a text item or a list of text items." + self.idebug(data))
                     audiovideo.append({'text': TextObject(definitions + str(data['interview help']['video']), question=self), 'package': self.package, 'type': 'video'})
             if 'video' not in data['interview help'] and 'audio' not in data['interview help']:
                 audiovideo = None
@@ -2845,21 +2847,21 @@ def __init__(self, orig_data, caller, **kwargs):
                 if not isinstance(data['interview help']['heading'], (dict, list)):
                     help_heading = TextObject(definitions + str(data['interview help']['heading']), question=self)
                 else:
-                    raise DAError("A heading within an interview help section must be text, not a list or a dictionary." + self.idebug(data))
+                    raise DASourceError("A heading within an interview help section must be text, not a list or a dictionary." + self.idebug(data))
             else:
                 help_heading = None
             if 'content' in data['interview help']:
                 if not isinstance(data['interview help']['content'], (dict, list)):
                     help_content = TextObject(definitions + str(data['interview help']['content']), question=self)
                 else:
-                    raise DAError("Help content must be text, not a list or a dictionary." + self.idebug(data))
+                    raise DASourceError("Help content must be text, not a list or a dictionary." + self.idebug(data))
             else:
-                raise DAError("No content section was found in an interview help section." + self.idebug(data))
+                raise DASourceError("No content section was found in an interview help section." + self.idebug(data))
             if 'label' in data['interview help']:
                 if not isinstance(data['interview help']['label'], (dict, list)):
                     help_label = TextObject(definitions + str(data['interview help']['label']), question=self)
                 else:
-                    raise DAError("Help label must be text, not a list or a dictionary." + self.idebug(data))
+                    raise DASourceError("Help label must be text, not a list or a dictionary." + self.idebug(data))
             else:
                 help_label = None
             if self.language not in self.interview.helptext:
@@ -2868,7 +2870,7 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'default screen parts' in data:
             should_append = False
             if not isinstance(data['default screen parts'], dict):
-                raise DAError("A default screen parts block must be in the form of a dictionary." + self.idebug(data))
+                raise DASourceError("A default screen parts block must be in the form of a dictionary." + self.idebug(data))
             if self.language not in self.interview.default_screen_parts:
                 self.interview.default_screen_parts[self.language] = {}
             for key, content in data['default screen parts'].items():
@@ -2877,17 +2879,17 @@ def __init__(self, orig_data, caller, **kwargs):
                         del self.interview.default_screen_parts[self.language][key]
                 else:
                     if not (isinstance(key, str) and isinstance(content, str)):
-                        raise DAError("A default screen parts block must be a dictionary of text keys and text values." + self.idebug(data))
+                        raise DASourceError("A default screen parts block must be a dictionary of text keys and text values." + self.idebug(data))
                     self.interview.default_screen_parts[self.language][key] = TextObject(definitions + str(content.strip()), question=self)
         if 'default validation messages' in data:
             should_append = False
             if not isinstance(data['default validation messages'], dict):
-                raise DAError("A default validation messages block must be in the form of a dictionary." + self.idebug(data))
+                raise DASourceError("A default validation messages block must be in the form of a dictionary." + self.idebug(data))
             if self.language not in self.interview.default_validation_messages:
                 self.interview.default_validation_messages[self.language] = {}
             for validation_key, validation_message in data['default validation messages'].items():
                 if not (isinstance(validation_key, str) and isinstance(validation_message, str)):
-                    raise DAError("A validation messages block must be a dictionary of text keys and text values." + self.idebug(data))
+                    raise DASourceError("A validation messages block must be a dictionary of text keys and text values." + self.idebug(data))
                 self.interview.default_validation_messages[self.language][validation_key] = validation_message.strip()
         if 'generic object' in data:
             self.is_generic = True
@@ -2904,7 +2906,7 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'metadata' in data:
             for key in data:
                 if key not in ('metadata', 'comment'):
-                    raise DAError("A metadata directive cannot be mixed with other directives." + self.idebug(data))
+                    raise DASourceError("A metadata directive cannot be mixed with other directives." + self.idebug(data))
             should_append = False
             if isinstance(data['metadata'], dict):
                 data['metadata']['_origin_path'] = self.from_source.path
@@ -2913,7 +2915,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     self.interview.default_language = data['metadata']['default language']
                 self.interview.metadata.append(data['metadata'])
             else:
-                raise DAError("A metadata section must be organized as a dictionary." + self.idebug(data))
+                raise DASourceError("A metadata section must be organized as a dictionary." + self.idebug(data))
         if 'modules' in data:
             if isinstance(data['modules'], str):
                 data['modules'] = [data['modules']]
@@ -2926,7 +2928,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 self.question_type = 'modules'
                 self.module_list = data['modules']
             else:
-                raise DAError("A modules section must be organized as a list." + self.idebug(data))
+                raise DASourceError("A modules section must be organized as a list." + self.idebug(data))
         if 'reset' in data:
             # logmessage("Found a reset")
             if isinstance(data['reset'], str):
@@ -2935,7 +2937,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 self.question_type = 'reset'
                 self.reset_list = data['reset']
             else:
-                raise DAError("A reset section must be organized as a list." + self.idebug(data))
+                raise DASourceError("A reset section must be organized as a list." + self.idebug(data))
         if 'imports' in data:
             if isinstance(data['imports'], str):
                 data['imports'] = [data['imports']]
@@ -2943,16 +2945,16 @@ def __init__(self, orig_data, caller, **kwargs):
                 self.question_type = 'imports'
                 self.module_list = data['imports']
             else:
-                raise DAError("An imports section must be organized as a list." + self.idebug(data))
+                raise DASourceError("An imports section must be organized as a list." + self.idebug(data))
         if 'terms' in data and 'question' in data:
             if not isinstance(data['terms'], (dict, list)):
-                raise DAError("Terms must be organized as a dictionary or a list." + self.idebug(data))
+                raise DASourceError("Terms must be organized as a dictionary or a list." + self.idebug(data))
 
             if isinstance(data['terms'], dict):
                 data['terms'] = [data['terms']]
             for termitem in data['terms']:
                 if not isinstance(termitem, dict):
-                    raise DAError("A terms section organized as a list must be a list of dictionary items." + self.idebug(data))
+                    raise DASourceError("A terms section organized as a list must be a list of dictionary items." + self.idebug(data))
                 if len(termitem) == 2 and 'phrases' in termitem and isinstance(termitem['phrases'], list) and 'definition' in termitem:
                     termitems = [(phrase, termitem['definition']) for phrase in termitem['phrases']]
                 else:
@@ -2970,12 +2972,12 @@ def __init__(self, orig_data, caller, **kwargs):
                     self.terms[lower_term] = {'definition': TextObject(definitions + str(definition), question=self), 're': re_dict, 'alt_terms': alt_terms}
         if 'auto terms' in data and 'question' in data:
             if not isinstance(data['auto terms'], (dict, list)):
-                raise DAError("Terms must be organized as a dictionary or a list." + self.idebug(data))
+                raise DASourceError("Terms must be organized as a dictionary or a list." + self.idebug(data))
             if isinstance(data['auto terms'], dict):
                 data['auto terms'] = [data['auto terms']]
             for termitem in data['auto terms']:
                 if not isinstance(termitem, dict):
-                    raise DAError("A terms section organized as a list must be a list of dictionary items." + self.idebug(data))
+                    raise DASourceError("A terms section organized as a list must be a list of dictionary items." + self.idebug(data))
                 if len(termitem) == 2 and 'phrases' in termitem and isinstance(termitem['phrases'], list) and 'definition' in termitem:
                     termitems = [(phrase, termitem['definition']) for phrase in termitem['phrases']]
                 else:
@@ -3015,7 +3017,7 @@ def __init__(self, orig_data, caller, **kwargs):
                                         lower_other = re.sub(r'\s+', ' ', tr_tuple[0].lower())
                                         self.interview.terms[lang][tr_tuple[0]] = {'definition': definition_textobject.other_lang[lang][0], 're': re.compile(r"{(?i)(%s)(\|[^\}]*)?}" % (re.sub(r'\s', '\\\s+', lower_other),), re.IGNORECASE | re.DOTALL)}  # noqa: W605
                     else:
-                        raise DAError("A terms section organized as a list must be a list of dictionary items." + self.idebug(data))
+                        raise DASourceError("A terms section organized as a list must be a list of dictionary items." + self.idebug(data))
             elif isinstance(data['terms'], dict):
                 for term in data['terms']:
                     lower_term = re.sub(r'\s+', ' ', term.lower())
@@ -3030,7 +3032,7 @@ def __init__(self, orig_data, caller, **kwargs):
                                 lower_other = re.sub(r'\s+', ' ', tr_tuple[0].lower())
                                 self.interview.terms[lang][tr_tuple[0]] = {'definition': definition_textobject.other_lang[lang][0], 're': re.compile(r"{(?i)(%s)(\|[^\}]*)?}" % (re.sub(r'\s', '\\\s+', lower_other),), re.IGNORECASE | re.DOTALL)}  # noqa: W605
             else:
-                raise DAError("A terms section must be organized as a dictionary or a list." + self.idebug(data))
+                raise DASourceError("A terms section must be organized as a dictionary or a list." + self.idebug(data))
         if 'auto terms' in data and 'question' not in data:
             should_append = False
             if self.language not in self.interview.autoterms:
@@ -3055,7 +3057,7 @@ def __init__(self, orig_data, caller, **kwargs):
                                         lower_other = re.sub(r'\s+', ' ', tr_tuple[0].lower())
                                         self.interview.autoterms[lang][tr_tuple[0]] = {'definition': definition_textobject.other_lang[lang][0], 're': re.compile(r"{?(?i)\b(%s)\b}?" % (re.sub(r'\s', '\\\s+', lower_other),), re.IGNORECASE | re.DOTALL)}  # noqa: W605
                     else:
-                        raise DAError("An auto terms section organized as a list must be a list of dictionary items." + self.idebug(data))
+                        raise DASourceError("An auto terms section organized as a list must be a list of dictionary items." + self.idebug(data))
             elif isinstance(data['auto terms'], dict):
                 for term in data['auto terms']:
                     lower_term = re.sub(r'\s+', ' ', term.lower())
@@ -3070,7 +3072,7 @@ def __init__(self, orig_data, caller, **kwargs):
                                 lower_other = re.sub(r'\s+', ' ', tr_tuple[0].lower())
                                 self.interview.autoterms[lang][tr_tuple[0]] = {'definition': definition_textobject.other_lang[lang][0], 're': re.compile(r"{?(?i)\b(%s)\b}?" % (re.sub(r'\s', '\\\s+', lower_other),), re.IGNORECASE | re.DOTALL)}  # noqa: W605
             else:
-                raise DAError("An auto terms section must be organized as a dictionary or a list." + self.idebug(data))
+                raise DASourceError("An auto terms section must be organized as a dictionary or a list." + self.idebug(data))
         if 'default role' in data:
             if 'code' not in data:
                 should_append = False
@@ -3079,7 +3081,7 @@ def __init__(self, orig_data, caller, **kwargs):
             elif isinstance(data['default role'], list):
                 self.interview.default_role = data['default role']
             else:
-                raise DAError("A default role must be a list or a string." + self.idebug(data))
+                raise DASourceError("A default role must be a list or a string." + self.idebug(data))
         if 'role' in data:
             if isinstance(data['role'], str):
                 if data['role'] not in self.role:
@@ -3089,7 +3091,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     if data['role'] not in self.role:
                         self.role.append(rolename)
             else:
-                raise DAError("The role of a question must be a string or a list." + self.idebug(data))
+                raise DASourceError("The role of a question must be a string or a list." + self.idebug(data))
         else:
             self.role = []
         if 'include' in data:
@@ -3109,19 +3111,19 @@ def __init__(self, orig_data, caller, **kwargs):
                                     raise DANotFoundError('Question file ' + questionPath + ' not found')
                             self.interview.read_from(new_source)
                     except DANotFoundError:
-                        raise DAError('An include section could not find the file ' + str(questionPath) + '.' + self.idebug(data))
+                        raise DASourceError('An include section could not find the file ' + str(questionPath) + '.' + self.idebug(data))
             else:
-                raise DAError("An include section must be organized as a list." + self.idebug(data))
+                raise DASourceError("An include section must be organized as a list." + self.idebug(data))
         if 'action buttons' in data:
             if isinstance(data['action buttons'], dict) and len(data['action buttons']) == 1 and 'code' in data['action buttons']:
                 self.action_buttons.append(compile(data['action buttons']['code'], '<action buttons code>', 'eval'))
                 self.find_fields_in(data['action buttons']['code'])
             else:
                 if not isinstance(data['action buttons'], list):
-                    raise DAError("An action buttons specifier must be a list." + self.idebug(data))
+                    raise DASourceError("An action buttons specifier must be a list." + self.idebug(data))
                 for item in data['action buttons']:
                     if not isinstance(item, dict):
-                        raise DAError("An action buttons item must be a dictionary." + self.idebug(data))
+                        raise DASourceError("An action buttons item must be a dictionary." + self.idebug(data))
                     action = item.get('action', None)
                     target = item.get('new window', None)
                     if target is True:
@@ -3141,23 +3143,23 @@ def __init__(self, orig_data, caller, **kwargs):
                     forget_prior = item.get('forget prior', False)
                     given_arguments = item.get('arguments', {})
                     if not isinstance(action, str):
-                        raise DAError("An action buttons item must contain an action in plain text." + self.idebug(data))
+                        raise DASourceError("An action buttons item must contain an action in plain text." + self.idebug(data))
                     if not isinstance(target, (str, NoneType)):
-                        raise DAError("The new window specifier in an action buttons item must refer to True or plain text." + self.idebug(data))
+                        raise DASourceError("The new window specifier in an action buttons item must refer to True or plain text." + self.idebug(data))
                     if not isinstance(given_arguments, dict):
-                        raise DAError("The arguments specifier in an action buttons item must refer to a dictionary." + self.idebug(data))
+                        raise DASourceError("The arguments specifier in an action buttons item must refer to a dictionary." + self.idebug(data))
                     if not isinstance(label, str):
-                        raise DAError("An action buttons item must contain a label in plain text." + self.idebug(data))
+                        raise DASourceError("An action buttons item must contain a label in plain text." + self.idebug(data))
                     if not isinstance(color, str):
-                        raise DAError("The color specifier in an action buttons item must refer to plain text." + self.idebug(data))
+                        raise DASourceError("The color specifier in an action buttons item must refer to plain text." + self.idebug(data))
                     if not isinstance(icon, (str, NoneType)):
-                        raise DAError("The icon specifier in an action buttons item must refer to plain text." + self.idebug(data))
+                        raise DASourceError("The icon specifier in an action buttons item must refer to plain text." + self.idebug(data))
                     if not isinstance(placement, (str, NoneType)):
-                        raise DAError("The placement specifier in an action buttons item must refer to plain text." + self.idebug(data))
+                        raise DASourceError("The placement specifier in an action buttons item must refer to plain text." + self.idebug(data))
                     if not isinstance(css_class, (str, NoneType)):
-                        raise DAError("The css classifier specifier in an action buttons item must refer to plain text." + self.idebug(data))
+                        raise DASourceError("The css classifier specifier in an action buttons item must refer to plain text." + self.idebug(data))
                     if not isinstance(forget_prior, bool):
-                        raise DAError("The forget prior specifier in an action buttons item must refer to true or false." + self.idebug(data))
+                        raise DASourceError("The forget prior specifier in an action buttons item must refer to true or false." + self.idebug(data))
                     button = {'action': TextObject(definitions + action, question=self), 'label': TextObject(definitions + label, question=self), 'color': TextObject(definitions + color, question=self)}
                     button['show if'] = showif
                     if target is not None:
@@ -3183,7 +3185,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     button['arguments'] = {}
                     for key, val in given_arguments.items():
                         if isinstance(val, (list, dict)):
-                            raise DAError("The arguments specifier in an action buttons item must refer to plain items." + self.idebug(data))
+                            raise DASourceError("The arguments specifier in an action buttons item must refer to plain items." + self.idebug(data))
                         if isinstance(val, str):
                             button['arguments'][key] = TextObject(definitions + val, question=self)
                         else:
@@ -3198,10 +3200,10 @@ def __init__(self, orig_data, caller, **kwargs):
                 for x in data['if']:
                     self.find_fields_in(x)
             else:
-                raise DAError("An if statement must either be text or a list." + self.idebug(data))
+                raise DASourceError("An if statement must either be text or a list." + self.idebug(data))
         if 'validation code' in data:
             if not isinstance(data['validation code'], str):
-                raise DAError("A validation code statement must be text." + self.idebug(data))
+                raise DASourceError("A validation code statement must be text." + self.idebug(data))
             self.validation_code = compile(data['validation code'], f'<validation code, {self.id_debug(data)}>', 'exec')
             self.find_fields_in(data['validation code'])
         if 'require' in data:
@@ -3218,11 +3220,11 @@ def __init__(self, orig_data, caller, **kwargs):
                     if isinstance(data['orelse'], dict):
                         self.or_else_question = Question(data['orelse'], self.interview, register_target=register_target, source=self.from_source, package=self.package)
                     else:
-                        raise DAError("The orelse part of a require section must be organized as a dictionary." + self.idebug(data))
+                        raise DASourceError("The orelse part of a require section must be organized as a dictionary." + self.idebug(data))
                 else:
-                    raise DAError("A require section must have an orelse part." + self.idebug(data))
+                    raise DASourceError("A require section must have an orelse part." + self.idebug(data))
             else:
-                raise DAError("A require section must be organized as a list." + self.idebug(data))
+                raise DASourceError("A require section must be organized as a list." + self.idebug(data))
         if 'attachment' in data:
             self.attachments = self.process_attachment_list(data['attachment'])
         elif 'attachments' in data:
@@ -3260,7 +3262,7 @@ def __init__(self, orig_data, caller, **kwargs):
         #     elif isinstance(data['role'], str) and data['role'] not in self.role:
         #         self.role.append(data['role'])
         #     else:
-        #         raise DAError("A role section must be text or a list." + self.idebug(data))
+        #         raise DASourceError("A role section must be text or a list." + self.idebug(data))
         if 'progress' in data:
             if data['progress'] is None:
                 self.progress = -1
@@ -3338,11 +3340,11 @@ def __init__(self, orig_data, caller, **kwargs):
                 self.response_code = data['response code']
         if 'css class' in data:
             if 'question' not in data:
-                raise DAError("A css class can only accompany a question." + self.idebug(data))
+                raise DASourceError("A css class can only accompany a question." + self.idebug(data))
             self.css_class = TextObject(definitions + str(data['css class']), question=self)
         if 'table css class' in data:
             if 'question' not in data:
-                raise DAError("A table css class can only accompany a question." + self.idebug(data))
+                raise DASourceError("A table css class can only accompany a question." + self.idebug(data))
             self.table_css_class = TextObject(definitions + str(data['table css class']), question=self)
         if 'question' in data:
             self.content = TextObject(definitions + str(data['question']), question=self)
@@ -3366,7 +3368,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             the_list = value
                         for list_item in the_list:
                             if isinstance(list_item, (dict, list, set)):
-                                raise DAError("An audio declaration in a help block can only contain a text item or a list of text items." + self.idebug(data))
+                                raise DASourceError("An audio declaration in a help block can only contain a text item or a list of text items." + self.idebug(data))
                             if self.audiovideo is None:
                                 self.audiovideo = {}
                             if 'help' not in self.audiovideo:
@@ -3379,7 +3381,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             the_list = value
                         for list_item in the_list:
                             if isinstance(list_item, (dict, list, set)):
-                                raise DAError("A video declaration in a help block can only contain a text item or a list of text items." + self.idebug(data))
+                                raise DASourceError("A video declaration in a help block can only contain a text item or a list of text items." + self.idebug(data))
                             if self.audiovideo is None:
                                 self.audiovideo = {}
                             if 'help' not in self.audiovideo:
@@ -3387,7 +3389,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             self.audiovideo['help'].append({'text': TextObject(definitions + str(list_item.strip()), question=self), 'package': self.package, 'type': 'video'})
                     if key == 'content':
                         if isinstance(value, (dict, list, set)):
-                            raise DAError("A content declaration in a help block can only contain text." + self.idebug(data))
+                            raise DASourceError("A content declaration in a help block can only contain text." + self.idebug(data))
                         self.helptext = TextObject(definitions + str(value), question=self)
             else:
                 self.helptext = TextObject(definitions + str(data['help']), question=self)
@@ -3398,7 +3400,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 the_list = data['audio']
             for list_item in the_list:
                 if isinstance(list_item, (dict, list, set)):
-                    raise DAError("An audio declaration can only contain a text item or a list of text items." + self.idebug(data))
+                    raise DASourceError("An audio declaration can only contain a text item or a list of text items." + self.idebug(data))
                 if self.audiovideo is None:
                     self.audiovideo = {}
                 if 'question' not in self.audiovideo:
@@ -3411,7 +3413,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 the_list = data['video']
             for list_item in the_list:
                 if isinstance(list_item, (dict, list, set)):
-                    raise DAError("A video declaration can only contain a text item or a list of text items." + self.idebug(data))
+                    raise DASourceError("A video declaration can only contain a text item or a list of text items." + self.idebug(data))
                 if self.audiovideo is None:
                     self.audiovideo = {}
                 if 'question' not in self.audiovideo:
@@ -3455,7 +3457,7 @@ def __init__(self, orig_data, caller, **kwargs):
             else:
                 self.other_fields_used.add(data['signature'])
         elif 'required' in data:
-            raise DAError("The required modifier can only be used on a signature block" + self.idebug(data))
+            raise DASourceError("The required modifier can only be used on a signature block" + self.idebug(data))
         if 'question metadata' in data:
             self.question_metadata = recursive_textobject_or_primitive(data['question metadata'], self)
         if 'under' in data:
@@ -3469,12 +3471,12 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'check in' in data:
             self.interview.uses_action = True
             if isinstance(data['check in'], (dict, list, set)):
-                raise DAError("A check in event must be text or a list." + self.idebug(data))
+                raise DASourceError("A check in event must be text or a list." + self.idebug(data))
             self.checkin = str(data['check in'])
             self.names_used.add(str(data['check in']))
         if 'yesno' in data:
             if not isinstance(data['yesno'], str):
-                raise DAError("A yesno must refer to text." + self.idebug(data))
+                raise DASourceError("A yesno must refer to text." + self.idebug(data))
             self.fields.append(Field({'saveas': data['yesno'], 'boolean': 1}))
             if self.scan_for_variables:
                 self.fields_used.add(data['yesno'])
@@ -3483,7 +3485,7 @@ def __init__(self, orig_data, caller, **kwargs):
             self.question_type = 'yesno'
         if 'noyes' in data:
             if not isinstance(data['noyes'], str):
-                raise DAError("A noyes must refer to text." + self.idebug(data))
+                raise DASourceError("A noyes must refer to text." + self.idebug(data))
             self.fields.append(Field({'saveas': data['noyes'], 'boolean': -1}))
             if self.scan_for_variables:
                 self.fields_used.add(data['noyes'])
@@ -3492,7 +3494,7 @@ def __init__(self, orig_data, caller, **kwargs):
             self.question_type = 'noyes'
         if 'yesnomaybe' in data:
             if not isinstance(data['yesnomaybe'], str):
-                raise DAError("A yesnomaybe must refer to text." + self.idebug(data))
+                raise DASourceError("A yesnomaybe must refer to text." + self.idebug(data))
             self.fields.append(Field({'saveas': data['yesnomaybe'], 'threestate': 1}))
             if self.scan_for_variables:
                 self.fields_used.add(data['yesnomaybe'])
@@ -3501,7 +3503,7 @@ def __init__(self, orig_data, caller, **kwargs):
             self.question_type = 'yesnomaybe'
         if 'noyesmaybe' in data:
             if not isinstance(data['noyesmaybe'], str):
-                raise DAError("A noyesmaybe must refer to text." + self.idebug(data))
+                raise DASourceError("A noyesmaybe must refer to text." + self.idebug(data))
             self.fields.append(Field({'saveas': data['noyesmaybe'], 'threestate': -1}))
             if self.scan_for_variables:
                 self.fields_used.add(data['noyesmaybe'])
@@ -3515,7 +3517,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 for key in data['sets']:
                     self.fields_used.add(key)
             else:
-                raise DAError("A sets phrase must be text or a list." + self.idebug(data))
+                raise DASourceError("A sets phrase must be text or a list." + self.idebug(data))
         if 'event' in data:
             self.interview.uses_action = True
             if isinstance(data['event'], str):
@@ -3524,20 +3526,20 @@ def __init__(self, orig_data, caller, **kwargs):
                 for key in data['event']:
                     self.fields_used.add(key)
             else:
-                raise DAError("An event phrase must be text or a list." + self.idebug(data))
+                raise DASourceError("An event phrase must be text or a list." + self.idebug(data))
         if 'choices' in data or 'buttons' in data or 'dropdown' in data or 'combobox' in data:
             if 'field' in data:
                 uses_field = True
                 uses_continue_button_field = False
                 data['field'] = data['field'].strip()
                 if invalid_variable_name(data['field']):
-                    raise DAError("Missing or invalid variable name " + repr(data['field']) + "." + self.idebug(data))
+                    raise DASourceError("Missing or invalid variable name " + repr(data['field']) + "." + self.idebug(data))
             else:
                 uses_field = False
                 if 'continue button field' in data:
                     data['continue button field'] = data['continue button field'].strip()
                     if invalid_variable_name(data['continue button field']):
-                        raise DAError("Missing or invalid variable name " + repr(data['continue button field']) + "." + self.idebug(data))
+                        raise DASourceError("Missing or invalid variable name " + repr(data['continue button field']) + "." + self.idebug(data))
                     uses_continue_button_field = True
                 else:
                     uses_continue_button_field = False
@@ -3565,11 +3567,11 @@ def __init__(self, orig_data, caller, **kwargs):
                 self.question_variety = 'buttons'
             if 'validation messages' in data:
                 if not isinstance(data['validation messages'], dict):
-                    raise DAError("A validation messages indicator must be a dictionary." + self.idebug(data))
+                    raise DASourceError("A validation messages indicator must be a dictionary." + self.idebug(data))
                 field_data['validation messages'] = {}
                 for validation_key, validation_message in data['validation messages'].items():
                     if not (isinstance(validation_key, str) and isinstance(validation_message, str)):
-                        raise DAError("A validation messages indicator must be a dictionary of text keys and text values." + self.idebug(data))
+                        raise DASourceError("A validation messages indicator must be a dictionary of text keys and text values." + self.idebug(data))
                     field_data['validation messages'][validation_key] = TextObject(definitions + str(validation_message).strip(), question=self)
             if uses_field:
                 if self.scan_for_variables:
@@ -3597,7 +3599,7 @@ def __init__(self, orig_data, caller, **kwargs):
             self.question_type = 'multiple_choice'
         elif 'continue button field' in data and 'fields' not in data and 'yesno' not in data and 'noyes' not in data and 'yesnomaybe' not in data and 'noyesmaybe' not in data and 'signature' not in data:
             if not isinstance(data['continue button field'], str):
-                raise DAError("A continue button field must be plain text." + self.idebug(data))
+                raise DASourceError("A continue button field must be plain text." + self.idebug(data))
             if self.scan_for_variables:
                 self.fields_used.add(data['continue button field'])
             else:
@@ -3614,32 +3616,32 @@ def __init__(self, orig_data, caller, **kwargs):
             elif isinstance(data['need'], list):
                 need_list = data['need']
             else:
-                raise DAError("A need phrase must be text or a list." + self.idebug(data))
+                raise DASourceError("A need phrase must be text or a list." + self.idebug(data))
             pre_need_list = []
             post_need_list = []
             for item in need_list:
                 if isinstance(item, dict):
                     if not (('pre' in item and len(item) == 1) or ('post' in item and len(item) == 1) or ('pre' in item and 'post' in item and len(item) == 2)):
-                        raise DAError("If 'need' contains a dictionary it can only include keys 'pre' or 'post'." + self.idebug(data))
+                        raise DASourceError("If 'need' contains a dictionary it can only include keys 'pre' or 'post'." + self.idebug(data))
                     if 'post' in item:
                         if isinstance(item['post'], str):
                             post_need_list.append(item['post'])
                         elif isinstance(item['post'], list):
                             post_need_list.extend(item['post'])
                         else:
-                            raise DAError("A need post phrase must be text or a list." + self.idebug(data))
+                            raise DASourceError("A need post phrase must be text or a list." + self.idebug(data))
                     if 'pre' in item:
                         if isinstance(item['pre'], str):
                             pre_need_list.append(item['pre'])
                         elif isinstance(item['pre'], list):
                             pre_need_list.extend(item['pre'])
                         else:
-                            raise DAError("A need pre phrase must be text or a list." + self.idebug(data))
+                            raise DASourceError("A need pre phrase must be text or a list." + self.idebug(data))
                 else:
                     pre_need_list.append(item)
             for sub_item in pre_need_list + post_need_list:
                 if not isinstance(sub_item, str):
-                    raise DAError("In 'need', the items must be text strings." + self.idebug(data))
+                    raise DASourceError("In 'need', the items must be text strings." + self.idebug(data))
             if len(pre_need_list) > 0:
                 try:
                     self.need = list(map((lambda x: compile(x, '<need expression>', 'eval')), pre_need_list))
@@ -3670,18 +3672,18 @@ def __init__(self, orig_data, caller, **kwargs):
         if 'target' in data:
             self.interview.uses_action = True
             if isinstance(data['target'], (list, dict, set, bool, int, float)):
-                raise DAError("The target of a template must be plain text." + self.idebug(data))
+                raise DASourceError("The target of a template must be plain text." + self.idebug(data))
             if 'template' not in data:
-                raise DAError("A target directive can only be used with a template." + self.idebug(data))
+                raise DASourceError("A target directive can only be used with a template." + self.idebug(data))
             self.target = data['target']
         if 'table' in data or 'rows' in data or 'columns' in data:
             if 'table' not in data or 'rows' not in data or 'columns' not in data:
-                raise DAError("A table definition must have definitions for table, row, and column." + self.idebug(data))
+                raise DASourceError("A table definition must have definitions for table, row, and column." + self.idebug(data))
             if isinstance(data['rows'], (list, dict, set, bool, int, float)):
-                raise DAError("The row part of a table definition must be plain Python code." + self.idebug(data))
+                raise DASourceError("The row part of a table definition must be plain Python code." + self.idebug(data))
             data['rows'] = data['rows'].strip()
             if not isinstance(data['columns'], list):
-                raise DAError("The column part of a table definition must be a list." + self.idebug(data))
+                raise DASourceError("The column part of a table definition must be a list." + self.idebug(data))
             row = compile(data['rows'], '<row code>', 'eval')
             self.find_fields_in(data['rows'])
             header = []
@@ -3697,9 +3699,9 @@ def __init__(self, orig_data, caller, **kwargs):
                 not_available_label = 'n/a'
             for col in data['columns']:
                 if not isinstance(col, dict):
-                    raise DAError("The column items in a table definition must be dictionaries." + self.idebug(data))
+                    raise DASourceError("The column items in a table definition must be dictionaries." + self.idebug(data))
                 if len(col) == 0:
-                    raise DAError("A column item in a table definition cannot be empty." + self.idebug(data))
+                    raise DASourceError("A column item in a table definition cannot be empty." + self.idebug(data))
                 if 'header' in col and 'cell' in col:
                     header_text = col['header']
                     cell_text = str(col['cell']).strip()
@@ -3719,12 +3721,12 @@ def __init__(self, orig_data, caller, **kwargs):
                 is_editable = True
                 if isinstance(data['edit'], list):
                     if len(data['edit']) == 0:
-                        raise DAError("The edit directive must be a list of attributes, or True or False" + self.idebug(data))
+                        raise DASourceError("The edit directive must be a list of attributes, or True or False" + self.idebug(data))
                     for attribute_name in data['edit']:
                         if not isinstance(attribute_name, str):
-                            raise DAError("The edit directive must be a list of attribute names" + self.idebug(data))
+                            raise DASourceError("The edit directive must be a list of attribute names" + self.idebug(data))
                 elif not isinstance(data['edit'], bool):
-                    raise DAError("The edit directive must be a list of attributes, or True or False" + self.idebug(data))
+                    raise DASourceError("The edit directive must be a list of attributes, or True or False" + self.idebug(data))
                 keyword_args = ''
                 if 'delete buttons' in data and not data['delete buttons']:
                     keyword_args += ', delete=False'
@@ -3732,7 +3734,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     keyword_args += ', confirm=True'
                 if 'read only' in data:
                     if not isinstance(data['read only'], str):
-                        raise DAError("The read only directive must be plain text referring to an attribute" + self.idebug(data))
+                        raise DASourceError("The read only directive must be plain text referring to an attribute" + self.idebug(data))
                     keyword_args += ', read_only_attribute=' + repr(data['read only'].strip())
                 if isinstance(data['edit'], list):
                     column.append(compile('(' + data['rows'] + ').item_actions(row_item, row_index, ' + ', '.join([repr(y) for y in data['edit']]) + keyword_args + ', reorder=' + repr(reorder) + ', ensure_complete=' + repr(ensure_complete) + ')', '<edit code>', 'eval'))
@@ -3740,7 +3742,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     column.append(compile('(' + data['rows'] + ').item_actions(row_item, row_index' + keyword_args + ', reorder=' + repr(reorder) + ', ensure_complete=' + repr(ensure_complete) + ')', '<edit code>', 'eval'))
                 if 'edit header' in data:
                     if not isinstance(data['edit header'], str):
-                        raise DAError("The edit header directive must be text" + self.idebug(data))
+                        raise DASourceError("The edit header directive must be text" + self.idebug(data))
                     if data['edit header'] == '':
                         header.append(TextObject('&nbsp;'))
                     else:
@@ -3752,7 +3754,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 keyword_args = ''
                 if 'read only' in data:
                     if not isinstance(data['read only'], str):
-                        raise DAError("The read only directive must be plain text referring to an attribute" + self.idebug(data))
+                        raise DASourceError("The read only directive must be plain text referring to an attribute" + self.idebug(data))
                     keyword_args += ', read_only_attribute=' + repr(data['read only'].strip())
                 if 'confirm' in data and data['confirm']:
                     keyword_args += ', confirm=True'
@@ -3762,7 +3764,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     column.append(compile('(' + data['rows'] + ').item_actions(row_item, row_index, edit=False' + keyword_args + ', delete=False, reorder=' + repr(reorder) + ', ensure_complete=' + repr(ensure_complete) + ')', '<reorder buttons code>', 'eval'))
                 if 'edit header' in data:
                     if not isinstance(data['edit header'], str):
-                        raise DAError("The edit header directive must be text" + self.idebug(data))
+                        raise DASourceError("The edit header directive must be text" + self.idebug(data))
                     if data['edit header'] == '':
                         header.append(TextObject('&nbsp;'))
                     else:
@@ -3795,27 +3797,27 @@ def __init__(self, orig_data, caller, **kwargs):
                     self.find_fields_in(data['content file']['code'])
                     self.question_type = 'template_code'
                 else:
-                    raise DAError('A content file must be specified as text, as a list of text filenames, or as a dictionary with code as the key' + self.idebug(data))
+                    raise DASourceError('A content file must be specified as text, as a list of text filenames, or as a dictionary with code as the key' + self.idebug(data))
             else:
                 if not isinstance(data['content file'], list):
                     data['content file'] = [data['content file']]
                 data['content'] = ''
                 for content_file in data['content file']:
                     if not isinstance(content_file, str):
-                        raise DAError('A content file must be specified as text, as a list of text filenames, or as a dictionary with code as the key' + self.idebug(data))
+                        raise DASourceError('A content file must be specified as text, as a list of text filenames, or as a dictionary with code as the key' + self.idebug(data))
                     file_to_read = docassemble.base.functions.package_template_filename(content_file, package=self.package)
                     # if file_to_read is not None and get_mimetype(file_to_read) != 'text/markdown':
-                    #    raise DAError('The content file ' + str(data['content file']) + ' is not a markdown file ' + str(file_to_read) + self.idebug(data))
+                    #    raise DASourceError('The content file ' + str(data['content file']) + ' is not a markdown file ' + str(file_to_read) + self.idebug(data))
                     if file_to_read is not None and os.path.isfile(file_to_read) and os.access(file_to_read, os.R_OK):
                         with open(file_to_read, 'r', encoding='utf-8') as the_file:
                             data['content'] += the_file.read()
                     else:
-                        raise DAError('Unable to read content file ' + str(data['content file']) + ' after trying to find it at ' + str(file_to_read) + self.idebug(data))
+                        raise DASourceError('Unable to read content file ' + str(data['content file']) + ' after trying to find it at ' + str(file_to_read) + self.idebug(data))
         if 'template' in data and 'content' in data:
             if isinstance(data['template'], (list, dict)):
-                raise DAError("A template must designate a single variable expressed as text." + self.idebug(data))
+                raise DASourceError("A template must designate a single variable expressed as text." + self.idebug(data))
             if isinstance(data['content'], (list, dict)):
-                raise DAError("The content of a template must be expressed as text." + self.idebug(data))
+                raise DASourceError("The content of a template must be expressed as text." + self.idebug(data))
             if self.scan_for_variables:
                 self.fields_used.add(data['template'])
             else:
@@ -3848,10 +3850,10 @@ def __init__(self, orig_data, caller, **kwargs):
                     raise
                 self.find_fields_in(data['code'])
             else:
-                raise DAError("A code section must be text, not a list or a dictionary." + self.idebug(data))
+                raise DASourceError("A code section must be text, not a list or a dictionary." + self.idebug(data))
         if 'reconsider' in data:
             # if not isinstance(data['reconsider'], bool):
-            #    raise DAError("A reconsider directive must be true or false." + self.idebug(data))
+            #    raise DASourceError("A reconsider directive must be true or false." + self.idebug(data))
             if isinstance(data['reconsider'], bool):
                 if data['reconsider']:
                     if self.is_generic:
@@ -3866,10 +3868,10 @@ def __init__(self, orig_data, caller, **kwargs):
                 elif isinstance(data['reconsider'], list):
                     fields = data['reconsider']
                 else:
-                    raise DAError("A reconsider directive must be true, false, a single variable or a list." + self.idebug(data))
+                    raise DASourceError("A reconsider directive must be true, false, a single variable or a list." + self.idebug(data))
                 for the_field in fields:
                     if not isinstance(the_field, str):
-                        raise DAError("A reconsider directive must refer to variable names expressed as text." + self.idebug(data))
+                        raise DASourceError("A reconsider directive must refer to variable names expressed as text." + self.idebug(data))
                     self.find_fields_in(the_field)
                     self.reconsider.append(the_field)
         if 'undefine' in data:
@@ -3878,15 +3880,15 @@ def __init__(self, orig_data, caller, **kwargs):
             elif isinstance(data['undefine'], list):
                 fields = data['undefine']
             else:
-                raise DAError("A undefine directive must a single variable or a list." + self.idebug(data))
+                raise DASourceError("A undefine directive must a single variable or a list." + self.idebug(data))
             for the_field in fields:
                 if not isinstance(the_field, str):
-                    raise DAError("A undefine directive must refer to variable names expressed as text." + self.idebug(data))
+                    raise DASourceError("A undefine directive must refer to variable names expressed as text." + self.idebug(data))
                 self.find_fields_in(the_field)
                 self.undefine.append(the_field)
         if 'continue button field' in data and 'question' in data and ('field' in data or 'fields' in data or 'yesno' in data or 'noyes' in data or 'yesnomaybe' in data or 'noyesmaybe' in data or 'signature' in data):
             if not isinstance(data['continue button field'], str):
-                raise DAError("A continue button field must be plain text." + self.idebug(data))
+                raise DASourceError("A continue button field must be plain text." + self.idebug(data))
             if self.scan_for_variables:
                 self.fields_used.add(data['continue button field'])
             else:
@@ -3897,12 +3899,12 @@ def __init__(self, orig_data, caller, **kwargs):
             if isinstance(data['fields'], dict):
                 data['fields'] = [data['fields']]
             if not isinstance(data['fields'], list):
-                raise DAError("The fields must be written in the form of a list." + self.idebug(data))
+                raise DASourceError("The fields must be written in the form of a list." + self.idebug(data))
             field_number = 0
             for field in data['fields']:
                 docassemble.base.functions.this_thread.misc['current_field'] = field_number
                 if not isinstance(field, dict):
-                    raise DAError("Each individual field in a list of fields must be expressed as a dictionary item, e.g., ' - Fruit: user.favorite_fruit'." + self.idebug(data))
+                    raise DASourceError("Each individual field in a list of fields must be expressed as a dictionary item, e.g., ' - Fruit: user.favorite_fruit'." + self.idebug(data))
                 manual_keys = set()
                 field_info = {'type': 'text', 'number': field_number}
                 custom_data_type = False
@@ -3910,7 +3912,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     if 'field' in field and 'label' not in field:
                         field['label'] = 'hidden'
                     if field.get('datatype', None) in ['file', 'files', 'camera', 'user', 'environment', 'camcorder', 'microphone']:
-                        raise DAError("Invalid datatype of hidden field." + self.idebug(data))
+                        raise DASourceError("Invalid datatype of hidden field." + self.idebug(data))
                 if 'choices' in field and isinstance(field['choices'], dict) and len(field['choices']) == 1 and 'code' in field['choices']:
                     field['code'] = field['choices']['code']
                     del field['choices']
@@ -3928,18 +3930,18 @@ def __init__(self, orig_data, caller, **kwargs):
                         field['input type'] = 'hidden'
                         field['datatype'] = 'text'
                     if field['datatype'] in ('object', 'object_radio', 'multiselect', 'object_multiselect', 'checkboxes', 'object_checkboxes') and not ('choices' in field or 'code' in field):
-                        raise DAError("A multiple choice field must refer to a list of choices." + self.idebug(data))
+                        raise DASourceError("A multiple choice field must refer to a list of choices." + self.idebug(data))
                     if field['datatype'] in docassemble.base.functions.custom_types and field['datatype'] not in standard_types:
                         custom_data_type = True
                         self.interview.custom_data_types.add(field['datatype'])
                 if 'input type' in field:
                     if field['input type'] == 'ajax':
                         if 'action' not in field:
-                            raise DAError("An ajax field must have an associated action." + self.idebug(data))
+                            raise DASourceError("An ajax field must have an associated action." + self.idebug(data))
                         if 'choices' in field or 'code' in field:
-                            raise DAError("An ajax field cannot contain a list of choices except through an action." + self.idebug(data))
+                            raise DASourceError("An ajax field cannot contain a list of choices except through an action." + self.idebug(data))
                     if field['input type'] in ('radio', 'combobox', 'pulldown') and not ('choices' in field or 'code' in field):
-                        raise DAError("A multiple choice field must refer to a list of choices." + self.idebug(data))
+                        raise DASourceError("A multiple choice field must refer to a list of choices." + self.idebug(data))
                 if len(field) == 1 and 'code' in field:
                     field_info['type'] = 'fields_code'
                     self.find_fields_in(field['code'])
@@ -3950,9 +3952,9 @@ def __init__(self, orig_data, caller, **kwargs):
                         del docassemble.base.functions.this_thread.misc['current_field']
                     continue
                 if 'object labeler' in field and ('datatype' not in field or not field['datatype'].startswith('object')):
-                    raise DAError("An object labeler can only be used with an object data type")
+                    raise DASourceError("An object labeler can only be used with an object data type." + self.idebug(data))
                 if ('note' in field and 'html' in field) or ('note' in field and 'raw html' in field) or ('html' in field and 'raw html' in field):
-                    raise DAError("You cannot combine note, html, and/or raw html in a single field." + self.idebug(data))
+                    raise DASourceError("You cannot combine note, html, and/or raw html in a single field." + self.idebug(data))
                 for key in field:
                     if key == 'default' and 'datatype' in field and field['datatype'] in ('object', 'object_radio', 'object_multiselect', 'object_checkboxes'):
                         continue
@@ -3996,11 +3998,11 @@ def __init__(self, orig_data, caller, **kwargs):
                                 self.find_fields_in(field[key])
                     elif key == 'validation messages':
                         if not isinstance(field[key], dict):
-                            raise DAError("A validation messages indicator must be a dictionary." + self.idebug(data))
+                            raise DASourceError("A validation messages indicator must be a dictionary." + self.idebug(data))
                         field_info['validation messages'] = {}
                         for validation_key, validation_message in field[key].items():
                             if not (isinstance(validation_key, str) and isinstance(validation_message, str)):
-                                raise DAError("A validation messages indicator must be a dictionary of text keys and text values." + self.idebug(data))
+                                raise DASourceError("A validation messages indicator must be a dictionary of text keys and text values." + self.idebug(data))
                             field_info['validation messages'][validation_key] = TextObject(definitions + str(validation_message).strip(), question=self)
                     elif key == 'validate':
                         field_info['validate'] = {'compute': compile(field[key], '<validate code>', 'eval'), 'sourcecode': field[key]}
@@ -4027,7 +4029,7 @@ def __init__(self, orig_data, caller, **kwargs):
                         if isinstance(field[key], list):
                             for item in field[key]:
                                 if not isinstance(item, str):
-                                    raise DAError("An allow privileges specifier must be a list of plain text items or code." + self.idebug(data))
+                                    raise DASourceError("An allow privileges specifier must be a list of plain text items or code." + self.idebug(data))
                             field_info['allow_privileges'] = field[key]
                         elif isinstance(field[key], str):
                             field_info['allow_privileges'] = [field[key]]
@@ -4035,12 +4037,12 @@ def __init__(self, orig_data, caller, **kwargs):
                             field_info['allow_privileges'] = {'compute': compile(field[key]['code'], '<allow privileges code>', 'eval'), 'sourcecode': field[key]['code']}
                             self.find_fields_in(field[key]['code'])
                         else:
-                            raise DAError("An allow privileges specifier must be a list of plain text items or code." + self.idebug(data))
+                            raise DASourceError("An allow privileges specifier must be a list of plain text items or code." + self.idebug(data))
                     elif key == 'allow users' and 'datatype' in field and field['datatype'] in ('file', 'files', 'camera', 'user', 'environment'):
                         if isinstance(field[key], list):
                             for item in field[key]:
                                 if not isinstance(item, (str, int)):
-                                    raise DAError("An allow users specifier must be a list of integers and plain text items or code." + self.idebug(data))
+                                    raise DASourceError("An allow users specifier must be a list of integers and plain text items or code." + self.idebug(data))
                             field_info['allow_users'] = field[key]
                         elif isinstance(field[key], str):
                             field_info['allow_users'] = [field[key]]
@@ -4048,7 +4050,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             field_info['allow_users'] = {'compute': compile(field[key]['code'], '<allow users code>', 'eval'), 'sourcecode': field[key]['code']}
                             self.find_fields_in(field[key]['code'])
                         else:
-                            raise DAError("An allow users specifier must be a list of integers and plain text items or code." + self.idebug(data))
+                            raise DASourceError("An allow users specifier must be a list of integers and plain text items or code." + self.idebug(data))
                     elif key == 'persistent' and 'datatype' in field and field['datatype'] in ('file', 'files', 'camera', 'user', 'environment'):
                         if isinstance(field[key], bool):
                             field_info['persistent'] = field[key]
@@ -4086,7 +4088,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             self.find_fields_in(field[key])
                     elif key in ('js show if', 'js hide if'):
                         if not isinstance(field[key], str):
-                            raise DAError("A js show if or js hide if expression must be a string" + self.idebug(data))
+                            raise DASourceError("A js show if or js hide if expression must be a string" + self.idebug(data))
                         js_info = {}
                         if key == 'js show if':
                             js_info['sign'] = True
@@ -4100,7 +4102,7 @@ def __init__(self, orig_data, caller, **kwargs):
                         field_info['extras']['show_if_js'] = js_info
                     elif key in ('js disable if', 'js enable if'):
                         if not isinstance(field[key], str):
-                            raise DAError("A js disable if or js enable if expression must be a string" + self.idebug(data))
+                            raise DASourceError("A js disable if or js enable if expression must be a string" + self.idebug(data))
                         js_info = {}
                         if key == 'js enable if':
                             js_info['sign'] = True
@@ -4119,16 +4121,16 @@ def __init__(self, orig_data, caller, **kwargs):
                                     this_is_code = (isinstance(field[key], dict) and len(field[key]) == 1 and 'code' in field[key])
                                     other_is_code = (isinstance(field[other_key], dict) and len(field[other_key]) == 1 and 'code' in field[other_key])
                                     if this_is_code == other_is_code:
-                                        raise DAError(key + " cannot be combined with " + other_key)
+                                        raise DASourceError(key + " cannot be combined with " + other_key + "." + self.idebug(data))
                         if 'extras' not in field_info:
                             field_info['extras'] = {}
                         if isinstance(field[key], dict):
                             showif_valid = False
                             if 'variable' in field[key] and 'is' in field[key]:
                                 if 'js show if' in field or 'js hide if' in field:
-                                    raise DAError("You cannot mix js show if and non-js show if" + self.idebug(data))
+                                    raise DASourceError("You cannot mix js show if and non-js show if" + self.idebug(data))
                                 if 'js disable if' in field or 'js enable if' in field:
-                                    raise DAError("You cannot mix js disable if and non-js show if" + self.idebug(data))
+                                    raise DASourceError("You cannot mix js disable if and non-js show if" + self.idebug(data))
                                 field_info['extras']['show_if_var'] = safeid(field[key]['variable'].strip())
                                 if isinstance(field[key]['is'], str):
                                     field_info['extras']['show_if_val'] = TextObject(definitions + str(field[key]['is']).strip(), question=self)
@@ -4140,14 +4142,14 @@ def __init__(self, orig_data, caller, **kwargs):
                                 self.find_fields_in(field[key]['code'])
                                 showif_valid = True
                             if not showif_valid:
-                                raise DAError("The keys of '" + key + "' must be 'variable' and 'is,' or 'code.'" + self.idebug(data))
+                                raise DASourceError("The keys of '" + key + "' must be 'variable' and 'is,' or 'code.'" + self.idebug(data))
                         elif isinstance(field[key], list):
-                            raise DAError("The keys of '" + key + "' cannot be a list" + self.idebug(data))
+                            raise DASourceError("The keys of '" + key + "' cannot be a list" + self.idebug(data))
                         elif isinstance(field[key], str):
                             field_info['extras']['show_if_var'] = safeid(field[key].strip())
                             field_info['extras']['show_if_val'] = TextObject('True')
                         else:
-                            raise DAError("Invalid variable name in show if/hide if")
+                            raise DASourceError("Invalid variable name in show if/hide if." + self.idebug(data))
                         exclusive = False
                         if isinstance(field[key], dict) and 'code' in field[key]:
                             if len(field[key]) == 1:
@@ -4173,16 +4175,16 @@ def __init__(self, orig_data, caller, **kwargs):
                                     this_is_code = (isinstance(field[key], dict) and len(field[key]) == 1 and 'code' in field[key])
                                     other_is_code = (isinstance(field[other_key], dict) and len(field[other_key]) == 1 and 'code' in field[other_key])
                                     if this_is_code == other_is_code:
-                                        raise DAError(key + " cannot be combined with " + other_key)
+                                        raise DASourceError(key + " cannot be combined with " + other_key + "." + self.idebug(data))
                         if 'extras' not in field_info:
                             field_info['extras'] = {}
                         if isinstance(field[key], dict):
                             showif_valid = False
                             if 'variable' in field[key] and 'is' in field[key]:
                                 if 'js show if' in field or 'js hide if' in field:
-                                    raise DAError("You cannot mix js show if and non-js disable if" + self.idebug(data))
+                                    raise DASourceError("You cannot mix js show if and non-js disable if." + self.idebug(data))
                                 if 'js disable if' in field or 'js enable if' in field:
-                                    raise DAError("You cannot mix js disable if and non-js disable if" + self.idebug(data))
+                                    raise DASourceError("You cannot mix js disable if and non-js disable if." + self.idebug(data))
                                 field_info['extras']['show_if_var'] = safeid(field[key]['variable'].strip())
                                 if isinstance(field[key]['is'], str):
                                     field_info['extras']['show_if_val'] = TextObject(definitions + str(field[key]['is']).strip(), question=self)
@@ -4194,14 +4196,14 @@ def __init__(self, orig_data, caller, **kwargs):
                                 self.find_fields_in(field[key]['code'])
                                 showif_valid = True
                             if not showif_valid:
-                                raise DAError("The keys of '" + key + "' must be 'variable' and 'is,' or 'code.'" + self.idebug(data))
+                                raise DASourceError("The keys of '" + key + "' must be 'variable' and 'is,' or 'code.'" + self.idebug(data))
                         elif isinstance(field[key], list):
-                            raise DAError("The keys of '" + key + "' cannot be a list" + self.idebug(data))
+                            raise DASourceError("The keys of '" + key + "' cannot be a list" + self.idebug(data))
                         elif isinstance(field[key], str):
                             field_info['extras']['show_if_var'] = safeid(field[key].strip())
                             field_info['extras']['show_if_val'] = TextObject('True')
                         else:
-                            raise DAError("Invalid variable name in " + key)
+                            raise DASourceError("Invalid variable name in " + key + '.' + self.idebug(data))
                         exclusive = False
                         if isinstance(field[key], dict) and 'code' in field[key]:
                             if len(field[key]) == 1:
@@ -4241,19 +4243,19 @@ def __init__(self, orig_data, caller, **kwargs):
                                     auto_determine_type(field_info, the_value=field[key])
                     elif key == 'disable others':
                         if 'datatype' in field and field['datatype'] in ('file', 'files', 'range', 'multiselect', 'checkboxes', 'camera', 'user', 'environment', 'camcorder', 'microphone', 'object_multiselect', 'object_checkboxes'):  # 'yesno', 'yesnowide', 'noyes', 'noyeswide',
-                            raise DAError("A 'disable others' directive cannot be used with this data type." + self.idebug(data))
+                            raise DASourceError("A 'disable others' directive cannot be used with this data type." + self.idebug(data))
                         if not isinstance(field[key], (list, bool)):
-                            raise DAError("A 'disable others' directive must be True, False, or a list of variable names." + self.idebug(data))
+                            raise DASourceError("A 'disable others' directive must be True, False, or a list of variable names." + self.idebug(data))
                         field_info['disable others'] = field[key]
                         if field[key] is not False:
                             field_info['required'] = False
                     elif key == 'uncheck others' and 'datatype' in field and field['datatype'] in ('yesno', 'yesnowide', 'noyes', 'noyeswide'):
                         if not isinstance(field[key], (list, bool)):
-                            raise DAError("An 'uncheck others' directive must be True, False, or a list of variable names." + self.idebug(data))
+                            raise DASourceError("An 'uncheck others' directive must be True, False, or a list of variable names." + self.idebug(data))
                         field_info['uncheck others'] = field[key]
                     elif key == 'check others' and 'datatype' in field and field['datatype'] in ('yesno', 'yesnowide', 'noyes', 'noyeswide'):
                         if not isinstance(field[key], (list, bool)):
-                            raise DAError("A 'check others' directive must be True, False, or a list of variable names." + self.idebug(data))
+                            raise DASourceError("A 'check others' directive must be True, False, or a list of variable names." + self.idebug(data))
                         field_info['check others'] = field[key]
                     elif key == 'datatype':
                         field_info['type'] = field[key]
@@ -4262,7 +4264,7 @@ def __init__(self, orig_data, caller, **kwargs):
                         if field[key] == 'range' and 'required' not in field_info:
                             field_info['required'] = False
                         if field[key] == 'range' and not ('min' in field and 'max' in field):
-                            raise DAError("If the datatype of a field is 'range', you must provide a min and a max." + self.idebug(data))
+                            raise DASourceError("If the datatype of a field is 'range', you must provide a min and a max." + self.idebug(data))
                         if field[key] in ('yesno', 'yesnowide', 'yesnoradio'):
                             field_info['boolean'] = 1
                         elif field[key] in ('noyes', 'noyeswide', 'noyesradio'):
@@ -4278,7 +4280,7 @@ def __init__(self, orig_data, caller, **kwargs):
                         self.find_fields_in(field[key])
                         if 'exclude' in field:
                             if isinstance(field['exclude'], dict):
-                                raise DAError("An exclude entry cannot be a dictionary." + self.idebug(data))
+                                raise DASourceError("An exclude entry cannot be a dictionary." + self.idebug(data))
                             if not isinstance(field['exclude'], list):
                                 field_info['selections']['exclude'] = [compile(field['exclude'], '<expression>', 'eval')]
                                 self.find_fields_in(field['exclude'])
@@ -4294,7 +4296,7 @@ def __init__(self, orig_data, caller, **kwargs):
                         elif isinstance(field[key], dict):
                             field_info['address_autocomplete'] = field[key]
                         elif isinstance(field[key], list):
-                            raise DAError("address autocomplete must be a Python expression, a dictionary, or a boolean value." + self.idebug(data))
+                            raise DASourceError("address autocomplete must be a Python expression, a dictionary, or a boolean value." + self.idebug(data))
                         else:
                             field_info['address_autocomplete'] = bool(field[key])
                     elif key == 'label above field':
@@ -4308,12 +4310,12 @@ def __init__(self, orig_data, caller, **kwargs):
                         if isinstance(field[key], (str, int)):
                             field[key] = {'width': field[key]}
                         if not isinstance(field[key], dict) or len(field[key]) == 0:
-                            raise DAError(key + " is not in the correct format." + self.idebug(data))
+                            raise DASourceError(key + " is not in the correct format." + self.idebug(data))
                         for item in field[key].keys():
                             if item not in ('width', 'label width', 'offset', 'start', 'end', 'breakpoint'):
-                                raise DAError(key + " has an invalid key " + repr(item) + "." + self.idebug(data))
+                                raise DASourceError(key + " has an invalid key " + repr(item) + "." + self.idebug(data))
                         if 'width' not in field[key]:
-                            raise DAError(key + ' must specify a width.' + self.idebug(data))
+                            raise DASourceError(key + ' must specify a width.' + self.idebug(data))
                         for subkey in ('width', 'label width', 'offset'):
                             if subkey in field[key]:
                                 if isinstance(field[key][subkey], str):
@@ -4322,7 +4324,7 @@ def __init__(self, orig_data, caller, **kwargs):
                                 elif isinstance(field[key][subkey], int):
                                     field_info[key][subkey] = field[key][subkey]
                                 else:
-                                    raise DAError(key + " " + subkey + " must be a number between 1 and 12, or a Python expression." + self.idebug(data))
+                                    raise DASourceError(key + " " + subkey + " must be a number between 1 and 12, or a Python expression." + self.idebug(data))
                         for subkey in ('start', 'end'):
                             if subkey in field[key]:
                                 if isinstance(field[key][subkey], str):
@@ -4331,7 +4333,7 @@ def __init__(self, orig_data, caller, **kwargs):
                                 elif isinstance(field[key][subkey], (bool, NoneType)):
                                     field_info[key][subkey] = field[key][subkey]
                                 else:
-                                    raise DAError(key + " " + subkey + " must be True or False, or a Python expression." + self.idebug(data))
+                                    raise DASourceError(key + " " + subkey + " must be True or False, or a Python expression." + self.idebug(data))
                         if 'breakpoint' in field[key]:
                             field_info[key]['breakpoint'] = TextObject(DO_NOT_TRANSLATE + str(field[key]['breakpoint']), question=self)
                     elif key == 'item grid':
@@ -4339,19 +4341,19 @@ def __init__(self, orig_data, caller, **kwargs):
                         if isinstance(field[key], (str, int)):
                             field[key] = {'width': field[key]}
                         if not isinstance(field[key], dict) or len(field[key]) == 0:
-                            raise DAError(key + " is not in the correct format." + self.idebug(data))
+                            raise DASourceError(key + " is not in the correct format." + self.idebug(data))
                         for item in field[key].keys():
                             if item not in ('width', 'breakpoint'):
-                                raise DAError(key + " has an invalid key " + repr(item) + "." + self.idebug(data))
+                                raise DASourceError(key + " has an invalid key " + repr(item) + "." + self.idebug(data))
                         if 'width' not in field[key]:
-                            raise DAError(key + ' must specify a width.' + self.idebug(data))
+                            raise DASourceError(key + ' must specify a width.' + self.idebug(data))
                         if isinstance(field[key]['width'], str):
                             field_info[key]['width'] = compile(field[key]['width'], '<' + key + ' width expression>', 'eval')
                             self.find_fields_in(field[key]['width'])
                         elif isinstance(field[key]['width'], int):
                             field_info[key]['width'] = field[key]['width']
                         else:
-                            raise DAError(key + " width must be a number between 1 and 12, or a Python expression." + self.idebug(data))
+                            raise DASourceError(key + " width must be a number between 1 and 12, or a Python expression." + self.idebug(data))
                         if 'breakpoint' in field[key]:
                             field_info[key]['breakpoint'] = TextObject(DO_NOT_TRANSLATE + str(field[key]['breakpoint']), question=self)
                     elif key == 'floating label':
@@ -4362,13 +4364,13 @@ def __init__(self, orig_data, caller, **kwargs):
                             field_info['floating_label'] = bool(field[key])
                     elif key == 'action' and 'input type' in field and field['input type'] == 'ajax':
                         if not isinstance(field[key], str):
-                            raise DAError("An action must be plain text" + self.idebug(data))
+                            raise DASourceError("An action must be plain text" + self.idebug(data))
                         if 'combobox action' not in field_info:
                             field_info['combobox action'] = {'trig': 4}
                         field_info['combobox action']['action'] = field[key]
                     elif key == 'trigger at' and 'action' in field and 'input type' in field and field['input type'] == 'ajax':
                         if (not isinstance(field[key], int)) or field[key] < 2:
-                            raise DAError("A trigger at must an integer greater than one" + self.idebug(data))
+                            raise DASourceError("A trigger at must an integer greater than one" + self.idebug(data))
                         if 'combobox action' not in field_info:
                             field_info['combobox action'] = {}
                         field_info['combobox action']['trig'] = field[key]
@@ -4378,7 +4380,7 @@ def __init__(self, orig_data, caller, **kwargs):
                         if 'datatype' in field and field['datatype'] in ('object', 'object_radio', 'object_multiselect', 'object_checkboxes'):
                             field_info['choicetype'] = 'compute'
                             if not isinstance(field[key], (list, str)):
-                                raise DAError("choices is not in appropriate format" + self.idebug(data))
+                                raise DASourceError("choices is not in appropriate format" + self.idebug(data))
                             field_info['selections'] = {}
                         else:
                             field_info['choicetype'] = 'manual'
@@ -4393,7 +4395,7 @@ def __init__(self, orig_data, caller, **kwargs):
                                     manual_keys.add(item['key'])
                         if 'exclude' in field:
                             if isinstance(field['exclude'], dict):
-                                raise DAError("An exclude entry cannot be a dictionary." + self.idebug(data))
+                                raise DASourceError("An exclude entry cannot be a dictionary." + self.idebug(data))
                             if not isinstance(field['exclude'], list):
                                 self.find_fields_in(field['exclude'])
                                 field_info['selections']['exclude'] = [compile(field['exclude'].strip(), '<expression>', 'eval')]
@@ -4436,26 +4438,26 @@ def __init__(self, orig_data, caller, **kwargs):
                             field_info['nota'] = TextObject(definitions + interpret_label(field[key]), question=self)
                     elif key == 'field':
                         if 'label' not in field:
-                            raise DAError("If you use 'field' to indicate a variable in a 'fields' section, you must also include a 'label.'" + self.idebug(data))
+                            raise DASourceError("If you use 'field' to indicate a variable in a 'fields' section, you must also include a 'label.'" + self.idebug(data))
                         if not isinstance(field[key], str):
-                            raise DAError("Fields in a 'field' section must be plain text." + self.idebug(data))
+                            raise DASourceError("Fields in a 'field' section must be plain text." + self.idebug(data))
                         field[key] = field[key].strip()
                         if invalid_variable_name(field[key]):
-                            raise DAError("Missing or invalid variable name " + repr(field[key]) + "." + self.idebug(data))
+                            raise DASourceError("Missing or invalid variable name " + repr(field[key]) + "." + self.idebug(data))
                         field_info['saveas'] = field[key]
                     elif key == 'label':
                         if 'field' not in field:
-                            raise DAError("If you use 'label' to label a field in a 'fields' section, you must also include a 'field.'" + self.idebug(data))
+                            raise DASourceError("If you use 'label' to label a field in a 'fields' section, you must also include a 'field.'" + self.idebug(data))
                         field_info['label'] = TextObject(definitions + interpret_label(field[key]), question=self)
                     else:
                         if 'label' in field_info:
-                            raise DAError("Syntax error: field label '" + str(key) + "' overwrites previous label, '" + str(field_info['label'].original_text) + "'" + self.idebug(data))
+                            raise DASourceError("Syntax error: field label '" + str(key) + "' overwrites previous label, '" + str(field_info['label'].original_text) + "'" + self.idebug(data))
                         field_info['label'] = TextObject(definitions + interpret_label(key), question=self)
                         if not isinstance(field[key], str):
-                            raise DAError("Fields in a 'field' section must be plain text." + self.idebug(data))
+                            raise DASourceError("Fields in a 'field' section must be plain text." + self.idebug(data))
                         field[key] = field[key].strip()
                         if invalid_variable_name(field[key]):
-                            raise DAError("Missing or invalid variable name " + repr(field[key]) + " for key " + repr(key) + "." + self.idebug(data))
+                            raise DASourceError("Missing or invalid variable name " + repr(field[key]) + " for key " + repr(key) + "." + self.idebug(data))
                         field_info['saveas'] = field[key]
                 if 'type' in field_info:
                     if field_info['type'] in ('multiselect', 'object_multiselect', 'checkboxes', 'object_checkboxes'):
@@ -4467,14 +4469,14 @@ def __init__(self, orig_data, caller, **kwargs):
                         field_info['nota'] = False
                 if 'choicetype' in field_info and field_info['choicetype'] == 'compute' and 'type' in field_info and field_info['type'] in ('object', 'object_radio', 'object_multiselect', 'object_checkboxes'):
                     if 'choices' not in field:
-                        raise DAError("You need to have a choices element if you want to set a variable to an object." + self.idebug(data))
+                        raise DASourceError("You need to have a choices element if you want to set a variable to an object." + self.idebug(data))
                     if not isinstance(field['choices'], list):
                         select_list = [str(field['choices'])]
                     else:
                         select_list = field['choices']
                     if 'exclude' in field:
                         if isinstance(field['exclude'], dict):
-                            raise DAError("choices exclude list is not in appropriate format" + self.idebug(data))
+                            raise DASourceError("choices exclude list is not in appropriate format" + self.idebug(data))
                         if not isinstance(field['exclude'], list):
                             exclude_list = [str(field['exclude']).strip()]
                         else:
@@ -4483,7 +4485,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             select_list.append('exclude=[' + ", ".join(exclude_list) + ']')
                     if 'default' in field:
                         if not isinstance(field['default'], (list, str)):
-                            raise DAError("default list is not in appropriate format" + self.idebug(data))
+                            raise DASourceError("default list is not in appropriate format" + self.idebug(data))
                         if not isinstance(field['default'], list):
                             default_list = [str(field['default'])]
                         else:
@@ -4506,7 +4508,7 @@ def __init__(self, orig_data, caller, **kwargs):
                     field_info['selections'] = {'compute': compile(source_code, '<expression>', 'eval'), 'sourcecode': source_code}
                 if 'saveas' in field_info:
                     if not isinstance(field_info['saveas'], str):
-                        raise DAError("Invalid variable name " + repr(field_info['saveas']) + "." + self.idebug(data))
+                        raise DASourceError("Invalid variable name " + repr(field_info['saveas']) + "." + self.idebug(data))
                     self.fields.append(Field(field_info))
                     if 'type' in field_info:
                         if field_info['type'] in ('multiselect', 'object_multiselect', 'checkboxes', 'object_checkboxes'):
@@ -4533,7 +4535,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             if re.search(r'\.text$', field_info['saveas']):
                                 field_info['saveas'] = field_info['saveas'].strip()
                                 if invalid_variable_name(field_info['saveas']):
-                                    raise DAError("Missing or invalid variable name " + repr(field_info['saveas']) + "." + self.idebug(data))
+                                    raise DASourceError("Missing or invalid variable name " + repr(field_info['saveas']) + "." + self.idebug(data))
                                 field_info['saveas'] = re.sub(r'\.text$', '', field_info['saveas'])
                                 if self.scan_for_variables:
                                     self.fields_used.add(field_info['saveas'])
@@ -4554,7 +4556,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             self.fields_used.add(field_info['saveas'])
                         else:
                             self.other_fields_used.add(field_info['saveas'])
-                elif 'note' in field or 'html' or 'raw html' in field:
+                elif 'note' in field or 'html' in field or 'raw html' in field:
                     if 'note' in field:
                         field_info['type'] = 'note'
                     elif 'raw html' in field:
@@ -4563,14 +4565,14 @@ def __init__(self, orig_data, caller, **kwargs):
                         field_info['type'] = 'html'
                     self.fields.append(Field(field_info))
                 else:
-                    raise DAError("A field was listed without indicating a label or a variable name, and the field was not a note or raw HTML." + self.idebug(data) + " and field_info was " + repr(field_info))
+                    raise DASourceError("A field was listed without indicating a label or a variable name, and the field was not a note or raw HTML." + self.idebug(data) + " and field_info was " + repr(field_info))
                 field_number += 1
                 if 'current_field' in docassemble.base.functions.this_thread.misc:
                     del docassemble.base.functions.this_thread.misc['current_field']
         if 'review' in data:
             self.question_type = 'review'
             if self.is_mandatory and 'continue button field' not in data:
-                raise DAError("A review block without a continue button field cannot be mandatory." + self.idebug(data))
+                raise DASourceError("A review block without a continue button field cannot be mandatory." + self.idebug(data))
             if 'tabular' in data and data['tabular']:
                 if isinstance(data['tabular'], str):
                     tabular_class = data['tabular']
@@ -4580,11 +4582,11 @@ def __init__(self, orig_data, caller, **kwargs):
             if isinstance(data['review'], dict):
                 data['review'] = [data['review']]
             if not isinstance(data['review'], list):
-                raise DAError("The review must be written in the form of a list." + self.idebug(data))
+                raise DASourceError("The review must be written in the form of a list." + self.idebug(data))
             field_number = 0
             for field in data['review']:
                 if not isinstance(field, dict):
-                    raise DAError("Each individual field in a list of fields must be expressed as a dictionary item, e.g., ' - Fruit: user.favorite_fruit'." + self.idebug(data))
+                    raise DASourceError("Each individual field in a list of fields must be expressed as a dictionary item, e.g., ' - Fruit: user.favorite_fruit'." + self.idebug(data))
                 field_info = {'number': field_number, 'data': []}
                 for key in field:
                     if key == 'action':
@@ -4593,7 +4595,7 @@ def __init__(self, orig_data, caller, **kwargs):
                         if not isinstance(field[key], dict) and not isinstance(field[key], list):
                             field_info[key] = TextObject(definitions + str(field[key]), question=self)
                         if 'button' in field:  # or 'css' in field or 'script' in field:
-                            raise DAError("In a review block, you cannot mix help text with a button item." + self.idebug(data))  # , css, or script
+                            raise DASourceError("In a review block, you cannot mix help text with a button item." + self.idebug(data))  # , css, or script
                     elif key == 'button':
                         if not isinstance(field[key], dict) and not isinstance(field[key], list):
                             field_info['help'] = TextObject(definitions + str(field[key]), question=self)
@@ -4612,10 +4614,10 @@ def __init__(self, orig_data, caller, **kwargs):
                         field_data = []
                         for the_saveas in field_list:
                             # if not isinstance(the_saveas, str):
-                            #    raise DAError("Invalid variable name in fields." + self.idebug(data))
+                            #    raise DASourceError("Invalid variable name in fields." + self.idebug(data))
                             the_saveas = str(the_saveas).strip()
                             # if invalid_variable_name(the_saveas):
-                            #    raise DAError("Missing or invalid variable name " + repr(the_saveas) + " ." + self.idebug(data))
+                            #    raise DASourceError("Missing or invalid variable name " + repr(the_saveas) + " ." + self.idebug(data))
                             if the_saveas not in field_data:
                                 field_data.append(the_saveas)
                             self.find_fields_in(the_saveas)
@@ -4625,7 +4627,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             field_info['saveas_code'].extend([(compile(y, '<expression>', 'eval'), True) for y in field_list])
                     elif key in ('field', 'fields'):
                         if 'label' not in field:
-                            raise DAError("If you use 'field' or 'fields' to indicate variables in a 'review' section, you must also include a 'label.'" + self.idebug(data))
+                            raise DASourceError("If you use 'field' or 'fields' to indicate variables in a 'review' section, you must also include a 'label.'" + self.idebug(data))
                         if not isinstance(field[key], list):
                             field_list = [field[key]]
                         else:
@@ -4635,29 +4637,29 @@ def __init__(self, orig_data, caller, **kwargs):
                             if isinstance(the_saveas, dict) and len(the_saveas) == 1 and ('undefine' in the_saveas or 'invalidate' in the_saveas or 'recompute' in the_saveas or 'set' in the_saveas or 'follow up' in the_saveas):
                                 if 'set' in the_saveas:
                                     if not isinstance(the_saveas['set'], list):
-                                        raise DAError("The set statement must refer to a list." + self.idebug(data))
+                                        raise DASourceError("The set statement must refer to a list." + self.idebug(data))
                                     clean_list = []
                                     for the_dict in the_saveas['set']:
                                         if not isinstance(the_dict, dict):
-                                            raise DAError("A set command must refer to a list of dicts." + self.idebug(data))
+                                            raise DASourceError("A set command must refer to a list of dicts." + self.idebug(data))
                                         for the_var, the_val in the_dict.items():
                                             if not isinstance(the_var, str):
-                                                raise DAError("A set command must refer to a list of dicts with keys as variable names." + self.idebug(data))
+                                                raise DASourceError("A set command must refer to a list of dicts with keys as variable names." + self.idebug(data))
                                             the_var_stripped = the_var.strip()
                                             if invalid_variable_name(the_var_stripped):
-                                                raise DAError("Missing or invalid variable name " + repr(the_var) + " ." + self.idebug(data))
+                                                raise DASourceError("Missing or invalid variable name " + repr(the_var) + " ." + self.idebug(data))
                                             self.find_fields_in(the_var_stripped)
                                             clean_list.append([the_var_stripped, the_val])
                                     field_info['data'].append({'action': '_da_set', 'arguments': {'variables': clean_list}})
                                 if 'follow up' in the_saveas:
                                     if not isinstance(the_saveas['follow up'], list):
-                                        raise DAError("The follow up statement must refer to a list." + self.idebug(data))
+                                        raise DASourceError("The follow up statement must refer to a list." + self.idebug(data))
                                     for var in the_saveas['follow up']:
                                         if not isinstance(var, str):
-                                            raise DAError("Invalid variable name in follow up " + repr(var) + "." + self.idebug(data))
+                                            raise DASourceError("Invalid variable name in follow up " + repr(var) + "." + self.idebug(data))
                                         var_saveas = var.strip()
                                         if invalid_variable_name(var_saveas):
-                                            raise DAError("Missing or invalid variable name " + repr(var_saveas) + " ." + self.idebug(data))
+                                            raise DASourceError("Missing or invalid variable name " + repr(var_saveas) + " ." + self.idebug(data))
                                         self.find_fields_in(var_saveas)
                                         # field_info['data'].append({'action': "_da_follow_up", 'arguments': {'action': var}})
                                         field_info['data'].append({'action': var, 'arguments': {}})
@@ -4665,14 +4667,14 @@ def __init__(self, orig_data, caller, **kwargs):
                                     if command not in the_saveas:
                                         continue
                                     if not isinstance(the_saveas[command], list):
-                                        raise DAError("The " + command + " statement must refer to a list." + self.idebug(data))
+                                        raise DASourceError("The " + command + " statement must refer to a list." + self.idebug(data))
                                     clean_list = []
                                     for undef_var in the_saveas[command]:
                                         if not isinstance(undef_var, str):
-                                            raise DAError("Invalid variable name " + repr(undef_var) + " in " + command + "." + self.idebug(data))
+                                            raise DASourceError("Invalid variable name " + repr(undef_var) + " in " + command + "." + self.idebug(data))
                                         undef_saveas = undef_var.strip()
                                         if invalid_variable_name(undef_saveas):
-                                            raise DAError("Missing or invalid variable name " + repr(undef_saveas) + " ." + self.idebug(data))
+                                            raise DASourceError("Missing or invalid variable name " + repr(undef_saveas) + " ." + self.idebug(data))
                                         self.find_fields_in(undef_saveas)
                                         clean_list.append(undef_saveas)
                                     if command == 'invalidate':
@@ -4684,13 +4686,13 @@ def __init__(self, orig_data, caller, **kwargs):
                                 continue
                             if isinstance(the_saveas, dict) and len(the_saveas) == 2 and 'action' in the_saveas and 'arguments' in the_saveas:
                                 if not isinstance(the_saveas['arguments'], dict):
-                                    raise DAError("An arguments directive must refer to a dictionary.  " + repr(data))
+                                    raise DASourceError("An arguments directive must refer to a dictionary.  " + repr(data))
                                 field_info['data'].append({'action': the_saveas['action'], 'arguments': the_saveas['arguments']})
                             if not isinstance(the_saveas, str):
-                                raise DAError("Invalid variable name " + repr(the_saveas) + " in fields." + self.idebug(data))
+                                raise DASourceError("Invalid variable name " + repr(the_saveas) + " in fields." + self.idebug(data))
                             the_saveas = the_saveas.strip()
                             if invalid_variable_name(the_saveas):
-                                raise DAError("Missing or invalid variable name " + repr(the_saveas) + " ." + self.idebug(data))
+                                raise DASourceError("Missing or invalid variable name " + repr(the_saveas) + " ." + self.idebug(data))
                             if the_saveas not in field_info['data']:
                                 field_info['data'].append(the_saveas)
                             self.find_fields_in(the_saveas)
@@ -4698,7 +4700,7 @@ def __init__(self, orig_data, caller, **kwargs):
                             field_info['action'] = {'action': field['action'], 'arguments': {}}
                     elif key == 'label':
                         if 'field' not in field and 'fields' not in field:
-                            raise DAError("If you use 'label' to label a field in a 'review' section, you must also include a 'field' or 'fields.'" + self.idebug(data))
+                            raise DASourceError("If you use 'label' to label a field in a 'review' section, you must also include a 'field' or 'fields.'" + self.idebug(data))
                         field_info['label'] = TextObject(definitions + interpret_label(field[key]), question=self)
                     else:
                         field_info['label'] = TextObject(definitions + interpret_label(key), question=self)
@@ -4711,29 +4713,29 @@ def __init__(self, orig_data, caller, **kwargs):
                             if isinstance(the_saveas, dict) and len(the_saveas) == 1 and ('undefine' in the_saveas or 'invalidate' in the_saveas or 'recompute' in the_saveas or 'set' in the_saveas or 'follow up' in the_saveas):
                                 if 'set' in the_saveas:
                                     if not isinstance(the_saveas['set'], list):
-                                        raise DAError("The set statement must refer to a list." + self.idebug(data))
+                                        raise DASourceError("The set statement must refer to a list." + self.idebug(data))
                                     clean_list = []
                                     for the_dict in the_saveas['set']:
                                         if not isinstance(the_dict, dict):
-                                            raise DAError("A set command must refer to a list of dicts." + self.idebug(data))
+                                            raise DASourceError("A set command must refer to a list of dicts." + self.idebug(data))
                                         for the_var, the_val in the_dict.items():
                                             if not isinstance(the_var, str):
-                                                raise DAError("A set command must refer to a list of dicts with keys as variable names." + self.idebug(data))
+                                                raise DASourceError("A set command must refer to a list of dicts with keys as variable names." + self.idebug(data))
                                             the_var_stripped = the_var.strip()
                                             if invalid_variable_name(the_var_stripped):
-                                                raise DAError("Missing or invalid variable name " + repr(the_var) + " ." + self.idebug(data))
+                                                raise DASourceError("Missing or invalid variable name " + repr(the_var) + " ." + self.idebug(data))
                                             self.find_fields_in(the_var_stripped)
                                             clean_list.append([the_var_stripped, the_val])
                                     field_info['data'].append({'action': '_da_set', 'arguments': {'variables': clean_list}})
                                 if 'follow up' in the_saveas:
                                     if not isinstance(the_saveas['follow up'], list):
-                                        raise DAError("The follow up statement must refer to a list." + self.idebug(data))
+                                        raise DASourceError("The follow up statement must refer to a list." + self.idebug(data))
                                     for var in the_saveas['follow up']:
                                         if not isinstance(var, str):
-                                            raise DAError("Invalid variable name in follow up " + command + "." + self.idebug(data))
+                                            raise DASourceError("Invalid variable name in follow up " + command + "." + self.idebug(data))
                                         var_saveas = var.strip()
                                         if invalid_variable_name(var_saveas):
-                                            raise DAError("Missing or invalid variable name " + repr(var_saveas) + " ." + self.idebug(data))
+                                            raise DASourceError("Missing or invalid variable name " + repr(var_saveas) + " ." + self.idebug(data))
                                         self.find_fields_in(var_saveas)
                                         # field_info['data'].append({'action': "_da_follow_up", 'arguments': {'action': var}})
                                         field_info['data'].append({'action': var, 'arguments': {}})
@@ -4741,14 +4743,14 @@ def __init__(self, orig_data, caller, **kwargs):
                                     if command not in the_saveas:
                                         continue
                                     if not isinstance(the_saveas[command], list):
-                                        raise DAError("The " + command + " statement must refer to a list." + self.idebug(data))
+                                        raise DASourceError("The " + command + " statement must refer to a list." + self.idebug(data))
                                     clean_list = []
                                     for undef_var in the_saveas[command]:
                                         if not isinstance(undef_var, str):
-                                            raise DAError("Invalid variable name " + repr(undef_var) + " in fields " + command + "." + self.idebug(data))
+                                            raise DASourceError("Invalid variable name " + repr(undef_var) + " in fields " + command + "." + self.idebug(data))
                                         undef_saveas = undef_var.strip()
                                         if invalid_variable_name(undef_saveas):
-                                            raise DAError("Missing or invalid variable name " + repr(undef_saveas) + " ." + self.idebug(data))
+                                            raise DASourceError("Missing or invalid variable name " + repr(undef_saveas) + " ." + self.idebug(data))
                                         self.find_fields_in(undef_saveas)
                                         clean_list.append(undef_saveas)
                                     if command == 'invalidate':
@@ -4760,13 +4762,13 @@ def __init__(self, orig_data, caller, **kwargs):
                                 continue
                             if isinstance(the_saveas, dict) and len(the_saveas) == 2 and 'action' in the_saveas and 'arguments' in the_saveas:
                                 if not isinstance(the_saveas['arguments'], dict):
-                                    raise DAError("An arguments directive must refer to a dictionary.  " + repr(data))
+                                    raise DASourceError("An arguments directive must refer to a dictionary.  " + repr(data))
                                 field_info['data'].append({'action': the_saveas['action'], 'arguments': the_saveas['arguments']})
                             if not isinstance(the_saveas, str):
-                                raise DAError("Invalid variable name " + repr(the_saveas) + " in fields." + self.idebug(data))
+                                raise DASourceError("Invalid variable name " + repr(the_saveas) + " in fields." + self.idebug(data))
                             the_saveas = the_saveas.strip()
                             if invalid_variable_name(the_saveas):
-                                raise DAError("Missing or invalid variable name " + repr(the_saveas) + " ." + self.idebug(data))
+                                raise DASourceError("Missing or invalid variable name " + repr(the_saveas) + " ." + self.idebug(data))
                             # if the_saveas not in field_info['data']:
                             field_info['data'].append(the_saveas)
                             self.find_fields_in(the_saveas)
@@ -4786,7 +4788,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 if len(field_info['data']) > 0 or ('type' in field_info and field_info['type'] in ('note', 'html', 'raw html')):
                     self.fields.append(Field(field_info))
                 else:
-                    raise DAError("A field in a review list was listed without indicating a label or a variable name, and the field was not a note or raw HTML." + self.idebug(field_info))
+                    raise DASourceError("A field in a review list was listed without indicating a label or a variable name, and the field was not a note or raw HTML." + self.idebug(field_info))
                 field_number += 1
         if not hasattr(self, 'question_type'):
             if len(self.attachments) > 0 and len(self.fields_used) > 0 and not hasattr(self, 'content'):
@@ -4795,7 +4797,7 @@ def __init__(self, orig_data, caller, **kwargs):
                 self.question_type = 'deadend'
         if should_append:
             if not hasattr(self, 'question_type'):
-                raise DAError("No question type could be determined for this section." + self.idebug(data))
+                raise DASourceError("No question type could be determined for this section." + self.idebug(data))
             if main_list:
                 self.interview.questions_list.append(self)
             self.number = self.interview.next_number()
@@ -4803,7 +4805,7 @@ def __init__(self, orig_data, caller, **kwargs):
             if hasattr(self, 'id'):
                 self.name = "ID " + self.id
                 # if self.name in self.interview.questions_by_name:
-                #     raise DAError("Question ID " + str(self.id) + " results in duplicate question name")
+                #     raise DASourceError("Question ID " + str(self.id) + " results in duplicate question name")
             else:
                 self.name = "Question_" + str(self.number)
         else:
@@ -5055,7 +5057,7 @@ def process_attachment(self, orig_target):
                     options['skip_undefined'] = compile(target['skip undefined'], '<skip undefined expression>', 'eval')
                     self.find_fields_in(target['skip undefined'])
                 else:
-                    raise DAError('Unknown data type in attachment skip undefined.' + self.idebug(target))
+                    raise DASourceError('Unknown data type in attachment skip undefined.' + self.idebug(target))
             else:
                 options['skip_undefined'] = False
             if 'language' in target:
@@ -5075,11 +5077,11 @@ def process_attachment(self, orig_target):
                     self.find_fields_in(target['redact'])
             if 'checkbox export value' in target and 'pdf template file' in target:
                 if not isinstance(target['checkbox export value'], str):
-                    raise DAError("A checkbox export value must be a string." + self.idebug(target))
+                    raise DASourceError("A checkbox export value must be a string." + self.idebug(target))
                 options['checkbox_export_value'] = TextObject(target['checkbox export value'])
             if 'decimal places' in target and 'pdf template file' in target:
                 if not isinstance(target['decimal places'], (str, int)):
-                    raise DAError("A decimal places directive must be an integer or string." + self.idebug(target))
+                    raise DASourceError("A decimal places directive must be an integer or string." + self.idebug(target))
                 options['decimal_places'] = TextObject(str(target['decimal places']))
             if 'initial yaml' in target:
                 if not isinstance(target['initial yaml'], list):
@@ -5087,7 +5089,7 @@ def process_attachment(self, orig_target):
                 options['initial_yaml'] = []
                 for yaml_file in target['initial yaml']:
                     if not isinstance(yaml_file, str):
-                        raise DAError('An initial yaml file must be a string.' + self.idebug(target))
+                        raise DASourceError('An initial yaml file must be a string.' + self.idebug(target))
                     options['initial_yaml'].append(FileInPackage(yaml_file, 'template', self.package))
             if 'additional yaml' in target:
                 if not isinstance(target['additional yaml'], list):
@@ -5095,19 +5097,19 @@ def process_attachment(self, orig_target):
                 options['additional_yaml'] = []
                 for yaml_file in target['additional yaml']:
                     if not isinstance(yaml_file, str):
-                        raise DAError('An additional yaml file must be a string.' + self.idebug(target))
+                        raise DASourceError('An additional yaml file must be a string.' + self.idebug(target))
                     options['additional_yaml'].append(FileInPackage(yaml_file, 'template', self.package))
             if 'template file' in target:
                 if not isinstance(target['template file'], str):
-                    raise DAError('The template file must be a string.' + self.idebug(target))
+                    raise DASourceError('The template file must be a string.' + self.idebug(target))
                 options['template_file'] = FileInPackage(target['template file'], 'template', self.package)
             if 'rtf template file' in target:
                 if not isinstance(target['rtf template file'], str):
-                    raise DAError('The rtf template file must be a string.' + self.idebug(target))
+                    raise DASourceError('The rtf template file must be a string.' + self.idebug(target))
                 options['rtf_template_file'] = FileInPackage(target['rtf template file'], 'template', self.package)
             if 'docx reference file' in target:
                 if not isinstance(target['docx reference file'], str):
-                    raise DAError('The docx reference file must be a string.' + self.idebug(target))
+                    raise DASourceError('The docx reference file must be a string.' + self.idebug(target))
                 options['docx_reference_file'] = FileInPackage(target['docx reference file'], 'template', self.package)
             if 'usedefs' in target:
                 if isinstance(target['usedefs'], str):
@@ -5115,17 +5117,17 @@ def process_attachment(self, orig_target):
                 elif isinstance(target['usedefs'], list):
                     the_list = target['usedefs']
                 else:
-                    raise DAError('The usedefs included in an attachment must be specified as a list of strings or a single string.' + self.idebug(target))
+                    raise DASourceError('The usedefs included in an attachment must be specified as a list of strings or a single string.' + self.idebug(target))
                 for def_key in the_list:
                     if not isinstance(def_key, str):
-                        raise DAError('The defs in an attachment must be strings.' + self.idebug(target))
+                        raise DASourceError('The defs in an attachment must be strings.' + self.idebug(target))
                     if def_key not in self.interview.defs:
-                        raise DAError('Referred to a non-existent def "' + def_key + '."  All defs must be defined before they are used.' + self.idebug(target))
+                        raise DASourceError('Referred to a non-existent def "' + def_key + '."  All defs must be defined before they are used.' + self.idebug(target))
                     defs.extend(self.interview.defs[def_key])
             if 'variable name' in target:
                 variable_name = target['variable name']
                 if variable_name is None:
-                    raise DAError('A variable name cannot be None.' + self.idebug(target))
+                    raise DASourceError('A variable name cannot be None.' + self.idebug(target))
                 if self.scan_for_variables:
                     self.fields_used.add(target['variable name'])
                 else:
@@ -5134,13 +5136,13 @@ def process_attachment(self, orig_target):
                 variable_name = "_internal['docvar'][" + str(self.interview.next_attachment_number()) + "]"
             if 'metadata' in target:
                 if not isinstance(target['metadata'], dict):
-                    raise DAError('Unknown data type ' + str(type(target['metadata'])) + ' in attachment metadata.' + self.idebug(target))
+                    raise DASourceError('Unknown data type ' + str(type(target['metadata'])) + ' in attachment metadata.' + self.idebug(target))
                 for key in target['metadata']:
                     data = target['metadata'][key]
                     if isinstance(data, list):
                         for sub_data in data:
                             if not isinstance(sub_data, str):
-                                raise DAError('Unknown data type ' + str(type(sub_data)) + ' in list in attachment metadata' + self.idebug(target))
+                                raise DASourceError('Unknown data type ' + str(type(sub_data)) + ' in list in attachment metadata' + self.idebug(target))
                         newdata = list(map((lambda x: TextObject(x, question=self)), data))
                         metadata[key] = newdata
                     elif isinstance(data, str):
@@ -5148,7 +5150,7 @@ def process_attachment(self, orig_target):
                     elif isinstance(data, bool):
                         metadata[key] = data
                     else:
-                        raise DAError('Unknown data type ' + str(type(data)) + ' in key in attachment metadata' + self.idebug(target))
+                        raise DASourceError('Unknown data type ' + str(type(data)) + ' in key in attachment metadata' + self.idebug(target))
             if 'raw' in target and target['raw']:
                 if 'content file' in target:
                     content_file = target['content file']
@@ -5176,20 +5178,20 @@ def process_attachment(self, orig_target):
                         options['content file code'] = compile(target['content file']['code'], '<content file code>', 'eval')
                         self.find_fields_in(target['content file']['code'])
                     else:
-                        raise DAError('A content file must be specified as text, a list of text filenames, or a dictionary where the one key is code' + self.idebug(target))
+                        raise DASourceError('A content file must be specified as text, a list of text filenames, or a dictionary where the one key is code' + self.idebug(target))
                 else:
                     if not isinstance(target['content file'], list):
                         target['content file'] = [target['content file']]
                     target['content'] = ''
                     for content_file in target['content file']:
                         if not isinstance(content_file, str):
-                            raise DAError('A content file must be specified as text, a list of text filenames, or a dictionary where the one key is code' + self.idebug(target))
+                            raise DASourceError('A content file must be specified as text, a list of text filenames, or a dictionary where the one key is code' + self.idebug(target))
                         file_to_read = docassemble.base.functions.package_template_filename(content_file, package=self.package)
                         if file_to_read is not None and os.path.isfile(file_to_read) and os.access(file_to_read, os.R_OK):
                             with open(file_to_read, 'r', encoding='utf-8') as the_file:
                                 target['content'] += the_file.read()
                         else:
-                            raise DAError('Unable to read content file ' + str(content_file) + ' after trying to find it at ' + str(file_to_read) + self.idebug(target))
+                            raise DASourceError('Unable to read content file ' + str(content_file) + ' after trying to find it at ' + str(file_to_read) + self.idebug(target))
             if 'pdf template file' in target and ('code' in target or 'field variables' in target or 'field code' in target or 'raw field variables' in target) and 'fields' not in target:
                 target['fields'] = {}
                 field_mode = 'manual'
@@ -5201,7 +5203,7 @@ def process_attachment(self, orig_target):
                         options['update_references'] = compile(target['update references'], '<expression>', 'eval')
                         self.find_fields_in(target['update references'])
                     else:
-                        raise DAError('Unknown data type in attachment "update references".' + self.idebug(target))
+                        raise DASourceError('Unknown data type in attachment "update references".' + self.idebug(target))
                 if 'fields' in target:
                     field_mode = 'manual'
                 else:
@@ -5216,9 +5218,9 @@ def process_attachment(self, orig_target):
                 target['fields'] = {}
             if 'fields' in target:
                 if 'pdf template file' not in target and 'docx template file' not in target:
-                    raise DAError('Fields supplied to attachment but no pdf template file or docx template file supplied' + self.idebug(target))
+                    raise DASourceError('Fields supplied to attachment but no pdf template file or docx template file supplied' + self.idebug(target))
                 if 'pdf template file' in target and 'docx template file' in target:
-                    raise DAError('You cannot use a pdf template file and a docx template file at the same time' + self.idebug(target))
+                    raise DASourceError('You cannot use a pdf template file and a docx template file at the same time' + self.idebug(target))
                 if 'pdf template file' in target:
                     template_type = 'pdf'
                     target['valid formats'] = ['pdf']
@@ -5230,37 +5232,37 @@ def process_attachment(self, orig_target):
                         if isinstance(target['valid formats'], str):
                             target['valid formats'] = [target['valid formats']]
                         elif not isinstance(target['valid formats'], list):
-                            raise DAError('Unknown data type in attachment valid formats.' + self.idebug(target))
+                            raise DASourceError('Unknown data type in attachment valid formats.' + self.idebug(target))
                         if 'rtf to docx' in target['valid formats']:
-                            raise DAError('Valid formats cannot include "rtf to docx" when "docx template file" is used' + self.idebug(target))
+                            raise DASourceError('Valid formats cannot include "rtf to docx" when "docx template file" is used' + self.idebug(target))
                     else:
                         target['valid formats'] = ['docx', 'pdf']
                 else:
                     template_type = ''
                 if template_type == 'docx':
                     if not isinstance(target['docx template file'], (str, dict, list)):
-                        raise DAError(template_type + ' template file supplied to attachment must be a string, dict, or list' + self.idebug(target))
+                        raise DASourceError(template_type + ' template file supplied to attachment must be a string, dict, or list' + self.idebug(target))
                     if not isinstance(target['docx template file'], list):
                         target[template_type + ' template file'] = [target['docx template file']]
                 else:
                     if not isinstance(target[template_type + ' template file'], (str, dict)):
-                        raise DAError(template_type + ' template file supplied to attachment must be a string or dict' + self.idebug(target))
+                        raise DASourceError(template_type + ' template file supplied to attachment must be a string or dict' + self.idebug(target))
                 if field_mode == 'auto':
                     options['fields'] = 'auto'
                 elif not isinstance(target['fields'], (list, dict)):
-                    raise DAError('fields supplied to attachment must be a list or dictionary' + self.idebug(target))
+                    raise DASourceError('fields supplied to attachment must be a list or dictionary' + self.idebug(target))
                 target['content'] = ''
                 if template_type == 'docx':
                     options[template_type + '_template_file'] = [FileInPackage(item, 'template', package=self.package) for item in target['docx template file']]
                     for item in target['docx template file']:
                         if not isinstance(item, (str, dict)):
-                            raise DAError('docx template file supplied to attachment must be a string or dict' + self.idebug(target))
+                            raise DASourceError('docx template file supplied to attachment must be a string or dict' + self.idebug(target))
                     template_files = []
                     for template_file in options['docx_template_file']:
                         if not template_file.is_code:
                             the_docx_path = template_file.path()
                             if the_docx_path is None or not os.path.isfile(the_docx_path):
-                                raise DAError("Missing docx template file " + template_file.original_reference())
+                                raise DASourceError("Missing docx template file " + template_file.original_reference())
                             template_files.append(the_docx_path)
                     if len(template_files) > 0:
                         if len(template_files) == 1:
@@ -5322,22 +5324,22 @@ def process_attachment(self, orig_target):
                             self.find_fields_in(target['code'])
                     if 'field variables' in target:
                         if not isinstance(target['field variables'], list):
-                            raise DAError('The field variables must be expressed in the form of a list' + self.idebug(target))
+                            raise DASourceError('The field variables must be expressed in the form of a list' + self.idebug(target))
                         if 'code dict' not in options:
                             options['code dict'] = {}
                         for varname in target['field variables']:
                             if not valid_variable_match.match(str(varname)):
-                                raise DAError('The variable ' + str(varname) + " cannot be used in a code list" + self.idebug(target))
+                                raise DASourceError('The variable ' + str(varname) + " cannot be used in a code list" + self.idebug(target))
                             options['code dict'][varname] = compile(varname, '<expression>', 'eval')
                             self.find_fields_in(varname)
                     if 'raw field variables' in target:
                         if not isinstance(target['raw field variables'], list):
-                            raise DAError('The raw field variables must be expressed in the form of a list' + self.idebug(target))
+                            raise DASourceError('The raw field variables must be expressed in the form of a list' + self.idebug(target))
                         if 'raw code dict' not in options:
                             options['raw code dict'] = {}
                         for varname in target['raw field variables']:
                             if not valid_variable_match.match(str(varname)):
-                                raise DAError('The variable ' + str(varname) + " cannot be used in a code list" + self.idebug(target))
+                                raise DASourceError('The variable ' + str(varname) + " cannot be used in a code list" + self.idebug(target))
                             options['raw code dict'][varname] = compile(varname, '<expression>', 'eval')
                             self.find_fields_in(varname)
                     if 'field code' in target:
@@ -5347,7 +5349,7 @@ def process_attachment(self, orig_target):
                             target['field code'] = [target['field code']]
                         for item in target['field code']:
                             if not isinstance(item, dict):
-                                raise DAError('The field code must be expressed in the form of a dictionary' + self.idebug(target))
+                                raise DASourceError('The field code must be expressed in the form of a dictionary' + self.idebug(target))
                             for key, val in item.items():
                                 options['code dict'][key] = compile(str(val), '<expression>', 'eval')
                                 self.find_fields_in(val)
@@ -5355,9 +5357,9 @@ def process_attachment(self, orig_target):
                 if isinstance(target['valid formats'], str):
                     target['valid formats'] = [target['valid formats']]
                 elif not isinstance(target['valid formats'], list):
-                    raise DAError('Unknown data type in attachment valid formats.' + self.idebug(target))
+                    raise DASourceError('Unknown data type in attachment valid formats.' + self.idebug(target))
                 if 'rtf to docx' in target['valid formats'] and 'docx' in target['valid formats']:
-                    raise DAError('Valid formats cannot include both "rtf to docx" and "docx."' + self.idebug(target))
+                    raise DASourceError('Valid formats cannot include both "rtf to docx" and "docx."' + self.idebug(target))
             else:
                 target['valid formats'] = ['*']
             if 'password' in target:
@@ -5373,7 +5375,7 @@ def process_attachment(self, orig_target):
                     options['persistent'] = compile(target['persistent'], '<persistent expression>', 'eval')
                     self.find_fields_in(target['persistent'])
                 else:
-                    raise DAError('Unknown data type in attachment persistent.' + self.idebug(target))
+                    raise DASourceError('Unknown data type in attachment persistent.' + self.idebug(target))
             if 'private' in target:
                 if isinstance(target['private'], bool):
                     options['private'] = target['private']
@@ -5381,7 +5383,7 @@ def process_attachment(self, orig_target):
                     options['private'] = compile(target['private'], '<public expression>', 'eval')
                     self.find_fields_in(target['private'])
                 else:
-                    raise DAError('Unknown data type in attachment public.' + self.idebug(target))
+                    raise DASourceError('Unknown data type in attachment public.' + self.idebug(target))
             if 'allow privileges' in target:
                 if isinstance(target['allow privileges'], dict) and len(target['allow privileges']) == 1 and 'code' in target['allow privileges'] and isinstance(target['allow privileges']['code'], str):
                     options['allow privileges'] = compile(target['allow privileges']['code'], '<allow privileges expression>', 'eval')
@@ -5390,7 +5392,7 @@ def process_attachment(self, orig_target):
                 elif isinstance(target['allow privileges'], list):
                     for item in target['allow privileges']:
                         if not isinstance(item, str):
-                            raise DAError('Unknown data type in attachment allow privileges.' + self.idebug(target))
+                            raise DASourceError('Unknown data type in attachment allow privileges.' + self.idebug(target))
                     options['allow privileges'] = target['allow privileges']
             if 'allow users' in target:
                 if isinstance(target['allow users'], dict) and len(target['allow users']) == 1 and 'code' in target['allow users'] and isinstance(target['allow users']['code'], str):
@@ -5400,13 +5402,13 @@ def process_attachment(self, orig_target):
                 elif isinstance(target['allow users'], list):
                     for item in target['allow users']:
                         if not isinstance(item, (str, int)):
-                            raise DAError('Unknown data type in attachment allow users.' + self.idebug(target))
+                            raise DASourceError('Unknown data type in attachment allow users.' + self.idebug(target))
                     options['allow users'] = target['allow users']
             if 'hyperlink style' in target:
                 if isinstance(target['hyperlink style'], str):
                     options['hyperlink_style'] = TextObject(target['hyperlink style'].strip(), question=self)
                 else:
-                    raise DAError('Unknown data type in attachment hyperlink style.' + self.idebug(target))
+                    raise DASourceError('Unknown data type in attachment hyperlink style.' + self.idebug(target))
             if 'pdf/a' in target:
                 if isinstance(target['pdf/a'], bool):
                     options['pdf_a'] = target['pdf/a']
@@ -5414,7 +5416,15 @@ def process_attachment(self, orig_target):
                     options['pdf_a'] = compile(target['pdf/a'], '<pdfa expression>', 'eval')
                     self.find_fields_in(target['pdf/a'])
                 else:
-                    raise DAError('Unknown data type in attachment pdf/a.' + self.idebug(target))
+                    raise DASourceError('Unknown data type in attachment pdf/a.' + self.idebug(target))
+            if 'pdftk' in target:
+                if isinstance(target['pdftk'], bool):
+                    options['pdftk'] = target['pdftk']
+                elif isinstance(target['pdftk'], str):
+                    options['pdftk'] = compile(target['pdftk'], '<pdftk expression>', 'eval')
+                    self.find_fields_in(target['pdftk'])
+                else:
+                    raise DASourceError('Unknown data type in attachment pdftk.' + self.idebug(target))
             if 'rendering font' in target and target['rendering font']:
                 options['rendering_font'] = TextObject(str(target['rendering font']), question=self)
             if 'tagged pdf' in target:
@@ -5424,11 +5434,11 @@ def process_attachment(self, orig_target):
                     options['tagged_pdf'] = compile(target['tagged pdf'], '<tagged pdf expression>', 'eval')
                     self.find_fields_in(target['tagged pdf'])
                 else:
-                    raise DAError('Unknown data type in attachment tagged pdf.' + self.idebug(target))
+                    raise DASourceError('Unknown data type in attachment tagged pdf.' + self.idebug(target))
             if 'content' not in target:
                 if 'content file code' in options:
                     return {'name': TextObject(target['name'], question=self), 'filename': TextObject(target['filename'], question=self), 'description': TextObject(target['description'], question=self), 'content': None, 'valid_formats': target['valid formats'], 'metadata': metadata, 'variable_name': variable_name, 'orig_variable_name': variable_name, 'options': options, 'raw': target['raw']}
-                raise DAError("No content provided in attachment." + self.idebug(target))
+                raise DASourceError("No content provided in attachment." + self.idebug(target))
             # logmessage("The content is " + str(target['content']))
             return {'name': TextObject(target['name'], question=self), 'filename': TextObject(target['filename'], question=self), 'description': TextObject(target['description'], question=self), 'content': TextObject("\n".join(defs) + "\n" + target['content'], question=self), 'valid_formats': target['valid formats'], 'metadata': metadata, 'variable_name': variable_name, 'orig_variable_name': variable_name, 'options': options, 'raw': target['raw']}
         if isinstance(orig_target, str):
@@ -6111,7 +6121,10 @@ def ask(self, user_dict, old_user_dict, the_x, iterators, sought, orig_sought, p
                     extra_amount = get_config('list collect extra count', 15)
                 for list_indexno in range(length_to_use + extra_amount):
                     new_iterators = copy.copy(iterators)
-                    new_iterators[iterator_index] = str(list_indexno)
+                    try:
+                        new_iterators[iterator_index] = str(list_indexno)
+                    except IndexError:
+                        raise DAException("list collect question needs iterator " + extras['list_iterator'] + " but it was asked in a context where there is no " + extras['list_iterator'])
                     ask_result = self.ask(user_dict, old_user_dict, the_x, new_iterators, sought, orig_sought, process_list_collect=False, test_for_objects=(list_indexno < length_to_use))
                     if hasattr(self, 'list_collect_label'):
                         extras['list_message'][list_indexno] = self.list_collect_label.text(user_dict)
@@ -6358,7 +6371,7 @@ def ask(self, user_dict, old_user_dict, the_x, iterators, sought, orig_sought, p
                             if hasattr(field, 'saveas'):
                                 parse_result = parse_var_name(from_safeid(field.saveas))
                                 if not parse_result['valid']:
-                                    raise DAError("Variable name " + from_safeid(field.saveas) + " is invalid: " + parse_result['reason'])
+                                    raise DASourceError("Variable name " + from_safeid(field.saveas) + " is invalid: " + parse_result['reason'])
                                 if len(parse_result['objects']) > 0:
                                     assumed_objects.add(parse_result['objects'][-1])
                                 if len(parse_result['bracket_objects']) > 0:
@@ -6539,7 +6552,7 @@ def ask(self, user_dict, old_user_dict, the_x, iterators, sought, orig_sought, p
                                 # logmessage("Doing " + the_string)
                                 exec(the_string, user_dict)
                         except Exception as err:
-                            raise DAError("Failure while processing field with datatype of object: " + err.__class__.__name__ + " " + str(err))
+                            raise DASourceError("Failure while processing field with datatype of object: " + err.__class__.__name__ + " " + str(err))
                     if hasattr(field, 'label'):
                         labels[field.number] = field.label.text(user_dict)
                     if hasattr(field, 'extras'):
@@ -6691,7 +6704,7 @@ def ask(self, user_dict, old_user_dict, the_x, iterators, sought, orig_sought, p
                     #     assumed_objects.add(m.group(1))
                     parse_result = parse_var_name(from_safeid(field.saveas))
                     if not parse_result['valid']:
-                        raise DAError("Variable name " + from_safeid(field.saveas) + " is invalid: " + parse_result['reason'])
+                        raise DASourceError("Variable name " + from_safeid(field.saveas) + " is invalid: " + parse_result['reason'])
                     if len(parse_result['objects']) > 0:
                         assumed_objects.add(parse_result['objects'][-1])
                     if len(parse_result['bracket_objects']) > 0:
@@ -6794,12 +6807,12 @@ def parse_fields(self, the_list, register_target, uses_field):
                 new_list.append(new_item)
             the_list = new_list
         if not isinstance(the_list, list):
-            raise DAError("Multiple choices need to be provided in list form.  " + self.idebug(the_list))
+            raise DASourceError("Multiple choices need to be provided in list form.  " + self.idebug(the_list))
         for the_dict in the_list:
             if not isinstance(the_dict, (dict, list)):
                 the_dict = {str(the_dict): the_dict}
             elif not isinstance(the_dict, dict):
-                raise DAError("Unknown data type for the_dict in parse_fields.  " + self.idebug(the_list))
+                raise DASourceError("Unknown data type for the_dict in parse_fields.  " + self.idebug(the_list))
             result_dict = {}
             uses_value_label = 'value' in the_dict and 'label' in the_dict
             for key, value in the_dict.items():
@@ -6850,7 +6863,7 @@ def parse_fields(self, the_list, register_target, uses_field):
                         result_dict['label'] = TextObject(key, question=self)
                     result_dict['key'] = value
                 else:
-                    raise DAError("Unknown data type in parse_fields:" + str(type(value)) + ".  " + self.idebug(the_list))
+                    raise DASourceError("Unknown data type in parse_fields:" + str(type(value)) + ".  " + self.idebug(the_list))
             result_list.append(result_dict)
         return (has_code, result_list)
 
@@ -6927,7 +6940,7 @@ def finalize_attachment(self, attachment, result, the_user_dict):
                         if hasattr(the_file, 'number'):
                             result['file'][doc_format] = the_file.number
                 # logmessage("finalize_attachment: returning " + attachment['variable_name'] + " from cache")
-                for key in ('template', 'field_data', 'images', 'data_strings', 'convert_to_pdf_a', 'convert_to_tagged_pdf', 'password', 'owner_password', 'template_password', 'update_references', 'permissions', 'rendering_font'):
+                for key in ('template', 'field_data', 'images', 'data_strings', 'convert_to_pdf_a', 'use_pdftk', 'convert_to_tagged_pdf', 'password', 'owner_password', 'template_password', 'update_references', 'permissions', 'rendering_font'):
                     if key in result:
                         del result[key]
                 return result
@@ -6965,10 +6978,10 @@ def finalize_attachment(self, attachment, result, the_user_dict):
                             docassemble.base.functions.set_context('pdf')
                             the_template_path = attachment['options']['pdf_template_file'].path(the_user_dict=the_user_dict)
                             if the_template_path is None:
-                                raise DAError("pdf template file " + attachment['options']['pdf_template_file'].original_reference() + " not found")
-                            the_pdf_file = docassemble.base.pdftk.fill_template(the_template_path, data_strings=result['data_strings'], images=result['images'], editable=result['editable'], pdfa=result['convert_to_pdf_a'], password=result['password'], owner_password=result['owner_password'], template_password=result['template_password'], default_export_value=default_export_value, replacement_font=result['rendering_font'])
+                                raise DASourceError("pdf template file " + attachment['options']['pdf_template_file'].original_reference() + " not found")
+                            the_pdf_file = docassemble.base.pdftk.fill_template(the_template_path, data_strings=result['data_strings'], images=result['images'], editable=result['editable'], pdfa=result['convert_to_pdf_a'], use_pdftk=result['use_pdftk'], password=result['password'], owner_password=result['owner_password'], template_password=result['template_password'], default_export_value=default_export_value, replacement_font=result['rendering_font'])
                             result['file'][doc_format], result['extension'][doc_format], result['mimetype'][doc_format] = docassemble.base.functions.server.save_numbered_file(result['filename'] + '.' + extension_of_doc_format[doc_format], the_pdf_file, yaml_file_name=self.interview.source.path)  # pylint: disable=assignment-from-none,unpacking-non-sequence
-                            for key in ('images', 'data_strings', 'convert_to_pdf_a', 'convert_to_tagged_pdf', 'password', 'owner_password', 'template_password', 'update_references', 'permissions', 'rendering_font'):
+                            for key in ('images', 'data_strings', 'convert_to_pdf_a', 'use_pdftk', 'convert_to_tagged_pdf', 'password', 'owner_password', 'template_password', 'update_references', 'permissions', 'rendering_font'):
                                 if key in result:
                                     del result[key]
                             docassemble.base.functions.reset_context()
@@ -7167,14 +7180,14 @@ def prepare_attachment(self, attachment, the_user_dict):
                                 try:
                                     urlretrieve(url_sanitize(str(the_filename)), temp_template_file.name)
                                 except Exception as err:
-                                    raise DAError("prepare_attachment: error downloading " + str(the_filename) + ": " + str(err))
+                                    raise DASourceError("prepare_attachment: error downloading " + str(the_filename) + ": " + str(err))
                                 the_filename = temp_template_file.name
                         else:
                             the_filename = docassemble.base.functions.package_template_filename(the_filename, package=self.package)
                     else:
                         the_filename = None
                     if the_filename is None or not os.path.isfile(the_filename):
-                        raise DAError("prepare_attachment: error obtaining template file from code: " + repr(the_orig_filename))
+                        raise DASourceError("prepare_attachment: error obtaining template file from code: " + repr(the_orig_filename))
                     (the_base, actual_extension) = os.path.splitext(the_filename)  # pylint: disable=unused-variable
                     with open(the_filename, 'r', encoding='utf-8') as the_file:
                         raw_content += the_file.read()
@@ -7228,6 +7241,13 @@ def prepare_attachment(self, attachment, the_user_dict):
                     result['convert_to_pdf_a'] = eval(attachment['options']['pdf_a'], the_user_dict)
             else:
                 result['convert_to_pdf_a'] = self.interview.use_pdf_a
+            if 'pdftk' in attachment['options']:
+                if isinstance(attachment['options']['pdftk'], bool):
+                    result['use_pdftk'] = attachment['options']['pdftk']
+                else:
+                    result['use_pdftk'] = eval(attachment['options']['pdftk'], the_user_dict)
+            else:
+                result['use_pdftk'] = self.interview.options.get('use pdftk', False)
             if 'rendering_font' in attachment['options']:
                 result['rendering_font'] = attachment['options']['rendering_font'].text(the_user_dict).strip()
             else:
@@ -7303,7 +7323,7 @@ def prepare_attachment(self, attachment, the_user_dict):
                             for docx_reference in attachment['options']['docx_template_file']:
                                 for docx_path in docx_reference.paths(the_user_dict=the_user_dict):
                                     if docx_path is None or not os.path.isfile(docx_path):
-                                        raise DAError("Missing docx template file " + docx_reference.original_reference())
+                                        raise DASourceError("Missing docx template file " + docx_reference.original_reference())
                                     docx_paths.append(docx_path)
                             if len(docx_paths) == 1:
                                 docx_path = docx_paths[0]
@@ -7645,7 +7665,7 @@ def process_selections_manual(self, data):
             for key, value in sorted(data.items(), key=operator.itemgetter(1)):
                 result.append({'key': TextObject(value, question=self), 'label': TextObject(key, question=self)})
         else:
-            raise DAError("Unknown data type in manual choices selection: " + re.sub(r'[<>]', '', repr(data)))
+            raise DASourceError("Unknown data type in manual choices selection: " + re.sub(r'[<>]', '', repr(data)))
         return result
 
 
@@ -8308,9 +8328,9 @@ def read_from(self, source):
                 except Exception as errMess:
                     self.success = False
                     try:
-                        error_to_raise = DAError(f'Error reading YAML file {source.path} in the block on line {line_number}\n\nDocument source code was:\n\n---\n{source_code.strip()}\n---\n\nError was:\n\n{format_yaml_errmess(errMess, source.path, line_number)}')
+                        error_to_raise = DASourceError(f'Error reading YAML file {source.path} in the block on line {line_number}\n\nDocument source code was:\n\n---\n{source_code.strip()}\n---\n\nError was:\n\n{format_yaml_errmess(errMess, source.path, line_number)}')
                     except:
-                        error_to_raise = DAError(f'Error reading YAML file {source.path} in the block on line {line_number}\n\nDocument source code was:\n\n---\n{source_code.strip()}\n---\n\nError was:\n\n' + str(errMess.__class__.__name__))
+                        error_to_raise = DASourceError(f'Error reading YAML file {source.path} in the block on line {line_number}\n\nDocument source code was:\n\n---\n{source_code.strip()}\n---\n\nError was:\n\n' + str(errMess.__class__.__name__))
                     raise error_to_raise
                 if document is not None:
                     try:
@@ -8318,13 +8338,13 @@ def read_from(self, source):
                         self.names_used.update(question.fields_used)
                     except SyntaxException as qError:
                         self.success = False
-                        raise DAError(f"Syntax Exception: {qError}\n\nIn file {source.path} in the block on line {line_number} from package {source_package}:\n{source_code}")
+                        raise DASourceError(f"Syntax Exception: {qError}\n\nIn file {source.path} in the block on line {line_number} from package {source_package}:\n{source_code}")
                     except CompileException as qError:
                         self.success = False
-                        raise DAError(f"Compile Exception: {qError}\n\nIn file {source.path} in the block on line {line_number} from package {source_package}:\n{source_code}")
+                        raise DASourceError(f"Compile Exception: {qError}\n\nIn file {source.path} in the block on line {line_number} from package {source_package}:\n{source_code}")
                     except SyntaxError as qError:
                         self.success = False
-                        raise DAError(f"Syntax Error: {qError}\n\nIn file {source.path} in the block on line {line_number} from package {source_package}:\n{source_code}")
+                        raise DASourceError(f"Syntax Error: {qError}\n\nIn file {source.path} in the block on line {line_number} from package {source_package}:\n{source_code}")
             line_number += lines_in_code
         for ordering in self.id_orderings:
             if ordering['type'] == 'supersedes' and hasattr(ordering['question'], 'number'):
@@ -8574,7 +8594,7 @@ def assemble(self, user_dict, interview_status=None, old_user_dict=None, force_q
                 number_loops += 1
                 if number_loops > self.loop_limit:
                     docassemble.base.functions.wrap_up()
-                    raise DAError("There appears to be a circularity.  Variables involved: " + ", ".join(variables_sought) + ".")
+                    raise DASourceError("There appears to be a circularity.  Variables involved: " + ", ".join(variables_sought) + ".")
                 docassemble.base.functions.reset_gathering_mode()
                 if 'action' in interview_status.current_info:
                     # logmessage("assemble: there is an action in the current_info: " + repr(interview_status.current_info['action']))
@@ -8582,13 +8602,13 @@ def assemble(self, user_dict, interview_status=None, old_user_dict=None, force_q
                         for the_key in ('list', 'item', 'items'):
                             if the_key in interview_status.current_info['arguments']:
                                 if illegal_variable_name(interview_status.current_info['arguments'][the_key]):
-                                    raise DAError("Invalid name " + interview_status.current_info['arguments'][the_key])
+                                    raise DASourceError("Invalid name " + interview_status.current_info['arguments'][the_key])
                                 interview_status.current_info['action_' + the_key] = eval(interview_status.current_info['arguments'][the_key], user_dict)
                     if interview_status.current_info['action'] in ('_da_dict_remove', '_da_dict_add', '_da_dict_complete'):
                         for the_key in ('dict', 'item', 'items'):
                             if the_key in interview_status.current_info['arguments']:
                                 if illegal_variable_name(interview_status.current_info['arguments'][the_key]):
-                                    raise DAError("Invalid name " + interview_status.current_info['arguments'][the_key])
+                                    raise DASourceError("Invalid name " + interview_status.current_info['arguments'][the_key])
                                 interview_status.current_info['action_' + the_key] = eval(interview_status.current_info['arguments'][the_key], user_dict)
                 # else:
                 #    logmessage("assemble: there is no action in the current_info")
@@ -8721,7 +8741,7 @@ def assemble(self, user_dict, interview_status=None, old_user_dict=None, force_q
                                         interview_status.populate(the_question.ask(user_dict, old_user_dict, 'None', [], None, None))
                                         interview_status.mark_tentative_as_answered(user_dict)
                                     else:
-                                        raise DAError("An embedded question can only be a code block or a regular question block.  The question type was " + getattr(the_question, 'question_type', 'unknown'))
+                                        raise DASourceError("An embedded question can only be a code block or a regular question block.  The question type was " + getattr(the_question, 'question_type', 'unknown'))
                                 else:
                                     interview_status.populate(question.ask(user_dict, old_user_dict, 'None', [], None, None))
                                 if interview_status.question.question_type == 'continue':
@@ -8776,7 +8796,7 @@ def assemble(self, user_dict, interview_status=None, old_user_dict=None, force_q
                                 extra = " in " + errinfo.filename
                                 if hasattr(errinfo, 'lineno'):
                                     extra += " line " + str(errinfo.lineno)
-                                raise DAError("NameError: " + str(the_exception) + extra)
+                                raise DASourceError("NameError: " + str(the_exception) + extra)
                             del cl
                             del exc
                             del tb
@@ -8945,7 +8965,7 @@ def assemble(self, user_dict, interview_status=None, old_user_dict=None, force_q
                     docassemble.base.functions.reset_context()
                     # logmessage(str(the_error.args))
                     docassemble.base.functions.wrap_up()
-                    raise DAError('Got error ' + str(the_error) + " " + traceback.format_exc() + "\nHistory was " + pprint.pformat(interview_status.seeking))
+                    raise DASourceError('Got error ' + str(the_error) + " " + traceback.format_exc() + "\nHistory was " + pprint.pformat(interview_status.seeking))
                 except MandatoryQuestion:
                     # logmessage("MandatoryQuestion")
                     docassemble.base.functions.reset_context()
@@ -8967,8 +8987,8 @@ def assemble(self, user_dict, interview_status=None, old_user_dict=None, force_q
                         pass
                     docassemble.base.functions.wrap_up()
                     if the_question is not None:
-                        raise DAError(str(qError) + "\n\n" + str(self.idebug(self.data_for_debug)))
-                    raise DAError("no question available: " + str(qError))
+                        raise DASourceError(str(qError) + "\n\n" + str(self.idebug(self.data_for_debug)))
+                    raise DASourceError("no question available: " + str(qError))
                 except CompileException as qError:
                     # logmessage("CompileException")
                     docassemble.base.functions.reset_context()
@@ -8979,8 +8999,8 @@ def assemble(self, user_dict, interview_status=None, old_user_dict=None, force_q
                         pass
                     docassemble.base.functions.wrap_up()
                     if the_question is not None:
-                        raise DAError(str(qError) + "\n\n" + str(self.idebug(self.data_for_debug)))
-                    raise DAError("no question available: " + str(qError))
+                        raise DASourceError(str(qError) + "\n\n" + str(self.idebug(self.data_for_debug)))
+                    raise DASourceError("no question available: " + str(qError))
                 else:
                     docassemble.base.functions.wrap_up()
                     raise DAErrorNoEndpoint('Docassemble has finished executing all code blocks marked as initial or mandatory, and finished asking all questions marked as mandatory (if any).  It is a best practice to end your interview with a question that says goodbye and offers an Exit button.')
@@ -9021,13 +9041,13 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
         if self.debug:
             seeking.append({'variable': missingVariable, 'time': time.time()})
         if recursion_depth > self.recursion_limit:
-            raise DAError("There appears to be an infinite loop.  Variables in stack are " + ", ".join(sorted(variable_stack)) + ".")
+            raise DASourceError("There appears to be an infinite loop.  Variables in stack are " + ", ".join(sorted(variable_stack)) + ".")
         # logmessage("askfor: I don't have " + str(missingVariable) + " for language " + str(language))
         # logmessage("I don't have " + str(missingVariable) + " for language " + str(language))
         origMissingVariable = missingVariable
         docassemble.base.functions.set_current_variable(origMissingVariable)
         # if missingVariable in variable_stack:
-        #     raise DAError("Infinite loop: " + missingVariable + " already looked for, where stack is " + str(variable_stack))
+        #     raise DASourceError("Infinite loop: " + missingVariable + " already looked for, where stack is " + str(variable_stack))
         # variable_stack.add(missingVariable)
         # found_generic = False
         # realMissingVariable = missingVariable
@@ -9078,7 +9098,7 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
         while True:
             num_cycles += 1
             if num_cycles > self.loop_limit:
-                raise DAError("Infinite loop detected while looking for " + missing_var)
+                raise DASourceError("Infinite loop detected while looking for " + missing_var)
             a_question_was_skipped = False
             docassemble.base.functions.reset_gathering_mode(origMissingVariable)
             # logmessage("Starting the while loop")
@@ -9370,14 +9390,14 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
                                         try:
                                             urlretrieve(url_sanitize(str(the_filename)), temp_template_file.name)
                                         except Exception as err:
-                                            raise DAError("askfor: error downloading " + str(the_filename) + ": " + str(err))
+                                            raise DASourceError("askfor: error downloading " + str(the_filename) + ": " + str(err))
                                         the_filename = temp_template_file.name
                                 else:
                                     the_filename = docassemble.base.functions.package_template_filename(the_filename, package=question.package)
                             else:
                                 the_filename = None
                             if the_filename is None or not os.path.isfile(the_filename):
-                                raise DAError("askfor: error obtaining template file from code: " + repr(the_orig_filename))
+                                raise DASourceError("askfor: error obtaining template file from code: " + repr(the_orig_filename))
                             with open(the_filename, 'r', encoding='utf-8') as the_file:
                                 raw_content += the_file.read()
                         temp_vars = {}
@@ -9530,7 +9550,7 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
                             continue
                         return question.ask(user_dict, old_user_dict, the_x, iterators, missing_var, origMissingVariable)
                 if a_question_was_skipped:
-                    raise DAError("Infinite loop: " + missingVariable + " already looked for, where stack is " + str(variable_stack))
+                    raise DASourceError("Infinite loop: " + missingVariable + " already looked for, where stack is " + str(variable_stack))
                 if 'forgive_missing_question' in docassemble.base.functions.this_thread.misc and origMissingVariable in docassemble.base.functions.this_thread.misc['forgive_missing_question']:
                     docassemble.base.functions.pop_current_variable()
                     docassemble.base.functions.pop_event_stack(origMissingVariable)
@@ -9601,7 +9621,7 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
                             extra = " in " + errinfo.filename
                             if hasattr(errinfo, 'lineno'):
                                 extra += " line " + str(errinfo.lineno)
-                            raise DAError("NameError: " + str(the_exception) + extra)
+                            raise DASourceError("NameError: " + str(the_exception) + extra)
                         del cl
                         del exc
                         del tb
@@ -9611,7 +9631,7 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
                     raise
                 # newMissingVariable = str(the_exception).split("'")[1]
                 # if newMissingVariable in questions_tried and newMissingVariable in variable_stack:
-                #    raise DAError("Infinite loop: " + missingVariable + " already looked for, where stack is " + str(variable_stack))
+                #    raise DASourceError("Infinite loop: " + missingVariable + " already looked for, where stack is " + str(variable_stack))
                 if newMissingVariable not in questions_tried:
                     questions_tried[newMissingVariable] = set()
                 else:
@@ -9784,7 +9804,7 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
                     # logmessage("Got here 2")
                     return {'type': 'continue', 'sought': missing_var, 'orig_sought': origMissingVariable}
                 except:
-                    # raise DAError("Problem setting that variable")
+                    # raise DASourceError("Problem setting that variable")
                     continue
             except SyntaxException as qError:
                 # logmessage("SyntaxException")
@@ -9795,8 +9815,8 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
                 except:
                     pass
                 if the_question is not None:
-                    raise DAError(str(qError) + "\n\n" + str(self.idebug(self.data_for_debug)))
-                raise DAError("no question available in askfor: " + str(qError))
+                    raise DASourceError(str(qError) + "\n\n" + str(self.idebug(self.data_for_debug)))
+                raise DASourceError("no question available in askfor: " + str(qError))
             except CompileException as qError:
                 # logmessage("CompileException")
                 docassemble.base.functions.reset_context()
@@ -9806,8 +9826,8 @@ def askfor(self, missingVariable, user_dict, old_user_dict, interview_status, **
                 except:
                     pass
                 if the_question is not None:
-                    raise DAError(str(qError) + "\n\n" + str(self.idebug(self.data_for_debug)))
-                raise DAError("no question available in askfor: " + str(qError))
+                    raise DASourceError(str(qError) + "\n\n" + str(self.idebug(self.data_for_debug)))
+                raise DASourceError("no question available in askfor: " + str(qError))
             # except SendFileError as qError:
             #     # logmessage("Trapped SendFileError2")
             #     question_data = {'extras': {}}
@@ -9973,7 +9993,7 @@ def process_selections(data, exclude=None):
                 else:
                     logmessage("process_selections: non-label passed as label in dictionary")
     else:
-        raise DAError("Unknown data type in choices selection: " + re.sub(r'[<>]', '', repr(data)))
+        raise DASourceError("Unknown data type in choices selection: " + re.sub(r'[<>]', '', repr(data)))
     return result
 
 
@@ -10079,7 +10099,7 @@ def ensure_object_exists(saveas, datatype, the_user_dict, commands=None):
         return
     parse_result = parse_var_name(saveas)
     if not parse_result['valid']:
-        raise DAError("Variable name " + saveas + " is invalid: " + parse_result['reason'])
+        raise DASourceError("Variable name " + saveas + " is invalid: " + parse_result['reason'])
     method = None
     if parse_result['final_parts'][1] != '':
         if parse_result['final_parts'][1][0] == '.':
@@ -10732,7 +10752,7 @@ def register_jinja_filter(filter_name, func):
 def get_docx_variables(the_path):
     names = set()
     if not os.path.isfile(the_path):
-        raise DAError("Missing docx template file " + os.path.basename(the_path))
+        raise DASourceError("Missing docx template file " + os.path.basename(the_path))
     try:
         docx_template = DocxTemplate(the_path)
         docx_template.render_init()
@@ -10743,7 +10763,7 @@ def get_docx_variables(the_path):
         the_xml = docx_template.patch_xml(the_xml)
         parsed_content = the_env.parse(the_xml)
     except Exception as the_err:
-        raise DAError("There was an error parsing the docx file: " + the_err.__class__.__name__ + " " + str(the_err))
+        raise DASourceError("There was an error parsing the docx file: " + the_err.__class__.__name__ + " " + str(the_err))
     for key in jinja2meta.find_undeclared_variables(parsed_content):
         if not key.startswith('__'):
             names.add(key)
diff --git a/docassemble_base/docassemble/base/pdftk.py b/docassemble_base/docassemble/base/pdftk.py
index fc7cb5982..b2c755ff3 100644
--- a/docassemble_base/docassemble/base/pdftk.py
+++ b/docassemble_base/docassemble/base/pdftk.py
@@ -160,7 +160,7 @@ def recursively_add_fields(fields, id_to_page, outfields, prefix='', parent_ft=N
                 outfields.append((prefix, default, pageno, rect, field_type, export_value))
 
 
-def fill_template(template, data_strings=None, data_names=None, hidden=None, readonly=None, images=None, pdf_url=None, editable=True, pdfa=False, password=None, owner_password=None, template_password=None, default_export_value=None, replacement_font=None):
+def fill_template(template, data_strings=None, data_names=None, hidden=None, readonly=None, images=None, pdf_url=None, editable=True, pdfa=False, password=None, owner_password=None, template_password=None, default_export_value=None, replacement_font=None, use_pdftk=False):
     if data_strings is None:
         data_strings = []
     if data_names is None:
@@ -219,7 +219,7 @@ def fill_template(template, data_strings=None, data_names=None, hidden=None, rea
     for key, val in data_strings:
         data_dict[key] = val
     pdf_file = tempfile.NamedTemporaryFile(prefix="datemp", mode="wb", suffix=".pdf", delete=False)
-    if pdfa or not editable:
+    if pdfa or not editable or use_pdftk:
         fdf = Xfdf(pdf_url, data_dict)
         # fdf = fdfgen.forge_fdf(pdf_url, data_strings, data_names, hidden, readonly)
         fdf_file = tempfile.NamedTemporaryFile(prefix="datemp", mode="wb", suffix=".xfdf", delete=False)
@@ -251,7 +251,10 @@ def fill_template(template, data_strings=None, data_names=None, hidden=None, rea
         if len(images) > 0:
             subprocess_arguments.append('need_appearances')
         else:
-            subprocess_arguments.append('flatten')
+            if pdfa or not editable:
+                subprocess_arguments.append('flatten')
+            else:
+                subprocess_arguments.append('need_appearances')
         completed_process = None
         try:
             completed_process = subprocess.run(subprocess_arguments, timeout=600, check=False, capture_output=True)
@@ -272,7 +275,6 @@ def fill_template(template, data_strings=None, data_names=None, hidden=None, rea
             pdf = Pdf.open(template, password=template_password)
         else:
             pdf = Pdf.open(template)
-        pdf.Root.AcroForm.NeedAppearances = True
         for page in pdf.pages:
             if not hasattr(page, 'Annots'):
                 continue
@@ -320,6 +322,9 @@ def fill_template(template, data_strings=None, data_names=None, hidden=None, rea
                         the_string = pikepdf.String(value)
                         annot.V = the_string
                         annot.DV = the_string
+        pdf.Root.AcroForm.NeedAppearances = True
+        pdf.generate_appearance_streams()
+        pdf.Root.AcroForm.NeedAppearances = True
         if len(images) == 0:
             pdf.save(pdf_file.name)
             pdf.close()
diff --git a/docassemble_webapp/docassemble/webapp/develop.py b/docassemble_webapp/docassemble/webapp/develop.py
index 7cf0ae29f..d76f63819 100644
--- a/docassemble_webapp/docassemble/webapp/develop.py
+++ b/docassemble_webapp/docassemble/webapp/develop.py
@@ -2,6 +2,7 @@
 from flask_wtf import FlaskForm
 from docassemble.base.functions import LazyWord as word
 from wtforms import validators, ValidationError, StringField, SubmitField, TextAreaField, SelectMultipleField, SelectField, FileField, HiddenField, RadioField, BooleanField
+from docassemble.webapp.validators import html_validator
 import packaging
 
 
@@ -37,21 +38,21 @@ def validate_package_name(form, field):  # pylint: disable=unused-argument
 
 class CreatePackageForm(FlaskForm):
     name = StringField(word('Package name'), validators=[
-        validators.DataRequired(word('Package name is required')), validate_name])
+        validators.DataRequired(word('Package name is required')), validate_name, html_validator])
     submit = SubmitField(word('Get template'))
 
 
 class CreatePlaygroundPackageForm(FlaskForm):
     name = SelectField(word('Package'), validators=[
-        validators.DataRequired(word('Package name is required')), validate_name])
+        validators.DataRequired(word('Package name is required')), validate_name, html_validator])
     submit = SubmitField(word('Get package'))
 
 
 class UpdatePackageForm(FlaskForm):
-    giturl = StringField(word('GitHub URL'))
-    gitbranch = SelectField(word('GitHub Branch'))
+    giturl = StringField(word('GitHub URL'), validators=[html_validator])
+    gitbranch = SelectField(word('GitHub Branch'), validators=[html_validator])
     zipfile = FileField(word('Zip File'))
-    pippackage = StringField(word('Package on PyPI'))
+    pippackage = StringField(word('Package on PyPI'), validators=[html_validator])
     submit = SubmitField(word('Update'))
 
 
@@ -64,7 +65,7 @@ class ConfigForm(FlaskForm):
 class PlaygroundForm(FlaskForm):
     status = StringField('Status')
     original_playground_name = StringField(word('Original Name'))
-    playground_name = StringField(word('Name'), [validators.Length(min=1, max=255)])
+    playground_name = StringField(word('Name'), [validators.Length(min=1, max=255), html_validator])
     playground_content = TextAreaField(word('Playground YAML'))
     search_term = StringField(word('Search'))
     submit = SubmitField(word('Save'))
@@ -108,7 +109,7 @@ class PlaygroundFilesEditForm(FlaskForm):
     purpose = StringField('Purpose')
     section = StringField(word('Section'))
     original_file_name = StringField(word('Original Name'))
-    file_name = StringField(word('Name'), [validators.Length(min=1, max=255)])
+    file_name = StringField(word('Name'), [validators.Length(min=1, max=255), html_validator])
     search_term = StringField(word('Search'))
     file_content = TextAreaField(word('File Text'))
     active_file = StringField(word('Active File'))
@@ -118,7 +119,7 @@ class PlaygroundFilesEditForm(FlaskForm):
 
 class RenameProject(FlaskForm):
     name = StringField(word('New Name'), validators=[
-        validators.DataRequired(word('Project name is required')), validate_project_name])
+        validators.DataRequired(word('Project name is required')), validate_project_name, html_validator])
     submit = SubmitField(word('Rename'))
 
 
@@ -128,29 +129,29 @@ class DeleteProject(FlaskForm):
 
 class NewProject(FlaskForm):
     name = StringField(word('Name'), validators=[
-        validators.DataRequired(word('Project name is required')), validate_project_name])
+        validators.DataRequired(word('Project name is required')), validate_project_name, html_validator])
     submit = SubmitField(word('Save'))
 
 
 class PullPlaygroundPackage(FlaskForm):
-    github_url = StringField(word('GitHub URL'))
-    github_branch = SelectField(word('GitHub Branch'))
-    pypi = StringField(word('PyPI package'))
+    github_url = StringField(word('GitHub URL'), validators=[html_validator])
+    github_branch = SelectField(word('GitHub Branch'), validators=[html_validator])
+    pypi = StringField(word('PyPI package'), validators=[html_validator])
     pull = SubmitField(word('Pull'))
     cancel = SubmitField(word('Cancel'))
 
 
 class PlaygroundPackagesForm(FlaskForm):
-    original_file_name = StringField(word('Original Name'))
+    original_file_name = StringField(word('Original Name'), validators=[html_validator])
     file_name = StringField(word('Package Name'), validators=[validators.Length(min=1, max=50),
                                                               validators.DataRequired(word('Package Name is required')),
-                                                              validate_package_name])
-    license = StringField(word('License'), default='The MIT License (MIT)', validators=[validators.Length(min=0, max=255)])
-    author_name = StringField(word('Author Name'), validators=[validators.Length(min=0, max=255)])
-    author_email = StringField(word('Author E-mail'), validators=[validators.Length(min=0, max=255)])
-    description = StringField(word('Description'), validators=[validators.Length(min=0, max=255)], default="A docassemble extension.")
-    version = StringField(word('Version'), validators=[validators.Length(min=0, max=255), validate_package_version], default="0.0.1")
-    url = StringField(word('URL'), validators=[validators.Length(min=0, max=255)], default="")
+                                                              validate_package_name, html_validator])
+    license = StringField(word('License'), default='The MIT License (MIT)', validators=[validators.Length(min=0, max=255), html_validator])
+    author_name = StringField(word('Author Name'), validators=[validators.Length(min=0, max=255), html_validator])
+    author_email = StringField(word('Author E-mail'), validators=[validators.Length(min=0, max=255), html_validator])
+    description = StringField(word('Description'), validators=[validators.Length(min=0, max=255), html_validator], default="A docassemble extension.")
+    version = StringField(word('Version'), validators=[validators.Length(min=0, max=255), validate_package_version, html_validator], default="0.0.1")
+    url = StringField(word('URL'), validators=[validators.Length(min=0, max=255), html_validator], default="")
     dependencies = SelectMultipleField(word('Dependencies'))
     interview_files = SelectMultipleField(word('Interview files'))
     template_files = SelectMultipleField(word('Template files'))
@@ -159,7 +160,7 @@ class PlaygroundPackagesForm(FlaskForm):
     sources_files = SelectMultipleField(word('Source files'))
     readme = TextAreaField(word('README file'), default='')
     github_branch = NonValidatingSelectField(word('Branch'))
-    github_branch_new = StringField(word('Name of new branch'))
+    github_branch_new = StringField(word('Name of new branch'), validators=[html_validator])
     commit_message = StringField(word('Commit message'), default="")
     pypi_also = BooleanField(word('Publish on PyPI also'))
     install_also = BooleanField(word('Install package on this server also'))
@@ -222,7 +223,7 @@ class APIKey(FlaskForm):
     action = HiddenField()
     key = HiddenField()
     security = HiddenField()
-    name = StringField(word('Name'), validators=[validators.Length(min=1, max=255)])
+    name = StringField(word('Name'), validators=[validators.Length(min=1, max=255), html_validator])
     method = SelectField(word('Security Method'))
     permissions = SelectMultipleField(word('Limited Permissions'))
     submit = SubmitField(word('Create'))
diff --git a/docassemble_webapp/docassemble/webapp/server.py b/docassemble_webapp/docassemble/webapp/server.py
index 19389d818..0f48166cd 100644
--- a/docassemble_webapp/docassemble/webapp/server.py
+++ b/docassemble_webapp/docassemble/webapp/server.py
@@ -49,7 +49,7 @@
 from docassemble.webapp.setup import da_version
 import docassemble.base.astparser
 from docassemble.webapp.api_key import encrypt_api_key
-from docassemble.base.error import DAError, DAErrorNoEndpoint, DAErrorMissingVariable, DAErrorCompileError, DAValidationError, DAException, DANotFoundError, DAInvalidFilename
+from docassemble.base.error import DAError, DAErrorNoEndpoint, DAErrorMissingVariable, DAErrorCompileError, DAValidationError, DAException, DANotFoundError, DAInvalidFilename, DASourceError
 import docassemble.base.functions
 from docassemble.base.functions import get_default_timezone, ReturnValue, word
 import docassemble.base.DA
@@ -159,7 +159,6 @@
 docassemble.base.util.set_svm_machine_learner(docassemble.webapp.machinelearning.SVMMachineLearner)
 
 
-
 min_system_version = '1.2.0'
 re._MAXCACHE = 10000
 
@@ -1178,12 +1177,17 @@ def my_default_url(error, endpoint, values):  # pylint: disable=unused-argument
 
 
 def make_safe_url(url):
+    if url in ('help', 'login', 'signin', 'restart', 'new_session', 'exit', 'interview', 'logout', 'exit_logout', 'leave', 'register', 'profile', 'change_password', 'interviews', 'dispatch', 'manage', 'config', 'playground', 'playgroundtemplate', 'playgroundstatic', 'playgroundsources', 'playgroundmodules', 'playgroundpackages', 'configuration', 'root', 'temp_url', 'login_url', 'exit_endpoint', 'interview_start', 'interview_list', 'playgroundfiles', 'create_playground_package', 'run', 'run_interview_in_package', 'run_dispatch', 'run_new', 'run_new_dispatch'):
+        return url
     parts = urlsplit(url)
     safe_url = parts.path
     if parts.query != '':
         safe_url += '?' + parts.query
     if parts.fragment != '':
         safe_url += '#' + parts.fragment
+    if len(safe_url) > 0 and safe_url[0] not in ('?', '#', '/'):
+        safe_url = '/' + safe_url
+    safe_url = re.sub(r'^//+', '/', safe_url)
     return safe_url
 
 
@@ -1238,6 +1242,7 @@ def password_validator(form, field):  # pylint: disable=unused-argument
 if DEBUG_BOOT:
     boot_log("server: finished setting up Flask")
 
+
 def url_for_interview(**args):
     for k, v in daconfig.get('dispatch').items():
         if v == args['i']:
@@ -5840,7 +5845,7 @@ def github_oauth_callback():
         return ('File not found', 404)
     setup_translation()
     failed = False
-    do_redirect = False
+    do_a_redirect = False
     if not app.config['USE_GITHUB']:
         logmessage('github_oauth_callback: server does not use github')
         failed = True
@@ -5853,14 +5858,14 @@ def github_oauth_callback():
         if 'code' not in request.args or 'state' not in request.args:
             logmessage('github_oauth_callback: code and state not in args')
             failed = True
-            do_redirect = True
+            do_a_redirect = True
         elif request.args['state'] != github_next['state']:
             logmessage('github_oauth_callback: state did not match')
             failed = True
     if failed:
         r.delete('da:github:userid:' + str(current_user.id))
         r.delete('da:using_github:userid:' + str(current_user.id))
-        if do_redirect:
+        if do_a_redirect:
             flash(word("There was a problem connecting to GitHub. Please check your GitHub configuration and try again."), 'danger')
             return redirect(url_for('github_menu'))
         return ('File not found', 404)
@@ -8265,7 +8270,7 @@ def index(action_argument=None, refer=None):
                     the_field = validation_error.field
                     logmessage("field is " + the_field)
                     if the_field not in key_to_orig_key:
-                        for item in key_to_orig_key.keys():
+                        for item in key_to_orig_key:
                             if item.startswith(the_field + '['):
                                 the_field = item
                                 break
@@ -10915,7 +10920,7 @@ def index(action_argument=None, refer=None):
         $(query).each(function(){
           var showIfParent = $(this).parents('.dashowif,.dajsshowif');
           if (!(showIfParent.length && ($(showIfParent[0]).data('isVisible') == '0' || !$(showIfParent[0]).is(":visible")))){
-            if ($(this).hasClass('combobox')){
+            if ($(this).prop('tagName') == 'INPUT' && $(this).hasClass('combobox')){
               if (value){
                 daComboBoxes[$(this).attr('id')].disable();
               }
@@ -14001,7 +14006,7 @@ def observer():
         $(query).each(function(){
           var showIfParent = $(this).parents('.dashowif, .dajsshowif');
           if (!(showIfParent.length && ($(showIfParent[0]).data('isVisible') == '0' || !$(showIfParent[0]).is(":visible")))){
-            if ($(this).hasClass('combobox')){
+            if ($(this).prop('tagName') == 'INPUT' && $(this).hasClass('combobox')){
               if (value){
                 daComboBoxes[$(this).attr('id')].disable();
               }
@@ -23043,7 +23048,14 @@ def server_error(the_error):
     else:
         the_history = None
     the_vars = None
-    if isinstance(the_error, (DAError, DANotFoundError, DAInvalidFilename)):
+    if isinstance(the_error, DASourceError):
+        if (DEBUG and daconfig.get('development site is protected', False)) or (current_user.is_authenticated and current_user.has_role('admin', 'developer')):
+            errmess = str(the_error)
+        else:
+            errmess = word("There was an error. Please contact the system administrator.")
+        the_trace = None
+        logmessage(str(the_error))
+    elif isinstance(the_error, (DAError, DANotFoundError, DAInvalidFilename)):
         errmess = str(the_error)
         the_trace = None
         logmessage(errmess)
@@ -23073,7 +23085,10 @@ def server_error(the_error):
             errmess += "\nIn field index number " + str(docassemble.base.functions.this_thread.misc['current_field'])
         if hasattr(the_error, 'da_line_with_error'):
             errmess += "\nIn line: " + str(the_error.da_line_with_error)
-
+        try:
+            logmessage(errmess)
+        except:
+            logmessage("Could not log the error message")
         logmessage(the_trace)
     if isinstance(the_error, DAError):
         error_code = the_error.error_code
@@ -23296,7 +23311,7 @@ def server_error(the_error):
         if 'in error' not in session and docassemble.base.functions.this_thread.interview is not None and 'error action' in docassemble.base.functions.this_thread.interview.consolidated_metadata:
             session['in error'] = True
             return index(action_argument={'action': docassemble.base.functions.this_thread.interview.consolidated_metadata['error action'], 'arguments': {'error_message': orig_errmess, 'error_history': the_history, 'error_trace': the_trace}}, refer=['error'])
-    show_debug = not bool((not DEBUG) and isinstance(the_error, (DAError, DAInvalidFilename)))
+    show_debug = not bool((not (DEBUG and daconfig.get('development site is protected', False))) and isinstance(the_error, (DAError, DAInvalidFilename)))
     if int(int(error_code)/100) == 4:
         show_debug = False
     if error_code == 404:
@@ -27000,6 +27015,7 @@ def invite_user(email_address, privilege=None, send=True):
         return None
     return accept_invite_link
 
+
 @app.route('/api/user_invite', methods=['POST'])
 @csrf.exempt
 @cross_origin(origins='*', methods=['POST', 'HEAD'], automatic_options=True)
diff --git a/docassemble_webapp/docassemble/webapp/users/forms.py b/docassemble_webapp/docassemble/webapp/users/forms.py
index c3f3ef915..981b24104 100644
--- a/docassemble_webapp/docassemble/webapp/users/forms.py
+++ b/docassemble_webapp/docassemble/webapp/users/forms.py
@@ -5,6 +5,9 @@
 from wtforms import DateField, StringField, SubmitField, ValidationError, BooleanField, SelectField, SelectMultipleField, HiddenField, validators, TextAreaField
 from wtforms.validators import DataRequired, Email, Optional
 from wtforms.widgets import PasswordInput
+from flask import flash, current_app, request, abort
+from flask_login import current_user
+from sqlalchemy import select
 from docassemble.base.functions import LazyWord as word, LazyArray
 from docassemble.base.config import daconfig
 from docassemble.base.generate_key import random_alphanumeric
@@ -12,9 +15,7 @@
 from docassemble.webapp.daredis import r
 from docassemble.webapp.db_object import db
 from docassemble.webapp.users.models import UserModel, Role
-from flask import flash, current_app, request, abort
-from flask_login import current_user
-from sqlalchemy import select
+from docassemble.webapp.validators import html_validator
 try:
     import ldap
 except ImportError:
@@ -207,21 +208,22 @@ def da_registration_restrict_validator(form, field):  # pylint: disable=unused-a
 
 
 class MyRegisterForm(RegisterForm):
-    first_name = StringField(word('First name'), [validators.Length(min=0, max=255)])
-    last_name = StringField(word('Last name'), [validators.Length(min=0, max=255)])
-    country = StringField(word('Country code'), [validators.Length(min=0, max=2)])
-    subdivisionfirst = StringField(word('First subdivision'), [validators.Length(min=0, max=64)])
-    subdivisionsecond = StringField(word('Second subdivision'), [validators.Length(min=0, max=64)])
-    subdivisionthird = StringField(word('Third subdivision'), [validators.Length(min=0, max=64)])
-    organization = StringField(word('Organization'), [validators.Length(min=0, max=64)])
-    language = StringField(word('Language'), [validators.Length(min=0, max=64)])
-    timezone = SelectField(word('Time Zone'), [validators.Length(min=0, max=64)])
-    nickname = StringField(word('Nickname'), [fix_nickname])
+    first_name = StringField(word('First name'), [validators.Length(min=0, max=255), html_validator])
+    last_name = StringField(word('Last name'), [validators.Length(min=0, max=255), html_validator])
+    country = StringField(word('Country code'), [validators.Length(min=0, max=2), html_validator])
+    subdivisionfirst = StringField(word('First subdivision'), [validators.Length(min=0, max=64), html_validator])
+    subdivisionsecond = StringField(word('Second subdivision'), [validators.Length(min=0, max=64), html_validator])
+    subdivisionthird = StringField(word('Third subdivision'), [validators.Length(min=0, max=64), html_validator])
+    organization = StringField(word('Organization'), [validators.Length(min=0, max=64), html_validator])
+    language = StringField(word('Language'), [validators.Length(min=0, max=64), html_validator])
+    timezone = SelectField(word('Time Zone'), [validators.Length(min=0, max=64), html_validator])
+    nickname = StringField(word('Nickname'), [fix_nickname, html_validator])
     email = StringField(word('Email'), validators=[
         validators.DataRequired(word('Email is required')),
         validators.Email(word('Invalid Email')),
         da_unique_email_validator,
-        da_registration_restrict_validator])
+        da_registration_restrict_validator,
+        html_validator])
 
 
 def length_two(form, field):  # pylint: disable=unused-argument
@@ -236,16 +238,16 @@ class NewPrivilegeForm(FlaskForm):
 
 
 class UserProfileForm(FlaskForm):
-    first_name = StringField(word('First name'), [validators.Length(min=0, max=255)])
-    last_name = StringField(word('Last name'), [validators.Length(min=0, max=255)])
-    country = StringField(word('Country code'), [validators.Length(min=0, max=2)])
-    subdivisionfirst = StringField(word('First subdivision'), [validators.Length(min=0, max=64)])
-    subdivisionsecond = StringField(word('Second subdivision'), [validators.Length(min=0, max=64)])
-    subdivisionthird = StringField(word('Third subdivision'), [validators.Length(min=0, max=64)])
-    organization = StringField(word('Organization'), [validators.Length(min=0, max=64)])
-    language = StringField(word('Language'), [validators.Length(min=0, max=64)])
-    timezone = SelectField(word('Time Zone'), [validators.Length(min=0, max=64)])
-    pypi_username = StringField(word('PyPI Username'), [validators.Length(min=0, max=255)])
+    first_name = StringField(word('First name'), [validators.Length(min=0, max=255), html_validator])
+    last_name = StringField(word('Last name'), [validators.Length(min=0, max=255), html_validator])
+    country = StringField(word('Country code'), [validators.Length(min=0, max=2), html_validator])
+    subdivisionfirst = StringField(word('First subdivision'), [validators.Length(min=0, max=64), html_validator])
+    subdivisionsecond = StringField(word('Second subdivision'), [validators.Length(min=0, max=64), html_validator])
+    subdivisionthird = StringField(word('Third subdivision'), [validators.Length(min=0, max=64), html_validator])
+    organization = StringField(word('Organization'), [validators.Length(min=0, max=64), html_validator])
+    language = StringField(word('Language'), [validators.Length(min=0, max=64), html_validator])
+    timezone = SelectField(word('Time Zone'), [validators.Length(min=0, max=64), html_validator])
+    pypi_username = StringField(word('PyPI Username'), [validators.Length(min=0, max=255), html_validator])
     pypi_password = StringField(word('PyPI Password'), [validators.Length(min=0, max=255)])
     confirmed_at = DateField(word('Confirmation Date'))
     submit = SubmitField(word('Save'))
@@ -253,7 +255,7 @@ class UserProfileForm(FlaskForm):
 
 
 class EditUserProfileForm(UserProfileForm):
-    email = StringField(word('E-mail'))
+    email = StringField(word('E-mail'), validators=[Email(word('Must be a valid e-mail address')), html_validator])
     role_id = SelectMultipleField(word('Privileges'), coerce=int)
     active = BooleanField(word('Active'))
     uses_mfa = BooleanField(word('Uses two-factor authentication'))
@@ -299,11 +301,11 @@ def validate(self):  # pylint: disable=arguments-differ
                     flash(word("Please choose a different e-mail address."), 'error')
                     return False
         return super().validate()
-    email = StringField(word('E-mail'), validators=[Optional(), Email(word('Must be a valid e-mail address'))])
+    email = StringField(word('E-mail'), validators=[Optional(), Email(word('Must be a valid e-mail address')), html_validator])
 
 
 class RequestDeveloperForm(FlaskForm):
-    reason = StringField(word('Reason for needing developer account (optional)'))
+    reason = StringField(word('Reason for needing developer account (optional)'), validators=[html_validator])
     submit = SubmitField(word('Submit'))
 
 
@@ -334,21 +336,21 @@ class UserAddForm(FlaskForm):
     email = StringField(word('E-mail'), validators=[
         validators.InputRequired(word('E-mail is required')),
         validators.Email(word('Invalid E-mail'))])
-    first_name = StringField(word('First name'), [validators.Length(min=0, max=255)])
-    last_name = StringField(word('Last name'), [validators.Length(min=0, max=255)])
+    first_name = StringField(word('First name'), [validators.Length(min=0, max=255), html_validator])
+    last_name = StringField(word('Last name'), [validators.Length(min=0, max=255), html_validator])
     role_id = SelectMultipleField(word('Privileges'), coerce=int)
     password = StringField(word('Password'), widget=PasswordInput(hide_value=False), validators=[password_validator])
     submit = SubmitField(word('Add'))
 
 
 class PhoneLoginForm(FlaskForm):
-    phone_number = StringField(word('Phone number'), [validators.Length(min=5, max=255)])
+    phone_number = StringField(word('Phone number'), [validators.Length(min=5, max=255), html_validator])
     submit = SubmitField(word('Go'))
 
 
 class PhoneLoginVerifyForm(FlaskForm):
-    phone_number = StringField(word('Phone number'), [validators.Length(min=5, max=255)])
-    verification_code = StringField(word('Verification code'), [validators.Length(min=daconfig['verification code digits'], max=daconfig['verification code digits'])])
+    phone_number = StringField(word('Phone number'), [validators.Length(min=5, max=255), html_validator])
+    verification_code = StringField(word('Verification code'), [validators.Length(min=daconfig['verification code digits'], max=daconfig['verification code digits']), html_validator])
     submit = SubmitField(word('Verify'))
 
     def validate(self):  # pylint: disable=arguments-differ
@@ -404,7 +406,7 @@ class MFAChooseForm(FlaskForm):
 
 
 class MFASMSSetupForm(FlaskForm):
-    phone_number = StringField(word('Phone number'), [validators.Length(min=5, max=255)])
+    phone_number = StringField(word('Phone number'), [validators.Length(min=5, max=255), html_validator])
     submit = SubmitField(word('Verify'))
 
 
@@ -416,8 +418,8 @@ class MFAVerifySMSSetupForm(FlaskForm):
 class MyResendConfirmEmailForm(FlaskForm):
     email = StringField(word('Your e-mail address'), validators=[
         validators.DataRequired(word('E-mail address is required')),
-        validators.Email(word('Invalid e-mail address')),
-        ])
+        validators.Email(word('Invalid e-mail address'))
+    ])
     submit = SubmitField(word('Send confirmation email'))
 
 
diff --git a/docassemble_webapp/docassemble/webapp/validators.py b/docassemble_webapp/docassemble/webapp/validators.py
new file mode 100644
index 000000000..fab3a24cf
--- /dev/null
+++ b/docassemble_webapp/docassemble/webapp/validators.py
@@ -0,0 +1,10 @@
+from bs4 import BeautifulSoup
+from wtforms import ValidationError
+from docassemble.base.functions import LazyWord as word
+
+
+def html_validator(form, field):  # pylint: disable=unused-argument
+    """Field must not contain HTML"""
+    text = BeautifulSoup(field.data, "html.parser").get_text('')
+    if text != field.data:
+        raise ValidationError(word('Field cannot contain HTML'))", "url": "https://github.com/jhpyle/docassemble/commit/4801ac7ff7c90df00ac09523077930cdb6dea2aa.patch" } ]
null
GHSA-2fvv-qxrq-7jq6
apollo-server-core vulnerable to URL-based XSS attack affecting IE11 on default landing page
null
[ { "commit_message": "[PATCH] Merge pull request from GHSA-2fvv-qxrq-7jq6 See https://github.com/apollographql/apollo-server/security/advisories/GHSA-2fvv-qxrq-7jq6 for details. Note that this doesn't affect the curl command shown in the colorful rendered non-embedded landing page, which is properly escaped by the React app. CHANGELOG.md | 4 ++++ .../__tests__/getEmbeddedExplorerHTML.test.ts | 16 ++++++++++++++ .../__tests__/getEmbeddedSandboxHTML.test.ts | 16 ++++++++++++++ .../src/plugin/landingPage/default/index.ts | 21 +++++++++++-------- 4 files changed, 48 insertions(+), 9 deletions(-)", "patch_text_b64": "From 68a439b6e3af9edc8a2480092f2d49f058be1e64 Mon Sep 17 00:00:00 2001
From: David Glasser <glasser@davidglasser.net>
Date: Wed, 10 Aug 2022 09:59:03 -0700
Subject: [PATCH] Merge pull request from GHSA-2fvv-qxrq-7jq6

See
https://github.com/apollographql/apollo-server/security/advisories/GHSA-2fvv-qxrq-7jq6
for details.

Note that this doesn't affect the curl command shown in the colorful
rendered non-embedded landing page, which is properly escaped by the
React app.
---
 CHANGELOG.md                                  |  4 ++++
 .../__tests__/getEmbeddedExplorerHTML.test.ts | 16 ++++++++++++++
 .../__tests__/getEmbeddedSandboxHTML.test.ts  | 16 ++++++++++++++
 .../src/plugin/landingPage/default/index.ts   | 21 +++++++++++--------
 4 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cf006239b34..16335c65314 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,10 @@ The version headers in this history reflect the versions of Apollo Server itself
 
 ## vNEXT
 
+## v3.10.1
+
+- ⚠️ **SECURITY**: The default landing page contained HTML to display a sample `curl` command which is made visible if the full landing page bundle could not be fetched from Apollo's CDN. The server's URL is directly interpolated into this command inside the browser from `window.location.href`. On some older browsers such as IE11, this value is not URI-encoded. On such browsers, opening a malicious URL pointing at an Apollo Router could cause execution of attacker-controlled JavaScript. In this release, the fallback page does not display a `curl` command. More details are available at the [security advisory](https://github.com/apollographql/apollo-server/security/advisories/GHSA-2fvv-qxrq-7jq6).
+- Improve error message when both a graph ref and a graph variant are specified. [PR #6709](https://github.com/apollographql/apollo-server/pull/6709)
 - Fix the TypeScript declaration of the `fieldLevelInstrumentation` option to `ApolloServerPluginUsageReporting` to show that the function may return a number in addition to a boolean. This now matches the implementation and docs. [PR #6763](https://github.com/apollographql/apollo-server/pull/6763)
 
 ## v3.10.0
diff --git a/packages/apollo-server-core/src/plugin/landingPage/__tests__/getEmbeddedExplorerHTML.test.ts b/packages/apollo-server-core/src/plugin/landingPage/__tests__/getEmbeddedExplorerHTML.test.ts
index d0f4972648b..7ae2afbb304 100644
--- a/packages/apollo-server-core/src/plugin/landingPage/__tests__/getEmbeddedExplorerHTML.test.ts
+++ b/packages/apollo-server-core/src/plugin/landingPage/__tests__/getEmbeddedExplorerHTML.test.ts
@@ -29,6 +29,14 @@ describe('Embedded Explorer Landing Page Config HTML', () => {
         graphRef: 'graph@current',
       };
     expect(getEmbeddedExplorerHTML(version, config)).toMatchInlineSnapshot(`
+      <div class="fallback">
+        <h1>
+          Welcome to Apollo Server
+        </h1>
+        <p>
+          Apollo Explorer cannot be loaded; it appears that you might be offline.
+        </p>
+      </div>
       <style>
         iframe {
           background-color: white;
@@ -59,6 +67,14 @@ describe('Embedded Explorer Landing Page Config HTML', () => {
         graphRef: 'graph@current',
       };
     expect(getEmbeddedExplorerHTML(version, config)).toMatchInlineSnapshot(`
+      <div class="fallback">
+        <h1>
+          Welcome to Apollo Server
+        </h1>
+        <p>
+          Apollo Explorer cannot be loaded; it appears that you might be offline.
+        </p>
+      </div>
       <style>
         iframe {
           background-color: white;
diff --git a/packages/apollo-server-core/src/plugin/landingPage/__tests__/getEmbeddedSandboxHTML.test.ts b/packages/apollo-server-core/src/plugin/landingPage/__tests__/getEmbeddedSandboxHTML.test.ts
index 08a70cf2f91..97371c92b5d 100644
--- a/packages/apollo-server-core/src/plugin/landingPage/__tests__/getEmbeddedSandboxHTML.test.ts
+++ b/packages/apollo-server-core/src/plugin/landingPage/__tests__/getEmbeddedSandboxHTML.test.ts
@@ -20,6 +20,14 @@ describe('Landing Page Config HTML', () => {
       embed: true,
     };
     expect(getEmbeddedSandboxHTML(version, config)).toMatchInlineSnapshot(`
+      <div class="fallback">
+        <h1>
+          Welcome to Apollo Server
+        </h1>
+        <p>
+          Apollo Sandbox cannot be loaded; it appears that you might be offline.
+        </p>
+      </div>
       <style>
         iframe {
           background-color: white;
@@ -49,6 +57,14 @@ describe('Landing Page Config HTML', () => {
       embed: true,
     };
     expect(getEmbeddedSandboxHTML(version, config)).toMatchInlineSnapshot(`
+      <div class="fallback">
+        <h1>
+          Welcome to Apollo Server
+        </h1>
+        <p>
+          Apollo Sandbox cannot be loaded; it appears that you might be offline.
+        </p>
+      </div>
       <style>
         iframe {
           background-color: white;
diff --git a/packages/apollo-server-core/src/plugin/landingPage/default/index.ts b/packages/apollo-server-core/src/plugin/landingPage/default/index.ts
index ac9b4ab163b..9e90b7a4548 100644
--- a/packages/apollo-server-core/src/plugin/landingPage/default/index.ts
+++ b/packages/apollo-server-core/src/plugin/landingPage/default/index.ts
@@ -101,6 +101,10 @@ export const getEmbeddedExplorerHTML = (
     };
 
   return `
+<div class="fallback">
+  <h1>Welcome to Apollo Server</h1>
+  <p>Apollo Explorer cannot be loaded; it appears that you might be offline.</p>
+</div>
 <style>
   iframe {
     background-color: white;
@@ -129,6 +133,10 @@ export const getEmbeddedSandboxHTML = (
   config: LandingPageConfig,
 ) => {
   return `
+<div class="fallback">
+  <h1>Welcome to Apollo Server</h1>
+  <p>Apollo Sandbox cannot be loaded; it appears that you might be offline.</p>
+</div>
 <style>
   iframe {
     background-color: white;
@@ -162,6 +170,10 @@ const getNonEmbeddedLandingPageHTML = (
   const encodedConfig = encodeConfig(config);
 
   return `
+ <div class="fallback">
+  <h1>Welcome to Apollo Server</h1>
+  <p>The full landing page cannot be loaded; it appears that you might be offline.</p>
+</div>
 <script>window.landingPage = ${encodedConfig};</script>
 <script src="https://apollo-server-landing-page.cdn.apollographql.com/${version}/static/js/main.js"></script>`;
 };
@@ -224,15 +236,6 @@ function ApolloServerPluginLandingPageDefault(
           100% {opacity:1; }
         }
       </style>
-      <div class="fallback">
-        <h1>Welcome to Apollo Server</h1>
-        <p>It appears that you might be offline. POST to this endpoint to query your graph:</p>
-        <code style="white-space: pre;">
-curl --request POST \\
-  --header 'content-type: application/json' \\
-  --url '<script>document.write(window.location.href)</script>' \\
-  --data '{"query":"query { __typename }"}'</code>
-      </div>
     ${
       config.embed
         ? 'graphRef' in config && config.graphRef", "url": "https://github.com/apollographql/apollo-server/commit/68a439b6e3af9edc8a2480092f2d49f058be1e64.patch" } ]
null
GHSA-2vpq-fh52-j3wv
snowflake-connector-python vulnerable to SQL Injection in write_pandas
null
[ { "commit_message": "<jakub.szczerbinski@snowflake.com> [PATCH] SNOW-1902019: Python CVEs january batch 2 (#2155) Co-authored-by: Yijun Xie <yijun.xie@snowflake.com> src/snowflake/connector/cursor.py | 8 +- src/snowflake/connector/pandas_tools.py | 122 ++++++++++++++++++------ test/integ/pandas/test_pandas_tools.py | 54 ++++++++++- 3 files changed, 148 insertions(+), 36 deletions(-)", "patch_text_b64": "From f3f9b666518d29c31a49384bbaa9a65889e72056 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Szczerbi=C5=84ski?=
 <jakub.szczerbinski@snowflake.com>
Date: Wed, 29 Jan 2025 17:23:22 +0100
Subject: [PATCH] SNOW-1902019: Python CVEs january batch 2 (#2155)

Co-authored-by: Yijun Xie <yijun.xie@snowflake.com>
---
 src/snowflake/connector/cursor.py       |   8 +-
 src/snowflake/connector/pandas_tools.py | 122 ++++++++++++++++++------
 test/integ/pandas/test_pandas_tools.py  |  54 ++++++++++-
 3 files changed, 148 insertions(+), 36 deletions(-)

diff --git a/src/snowflake/connector/cursor.py b/src/snowflake/connector/cursor.py
index b403b8a3e0..5625a18c72 100644
--- a/src/snowflake/connector/cursor.py
+++ b/src/snowflake/connector/cursor.py
@@ -875,6 +875,7 @@ def execute(
         _skip_upload_on_content_match: bool = False,
         file_stream: IO[bytes] | None = None,
         num_statements: int | None = None,
+        _force_qmark_paramstyle: bool = False,
         _dataframe_ast: str | None = None,
     ) -> Self | dict[str, Any] | None:
         """Executes a command/query.
@@ -910,6 +911,7 @@ def execute(
             file_stream: File-like object to be uploaded with PUT
             num_statements: Query level parameter submitted in _statement_params constraining exact number of
             statements being submitted (or 0 if submitting an uncounted number) when using a multi-statement query.
+            _force_qmark_paramstyle: Force the use of qmark paramstyle regardless of the connection's paramstyle.
             _dataframe_ast: Base64-encoded dataframe request abstract syntax tree.
 
         Returns:
@@ -958,7 +960,7 @@ def execute(
             "dataframe_ast": _dataframe_ast,
         }
 
-        if self._connection.is_pyformat:
+        if self._connection.is_pyformat and not _force_qmark_paramstyle:
             query = self._preprocess_pyformat_query(command, params)
         else:
             # qmark and numeric paramstyle
@@ -1458,7 +1460,9 @@ def executemany(
         else:
             if re.search(";/s*$", command) is None:
                 command = command + "; "
-            if self._connection.is_pyformat:
+            if self._connection.is_pyformat and not kwargs.get(
+                "_force_qmark_paramstyle", False
+            ):
                 processed_queries = [
                     self._preprocess_pyformat_query(command, params)
                     for params in seqparams
diff --git a/src/snowflake/connector/pandas_tools.py b/src/snowflake/connector/pandas_tools.py
index 956e2df4c4..24380d2618 100644
--- a/src/snowflake/connector/pandas_tools.py
+++ b/src/snowflake/connector/pandas_tools.py
@@ -85,9 +85,16 @@ def _do_create_temp_stage(
     overwrite: bool,
     use_scoped_temp_object: bool,
 ) -> None:
-    create_stage_sql = f"CREATE {get_temp_type_for_object(use_scoped_temp_object)} STAGE /* Python:snowflake.connector.pandas_tools.write_pandas() */ {stage_location} FILE_FORMAT=(TYPE=PARQUET COMPRESSION={compression}{' BINARY_AS_TEXT=FALSE' if auto_create_table or overwrite else ''})"
-    logger.debug(f"creating stage with '{create_stage_sql}'")
-    cursor.execute(create_stage_sql, _is_internal=True).fetchall()
+    create_stage_sql = f"CREATE {get_temp_type_for_object(use_scoped_temp_object)} STAGE /* Python:snowflake.connector.pandas_tools.write_pandas() */ identifier(?) FILE_FORMAT=(TYPE=PARQUET COMPRESSION={compression}{' BINARY_AS_TEXT=FALSE' if auto_create_table or overwrite else ''})"
+    params = (stage_location,)
+    logger.debug(f"creating stage with '{create_stage_sql}'. params: %s", params)
+    cursor.execute(
+        create_stage_sql,
+        _is_internal=True,
+        _force_qmark_paramstyle=True,
+        params=params,
+        num_statements=1,
+    )
 
 
 def _create_temp_stage(
@@ -147,12 +154,19 @@ def _do_create_temp_file_format(
     use_scoped_temp_object: bool,
 ) -> None:
     file_format_sql = (
-        f"CREATE {get_temp_type_for_object(use_scoped_temp_object)} FILE FORMAT {file_format_location} "
+        f"CREATE {get_temp_type_for_object(use_scoped_temp_object)} FILE FORMAT identifier(?) "
         f"/* Python:snowflake.connector.pandas_tools.write_pandas() */ "
         f"TYPE=PARQUET COMPRESSION={compression}{sql_use_logical_type}"
     )
-    logger.debug(f"creating file format with '{file_format_sql}'")
-    cursor.execute(file_format_sql, _is_internal=True)
+    params = (file_format_location,)
+    logger.debug(f"creating file format with '{file_format_sql}'. params: %s", params)
+    cursor.execute(
+        file_format_sql,
+        _is_internal=True,
+        _force_qmark_paramstyle=True,
+        params=params,
+        num_statements=1,
+    )
 
 
 def _create_temp_file_format(
@@ -379,14 +393,20 @@ def write_pandas(
             # Upload parquet file
             upload_sql = (
                 "PUT /* Python:snowflake.connector.pandas_tools.write_pandas() */ "
-                "'file://{path}' @{stage_location} PARALLEL={parallel}"
+                "'file://{path}' ? PARALLEL={parallel}"
             ).format(
                 path=chunk_path.replace("\\", "\\\\").replace("'", "\\'"),
-                stage_location=stage_location,
                 parallel=parallel,
             )
-            logger.debug(f"uploading files with '{upload_sql}'")
-            cursor.execute(upload_sql, _is_internal=True)
+            params = ("@" + stage_location,)
+            logger.debug(f"uploading files with '{upload_sql}', params: %s", params)
+            cursor.execute(
+                upload_sql,
+                _is_internal=True,
+                _force_qmark_paramstyle=True,
+                params=params,
+                num_statements=1,
+            )
             # Remove chunk file
             os.remove(chunk_path)
 
@@ -403,9 +423,16 @@ def write_pandas(
     columns = quote + f"{quote},{quote}".join(snowflake_column_names) + quote
 
     def drop_object(name: str, object_type: str) -> None:
-        drop_sql = f"DROP {object_type.upper()} IF EXISTS {name} /* Python:snowflake.connector.pandas_tools.write_pandas() */"
-        logger.debug(f"dropping {object_type} with '{drop_sql}'")
-        cursor.execute(drop_sql, _is_internal=True)
+        drop_sql = f"DROP {object_type.upper()} IF EXISTS identifier(?) /* Python:snowflake.connector.pandas_tools.write_pandas() */"
+        params = (name,)
+        logger.debug(f"dropping {object_type} with '{drop_sql}'. params: %s", params)
+        cursor.execute(
+            drop_sql,
+            _is_internal=True,
+            _force_qmark_paramstyle=True,
+            params=params,
+            num_statements=1,
+        )
 
     if auto_create_table or overwrite:
         file_format_location = _create_temp_file_format(
@@ -417,10 +444,17 @@ def drop_object(name: str, object_type: str) -> None:
             sql_use_logical_type,
             _use_scoped_temp_object,
         )
-        infer_schema_sql = f"SELECT COLUMN_NAME, TYPE FROM table(infer_schema(location=>'@{stage_location}', file_format=>'{file_format_location}'))"
-        logger.debug(f"inferring schema with '{infer_schema_sql}'")
+        infer_schema_sql = "SELECT COLUMN_NAME, TYPE FROM table(infer_schema(location=>?, file_format=>?))"
+        params = (f"@{stage_location}", file_format_location)
+        logger.debug(f"inferring schema with '{infer_schema_sql}'. params: %s", params)
         column_type_mapping = dict(
-            cursor.execute(infer_schema_sql, _is_internal=True).fetchall()
+            cursor.execute(
+                infer_schema_sql,
+                _is_internal=True,
+                _force_qmark_paramstyle=True,
+                params=params,
+                num_statements=1,
+            ).fetchall()
         )
         # Infer schema can return the columns out of order depending on the chunking we do when uploading
         # so we have to iterate through the dataframe columns to make sure we create the table with its
@@ -440,12 +474,21 @@ def drop_object(name: str, object_type: str) -> None:
         )
 
         create_table_sql = (
-            f"CREATE {table_type.upper()} TABLE IF NOT EXISTS {target_table_location} "
+            f"CREATE {table_type.upper()} TABLE IF NOT EXISTS identifier(?) "
             f"({create_table_columns})"
             f" /* Python:snowflake.connector.pandas_tools.write_pandas() */ "
         )
-        logger.debug(f"auto creating table with '{create_table_sql}'")
-        cursor.execute(create_table_sql, _is_internal=True)
+        params = (target_table_location,)
+        logger.debug(
+            f"auto creating table with '{create_table_sql}'. params: %s", params
+        )
+        cursor.execute(
+            create_table_sql,
+            _is_internal=True,
+            _force_qmark_paramstyle=True,
+            params=params,
+            num_statements=1,
+        )
         # need explicit casting when the underlying table schema is inferred
         parquet_columns = "$1:" + ",$1:".join(
             f"{quote}{snowflake_col}{quote}::{column_type_mapping[col]}"
@@ -464,12 +507,19 @@ def drop_object(name: str, object_type: str) -> None:
 
     try:
         if overwrite and (not auto_create_table):
-            truncate_sql = f"TRUNCATE TABLE {target_table_location} /* Python:snowflake.connector.pandas_tools.write_pandas() */"
-            logger.debug(f"truncating table with '{truncate_sql}'")
-            cursor.execute(truncate_sql, _is_internal=True)
+            truncate_sql = "TRUNCATE TABLE identifier(?) /* Python:snowflake.connector.pandas_tools.write_pandas() */"
+            params = (target_table_location,)
+            logger.debug(f"truncating table with '{truncate_sql}'. params: %s", params)
+            cursor.execute(
+                truncate_sql,
+                _is_internal=True,
+                _force_qmark_paramstyle=True,
+                params=params,
+                num_statements=1,
+            )
 
         copy_into_sql = (
-            f"COPY INTO {target_table_location} /* Python:snowflake.connector.pandas_tools.write_pandas() */ "
+            f"COPY INTO identifier(?) /* Python:snowflake.connector.pandas_tools.write_pandas() */ "
             f"({columns}) "
             f"FROM (SELECT {parquet_columns} FROM @{stage_location}) "
             f"FILE_FORMAT=("
@@ -478,10 +528,17 @@ def drop_object(name: str, object_type: str) -> None:
             f"{' BINARY_AS_TEXT=FALSE' if auto_create_table or overwrite else ''}"
             f"{sql_use_logical_type}"
             f") "
-            f"PURGE=TRUE ON_ERROR={on_error}"
+            f"PURGE=TRUE ON_ERROR=?"
         )
-        logger.debug(f"copying into with '{copy_into_sql}'")
-        copy_results = cursor.execute(copy_into_sql, _is_internal=True).fetchall()
+        params = (target_table_location, on_error)
+        logger.debug(f"copying into with '{copy_into_sql}'. params: %s", params)
+        copy_results = cursor.execute(
+            copy_into_sql,
+            _is_internal=True,
+            _force_qmark_paramstyle=True,
+            params=params,
+            num_statements=1,
+        ).fetchall()
 
         if overwrite and auto_create_table:
             original_table_location = build_location_helper(
@@ -491,9 +548,16 @@ def drop_object(name: str, object_type: str) -> None:
                 quote_identifiers=quote_identifiers,
             )
             drop_object(original_table_location, "table")
-            rename_table_sql = f"ALTER TABLE {target_table_location} RENAME TO {original_table_location} /* Python:snowflake.connector.pandas_tools.write_pandas() */"
-            logger.debug(f"rename table with '{rename_table_sql}'")
-            cursor.execute(rename_table_sql, _is_internal=True)
+            rename_table_sql = "ALTER TABLE identifier(?) RENAME TO identifier(?) /* Python:snowflake.connector.pandas_tools.write_pandas() */"
+            params = (target_table_location, original_table_location)
+            logger.debug(f"rename table with '{rename_table_sql}'. params: %s", params)
+            cursor.execute(
+                rename_table_sql,
+                _is_internal=True,
+                _force_qmark_paramstyle=True,
+                params=params,
+                num_statements=1,
+            )
     except ProgrammingError:
         if overwrite and auto_create_table:
             # drop table only if we created a new one with a random name
diff --git a/test/integ/pandas/test_pandas_tools.py b/test/integ/pandas/test_pandas_tools.py
index 3fa8c8b8b7..f5178c3304 100644
--- a/test/integ/pandas/test_pandas_tools.py
+++ b/test/integ/pandas/test_pandas_tools.py
@@ -64,7 +64,7 @@ def assert_result_equals(
 
 
 def test_fix_snow_746341(
-    conn_cnx: Callable[..., Generator[SnowflakeConnection, None, None]]
+    conn_cnx: Callable[..., Generator[SnowflakeConnection, None, None]],
 ):
     cat = '"cat"'
     df = pandas.DataFrame([[1], [2]], columns=[f"col_'{cat}'"])
@@ -534,8 +534,7 @@ def test_table_location_building(
 
         def mocked_execute(*args, **kwargs):
             if len(args) >= 1 and args[0].startswith("COPY INTO"):
-                location = args[0].split(" ")[2]
-                assert location == expected_location
+                assert kwargs["params"][0] == expected_location
             cur = SnowflakeCursor(cnx)
             cur._result = iter([])
             return cur
@@ -906,7 +905,7 @@ def test_auto_create_table_similar_column_names(
 
 
 def test_all_pandas_types(
-    conn_cnx: Callable[..., Generator[SnowflakeConnection, None, None]]
+    conn_cnx: Callable[..., Generator[SnowflakeConnection, None, None]],
 ):
     table_name = random_string(5, "all_types_")
     datetime_with_tz = datetime(1997, 6, 3, 14, 21, 32, 00, tzinfo=timezone.utc)
@@ -997,7 +996,7 @@ def test_no_create_internal_object_privilege_in_target_schema(
             def mock_execute(*args, **kwargs):
                 if (
                     f"CREATE TEMP {object_type}" in args[0]
-                    and "target_schema_no_create_" in args[0]
+                    and "target_schema_no_create_" in kwargs["params"][0]
                 ):
                     raise ProgrammingError("Cannot create temp object in target schema")
                 cursor = cnx.cursor()
@@ -1027,3 +1026,48 @@ def mock_execute(*args, **kwargs):
         finally:
             cnx.execute_string(f"drop schema if exists {source_schema}")
             cnx.execute_string(f"drop schema if exists {target_schema}")
+
+
+def test_write_pandas_with_on_error(
+    conn_cnx: Callable[..., Generator[SnowflakeConnection, None, None]],
+):
+    """Tests whether overwriting table using a Pandas DataFrame works as expected."""
+    random_table_name = random_string(5, "userspoints_")
+    df_data = [("Dash", 50)]
+    df = pandas.DataFrame(df_data, columns=["name", "points"])
+
+    table_name = random_table_name
+    col_id = "id"
+    col_name = "name"
+    col_points = "points"
+
+    create_sql = (
+        f"CREATE OR REPLACE TABLE {table_name}"
+        f"({col_name} STRING, {col_points} INT, {col_id} INT AUTOINCREMENT)"
+    )
+
+    select_count_sql = f"SELECT count(*) FROM {table_name}"
+    drop_sql = f"DROP TABLE IF EXISTS {table_name}"
+    with conn_cnx() as cnx:  # type: SnowflakeConnection
+        cnx.execute_string(create_sql)
+        try:
+            # Write dataframe with 1 row
+            success, nchunks, nrows, _ = write_pandas(
+                cnx,
+                df,
+                random_table_name,
+                quote_identifiers=False,
+                auto_create_table=False,
+                overwrite=True,
+                index=True,
+                on_error="continue",
+            )
+            # Check write_pandas output
+            assert success
+            assert nchunks == 1
+            assert nrows == 1
+            result = cnx.cursor(DictCursor).execute(select_count_sql).fetchone()
+            # Check number of rows
+            assert result["COUNT(*)"] == 1
+        finally:
+            cnx.execute_string(drop_sql)", "url": "https://github.com/snowflakedb/snowflake-connector-python/commit/f3f9b666518d29c31a49384bbaa9a65889e72056.patch" } ]
null
CVE-2024-47529
OpenC3 COSMOS uses clear text storage of password/token (`GHSL-2024-129`)
OpenC3 COSMOS provides the functionality needed to send commands to and receive data from one or more embedded systems. OpenC3 COSMOS stores the password of a user unencrypted in the LocalStorage of a web browser. This makes the user password susceptible to exfiltration via Cross-site scripting (see GHSL-2024-128). This vulnerability is fixed in 5.19.0. This only affects Open Source edition, and not OpenC3 COSMOS Enterprise Edition.
[ { "commit_message": "[PATCH] Switch to session token based auth .../app/controllers/auth_controller.rb | 6 ++-- .../app/controllers/users_controller.rb | 1 + .../src/tools/base/components/Login.vue | 12 ++++--- .../app/controllers/scripts_controller.rb | 8 ++--- openc3/lib/openc3/models/auth_model.rb | 33 +++++++++++++++++-- 5 files changed, 47 insertions(+), 13 deletions(-)", "patch_text_b64": "From b5ab34fe7fa54c0c8171c4aa3caf4e03d6f63bd7 Mon Sep 17 00:00:00 2001
From: Ryan Melton <ryan@openc3.com>
Date: Mon, 30 Sep 2024 11:48:25 -0600
Subject: [PATCH] Switch to session token based auth

---
 .../app/controllers/auth_controller.rb        |  6 ++--
 .../app/controllers/users_controller.rb       |  1 +
 .../src/tools/base/components/Login.vue       | 12 ++++---
 .../app/controllers/scripts_controller.rb     |  8 ++---
 openc3/lib/openc3/models/auth_model.rb        | 33 +++++++++++++++++--
 5 files changed, 47 insertions(+), 13 deletions(-)

diff --git a/openc3-cosmos-cmd-tlm-api/app/controllers/auth_controller.rb b/openc3-cosmos-cmd-tlm-api/app/controllers/auth_controller.rb
index fe7c49110a..4177f70d6d 100644
--- a/openc3-cosmos-cmd-tlm-api/app/controllers/auth_controller.rb
+++ b/openc3-cosmos-cmd-tlm-api/app/controllers/auth_controller.rb
@@ -34,11 +34,12 @@ def token_exists
   def verify
     begin
       if OpenC3::AuthModel.verify(params[:token])
-        head :ok
+        render :plain => OpenC3::AuthModel.generate_session()
       else
         head :unauthorized
       end
     rescue StandardError => e
+      OpenC3::Logger.error(e.formatted)
       render :json => { :status => 'error', :message => e.message, 'type' => e.class }, :status => 500
     end
   end
@@ -48,8 +49,9 @@ def set
       # Set throws an exception if it fails for any reason
       OpenC3::AuthModel.set(params[:token], params[:old_token])
       OpenC3::Logger.info("Password changed", user: username())
-      head :ok
+      render :plain => OpenC3::AuthModel.generate_session()
     rescue StandardError => e
+      OpenC3::Logger.error(e.formatted)
       render :json => { :status => 'error', :message => e.message, 'type' => e.class }, :status => 500
     end
   end
diff --git a/openc3-cosmos-cmd-tlm-api/app/controllers/users_controller.rb b/openc3-cosmos-cmd-tlm-api/app/controllers/users_controller.rb
index 67846edb3e..6581f90188 100644
--- a/openc3-cosmos-cmd-tlm-api/app/controllers/users_controller.rb
+++ b/openc3-cosmos-cmd-tlm-api/app/controllers/users_controller.rb
@@ -26,6 +26,7 @@ def active()
     end
 
     def logout()
+      OpenC3::AuthModel.logout
       head :ok
     end
   end
diff --git a/openc3-cosmos-init/plugins/packages/openc3-tool-common/src/tools/base/components/Login.vue b/openc3-cosmos-init/plugins/packages/openc3-tool-common/src/tools/base/components/Login.vue
index 62480c0548..c4e0174389 100644
--- a/openc3-cosmos-init/plugins/packages/openc3-tool-common/src/tools/base/components/Login.vue
+++ b/openc3-cosmos-init/plugins/packages/openc3-tool-common/src/tools/base/components/Login.vue
@@ -140,12 +140,12 @@ export default {
     showReset: function () {
       this.reset = true
     },
-    login: function () {
-      localStorage.openc3Token = this.password
+    login: function (response) {
+      localStorage.openc3Token = response.data
       const redirect = new URLSearchParams(window.location.search).get(
         'redirect',
       )
-      if (redirect[0] === '/' && redirect[1] !== '/') {
+      if (redirect.startsWith('/tools/')) {
         // Valid relative redirect URL
         window.location = decodeURI(redirect)
       } else {
@@ -161,7 +161,7 @@ export default {
         ...this.options,
       })
         .then((response) => {
-          this.login()
+          this.login(response)
         })
         .catch((error) => {
           this.alert = 'Incorrect password'
@@ -177,7 +177,9 @@ export default {
           token: this.password,
         },
         ...this.options,
-      }).then(this.login)
+      }).then((response) => {
+        this.login(response)
+      })
     },
   },
 }
diff --git a/openc3-cosmos-script-runner-api/app/controllers/scripts_controller.rb b/openc3-cosmos-script-runner-api/app/controllers/scripts_controller.rb
index e4393590af..7d1bf9a10f 100644
--- a/openc3-cosmos-script-runner-api/app/controllers/scripts_controller.rb
+++ b/openc3-cosmos-script-runner-api/app/controllers/scripts_controller.rb
@@ -56,7 +56,7 @@ def delete_temp
 
   def body
     return unless authorization('script_view')
-    scope, name = sanitize_params([:scope, :name])
+    scope, name = sanitize_params([:scope, :name], :allow_forward_slash => true)
     return unless scope
 
     file = Script.body(scope, name)
@@ -126,7 +126,7 @@ def run
 
   def lock
     return unless authorization('script_edit')
-    scope, name = sanitize_params([:scope, :name])
+    scope, name = sanitize_params([:scope, :name], :allow_forward_slash => true)
     return unless scope
     Script.lock(scope, name, username())
     render status: 200
@@ -134,7 +134,7 @@ def lock
 
   def unlock
     return unless authorization('script_edit')
-    scope, name = sanitize_params([:scope, :name])
+    scope, name = sanitize_params([:scope, :name], :allow_forward_slash => true)
     return unless scope
     locked_by = Script.locked?(scope, name)
     Script.unlock(scope, name) if username() == locked_by
@@ -143,7 +143,7 @@ def unlock
 
   def destroy
     return unless authorization('script_edit')
-    scope, name = sanitize_params([:scope, :name])
+    scope, name = sanitize_params([:scope, :name], :allow_forward_slash => true)
     return unless scope
     Script.destroy(scope, name)
     OpenC3::Logger.info("Script destroyed: #{name}", scope: scope, user: username())
diff --git a/openc3/lib/openc3/models/auth_model.rb b/openc3/lib/openc3/models/auth_model.rb
index b7008582a5..0a3414ab84 100644
--- a/openc3/lib/openc3/models/auth_model.rb
+++ b/openc3/lib/openc3/models/auth_model.rb
@@ -21,15 +21,22 @@
 # if purchased from OpenC3, Inc.
 
 require 'digest'
+require 'securerandom'
 require 'openc3/utilities/store'
 
 module OpenC3
   class AuthModel
     PRIMARY_KEY = 'OPENC3__TOKEN'
+    SESSIONS_KEY = 'OPENC3__SESSIONS'
 
     TOKEN_CACHE_TIMEOUT = 5
+    SESSION_CACHE_TIMEOUT = 5
     @@token_cache = nil
     @@token_cache_time = nil
+    @@session_cache = nil
+    @@session_cache_time = nil
+
+    MIN_TOKEN_LENGTH = 8
 
     def self.set?(key = PRIMARY_KEY)
       Store.exists(key) == 1
@@ -38,14 +45,23 @@ def self.set?(key = PRIMARY_KEY)
     def self.verify(token)
       return false if token.nil? or token.empty?
 
+      time = Time.now
+      return true if @@session_cache and (time - @@session_cache_time) < SESSION_CACHE_TIMEOUT and @@session_cache[token]
       token_hash = hash(token)
-      return true if @@token_cache and (Time.now - @@token_cache_time) < TOKEN_CACHE_TIMEOUT and @@token_cache == token_hash
+      return true if @@token_cache and (time - @@token_cache_time) < TOKEN_CACHE_TIMEOUT and @@token_cache == token_hash
+
+      # Check sessions
+      @@session_cache = Store.hgetall(SESSIONS_KEY)
+      @@session_cache_time = time
+      return true if @@session_cache[token]
 
+      # Check Direct password
       @@token_cache = Store.get(PRIMARY_KEY)
-      @@token_cache_time = Time.now
+      @@token_cache_time = time
       return true if @@token_cache == token_hash
 
       # Handle a service password - Generally only used by ScriptRunner
+      # TODO: Replace this with temporary service tokens
       service_password = ENV['OPENC3_SERVICE_PASSWORD']
       return true if service_password and service_password == token
 
@@ -54,6 +70,7 @@ def self.verify(token)
 
     def self.set(token, old_token, key = PRIMARY_KEY)
       raise "token must not be nil or empty" if token.nil? or token.empty?
+      raise "token must be at least 8 characters" if token.length < MIN_TOKEN_LENGTH
 
       if set?(key)
         raise "old_token must not be nil or empty" if old_token.nil? or old_token.empty?
@@ -62,6 +79,18 @@ def self.set(token, old_token, key = PRIMARY_KEY)
       Store.set(key, hash(token))
     end
 
+    def self.generate_session
+      token = SecureRandom.urlsafe_base64(nil, false)
+      Store.hset(SESSIONS_KEY, token, Time.now.iso8601)
+      return token
+    end
+
+    def self.logout
+      Store.del(SESSIONS_KEY)
+      @@sessions_cache = nil
+      @@sessions_cache_time = nil
+    end
+
     def self.hash(token)
       Digest::SHA2.hexdigest token
     end", "url": "https://github.com/OpenC3/cosmos/commit/b5ab34fe7fa54c0c8171c4aa3caf4e03d6f63bd7.patch" } ]
CWE-312: Cleartext Storage of Sensitive Information
CVE-2025-3264
Regular Expression Denial of Service (ReDoS) in huggingface/transformers
A Regular Expression Denial of Service (ReDoS) vulnerability was discovered in the Hugging Face Transformers library, specifically in the `get_imports()` function within `dynamic_module_utils.py`. This vulnerability affects versions 4.49.0 and is fixed in version 4.51.0. The issue arises from a regular expression pattern `\s*try\s*:.*?except.*?:` used to filter out try/except blocks from Python code, which can be exploited to cause excessive CPU consumption through crafted input strings due to catastrophic backtracking. This vulnerability can lead to remote code loading disruption, resource exhaustion in model serving, supply chain attack vectors, and development pipeline disruption.
[ { "commit_message": "[PATCH] Release: v4.51.0 examples/flax/question-answering/run_qa.py | 2 +- .../run_flax_speech_recognition_seq2seq.py | 2 +- .../flax/text-classification/run_flax_glue.py | 2 +- .../flax/token-classification/run_flax_ner.py | 2 +- .../run_audio_classification.py | 2 +- .../contrastive-image-text/run_clip.py | 2 +- .../run_image_classification.py | 2 +- .../run_image_classification_no_trainer.py | 2 +- examples/pytorch/image-pretraining/run_mae.py | 2 +- examples/pytorch/image-pretraining/run_mim.py | 2 +- .../image-pretraining/run_mim_no_trainer.py | 2 +- .../run_instance_segmentation.py | 2 +- .../run_instance_segmentation_no_trainer.py | 2 +- examples/pytorch/language-modeling/run_clm.py | 2 +- .../language-modeling/run_clm_no_trainer.py | 2 +- examples/pytorch/language-modeling/run_fim.py | 2 +- .../language-modeling/run_fim_no_trainer.py | 2 +- examples/pytorch/language-modeling/run_mlm.py | 2 +- .../language-modeling/run_mlm_no_trainer.py | 2 +- examples/pytorch/language-modeling/run_plm.py | 2 +- examples/pytorch/multiple-choice/run_swag.py | 2 +- .../multiple-choice/run_swag_no_trainer.py | 2 +- .../object-detection/run_object_detection.py | 2 +- .../run_object_detection_no_trainer.py | 2 +- examples/pytorch/question-answering/run_qa.py | 2 +- .../question-answering/run_qa_beam_search.py | 2 +- .../run_qa_beam_search_no_trainer.py | 2 +- .../question-answering/run_qa_no_trainer.py | 2 +- .../question-answering/run_seq2seq_qa.py | 2 +- .../run_semantic_segmentation.py | 2 +- .../run_semantic_segmentation_no_trainer.py | 2 +- .../run_speech_recognition_ctc.py | 2 +- .../run_speech_recognition_ctc_adapter.py | 2 +- .../run_speech_recognition_seq2seq.py | 2 +- .../summarization/run_summarization.py | 2 +- .../run_summarization_no_trainer.py | 2 +- .../text-classification/run_classification.py | 2 +- .../pytorch/text-classification/run_glue.py | 2 +- .../run_glue_no_trainer.py | 2 +- .../pytorch/text-classification/run_xnli.py | 2 +- .../pytorch/token-classification/run_ner.py | 2 +- .../run_ner_no_trainer.py | 2 +- .../pytorch/translation/run_translation.py | 2 +- .../translation/run_translation_no_trainer.py | 2 +- .../contrastive-image-text/run_clip.py | 2 +- .../run_image_classification.py | 2 +- .../tensorflow/multiple-choice/run_swag.py | 2 +- .../tensorflow/question-answering/run_qa.py | 2 +- .../summarization/run_summarization.py | 2 +- .../text-classification/run_glue.py | 2 +- .../tensorflow/translation/run_translation.py | 2 +- setup.py | 2 +- src/transformers/__init__.py | 2 +- ...lbert_original_tf_checkpoint_to_pytorch.py | 62 - .../models/align/convert_align_tf_to_hf.py | 389 ----- .../models/aria/convert_aria_weights_to_hf.py | 162 -- ...trogram_transformer_original_to_pytorch.py | 279 ---- .../bamba/convert_mamba_ssm_checkpoint.py | 273 ---- .../models/bark/convert_suno_to_hf.py | 263 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 156 -- .../beit/convert_beit_unilm_to_pytorch.py | 373 ----- ...bert_original_tf2_checkpoint_to_pytorch.py | 246 --- ..._bert_original_tf_checkpoint_to_pytorch.py | 62 - ..._bert_pytorch_checkpoint_to_original_tf.py | 112 -- ...ping_original_tf2_checkpoint_to_pytorch.py | 188 --- ...gbird_original_tf_checkpoint_to_pytorch.py | 69 - .../convert_bigbird_pegasus_tf_to_pytorch.py | 170 --- ..._original_pytorch_checkpoint_to_pytorch.py | 292 ---- .../models/bit/convert_bit_to_pytorch.py | 177 --- ..._original_pytorch_checkpoint_to_pytorch.py | 114 -- .../convert_blip_original_pytorch_to_hf.py | 191 --- .../convert_blip_2_original_to_pytorch.py | 390 ----- ...rt_bloom_original_checkpoint_to_pytorch.py | 254 ---- .../models/bros/convert_bros_to_pytorch.py | 145 -- ..._byt5_original_tf_checkpoint_to_pytorch.py | 59 - ...anine_original_tf_checkpoint_to_pytorch.py | 65 - .../convert_chameleon_weights_to_hf.py | 476 ------ ...ert_chinese_clip_original_pytorch_to_hf.py | 134 -- .../convert_clap_original_pytorch_to_hf.py | 133 -- .../convert_clip_original_pytorch_to_hf.py | 156 -- .../convert_clipseg_original_pytorch_to_hf.py | 264 ---- .../models/clvp/convert_clvp_to_hf.py | 234 --- .../colpali/convert_colpali_weights_to_hf.py | 214 --- ..._original_pytorch_checkpoint_to_pytorch.py | 324 ---- ...ginal_tf1_checkpoint_to_pytorch_and_tf2.py | 57 - .../convnext/convert_convnext_to_pytorch.py | 242 --- .../convert_convnextv2_to_pytorch.py | 286 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 362 ----- ..._original_pytorch_checkpoint_to_pytorch.py | 233 --- .../models/dac/convert_dac_checkpoint.py | 261 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 285 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 207 --- ..._original_pytorch_checkpoint_to_pytorch.py | 374 ----- .../convert_deformable_detr_to_pytorch.py | 236 --- .../deit/convert_deit_timm_to_pytorch.py | 218 --- ...original_gluonnlp_checkpoint_to_pytorch.py | 318 ---- .../deta/convert_deta_resnet_to_pytorch.py | 319 ---- .../deta/convert_deta_swin_to_pytorch.py | 326 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 252 ---- ...convert_gptsan_tf_checkpoint_to_pytorch.py | 181 --- .../deprecated/jukebox/convert_jukebox.py | 279 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 292 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 70 - ...fo_xl_original_tf_checkpoint_to_pytorch.py | 121 -- .../deprecated/van/convert_van_to_pytorch.py | 290 ---- .../convert_vit_hybrid_timm_to_pytorch.py | 282 ---- .../convert_depth_anything_to_hf.py | 368 ----- .../convert_distill_any_depth_to_hf.py | 246 --- .../convert_depth_pro_weights_to_hf.py | 254 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 277 ---- .../models/detr/convert_detr_to_pytorch.py | 385 ----- ..._original_pytorch_checkpoint_to_pytorch.py | 46 - .../models/dinov2/convert_dinov2_to_hf.py | 285 ---- .../convert_dinov2_with_registers_to_hf.py | 291 ---- .../dit/convert_dit_unilm_to_pytorch.py | 230 --- .../models/donut/convert_donut_to_pytorch.py | 234 --- ...vert_dpr_original_checkpoint_to_pytorch.py | 143 -- .../models/dpt/convert_dinov2_depth_to_hf.py | 383 ----- .../models/dpt/convert_dpt_beit_to_hf.py | 305 ---- .../dpt/convert_dpt_hybrid_to_pytorch.py | 315 ---- .../models/dpt/convert_dpt_swinv2_to_hf.py | 321 ---- .../models/dpt/convert_dpt_to_pytorch.py | 285 ---- .../convert_efficientnet_to_pytorch.py | 339 ----- ...ectra_original_tf_checkpoint_to_pytorch.py | 79 - .../models/emu3/convert_emu3_weights_to_hf.py | 448 ------ .../convert_encodec_checkpoint_to_pytorch.py | 365 ----- src/transformers/models/esm/convert_esm.py | 399 ----- .../falcon/convert_custom_code_checkpoint.py | 74 - ..._original_pytorch_checkpoint_to_pytorch.py | 210 --- .../fastspeech2_conformer/convert_hifigan.py | 134 -- .../convert_model_with_hifigan.py | 102 -- .../flava/convert_dalle_to_flava_codebook.py | 102 -- .../convert_flava_original_pytorch_to_hf.py | 99 -- ...net_original_flax_checkpoint_to_pytorch.py | 156 -- .../focalnet/convert_focalnet_to_hf_format.py | 237 --- ..._original_pytorch_checkpoint_to_pytorch.py | 280 ---- ...unnel_original_tf_checkpoint_to_pytorch.py | 67 - .../fuyu/convert_fuyu_model_weights_to_hf.py | 134 -- .../gemma/convert_gemma_weights_to_hf.py | 206 --- .../gemma2/convert_gemma2_weights_to_hf.py | 239 --- .../convert_gemma3_weights_orbax_to_hf.py | 589 -------- .../models/git/convert_git_to_pytorch.py | 448 ------ .../models/glm/convert_glm_weights_to_hf.py | 195 --- .../models/glpn/convert_glpn_to_pytorch.py | 218 --- .../convert_got_ocr2_weights_to_hf.py | 274 ---- ..._gpt2_original_tf_checkpoint_to_pytorch.py | 68 - .../convert_gpt_neo_mesh_tf_to_pytorch.py | 71 - .../gpt_sw3/convert_megatron_to_pytorch.py | 197 --- .../convert_grounding_dino_to_hf.py | 491 ------ .../groupvit/convert_groupvit_nvlab_to_hf.py | 217 --- .../models/hiera/convert_hiera_to_hf.py | 369 ----- ...rt_original_s3prl_checkpoint_to_pytorch.py | 222 --- ..._original_pytorch_checkpoint_to_pytorch.py | 261 ---- ...rt_original_s3prl_checkpoint_to_pytorch.py | 68 - .../convert_idefics2_weights_to_hf.py | 185 --- .../convert_idefics3_weights_to_hf.py | 214 --- .../models/ijepa/convert_ijepa_to_hf.py | 267 ---- ...onvert_imagegpt_original_tf2_to_pytorch.py | 71 - ...onvert_instructblip_original_to_pytorch.py | 303 ---- ...t_instructblipvideo_original_to_pytorch.py | 305 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 77 - .../levit/convert_levit_timm_to_pytorch.py | 181 --- .../llama/convert_llama_weights_to_hf.py | 601 -------- .../llama4/convert_llama4_weights_to_hf.py | 736 --------- .../llava/convert_llava_weights_to_hf.py | 204 --- .../convert_llava_next_weights_to_hf.py | 397 ----- .../convert_llava_next_video_weights_to_hf.py | 276 ---- .../convert_llava_onevision_weights_to_hf.py | 388 ----- ...r_original_pytorch_lightning_to_pytorch.py | 85 -- .../convert_longt5x_checkpoint_to_flax.py | 215 --- ..._original_pytorch_checkpoint_to_pytorch.py | 170 --- ...xmert_original_tf_checkpoint_to_pytorch.py | 59 - ...t_m2m100_original_checkpoint_to_pytorch.py | 85 -- ...convert_mamba_ssm_checkpoint_to_pytorch.py | 153 -- ...onvert_mamba2_ssm_checkpoint_to_pytorch.py | 193 --- .../convert_marian_tatoeba_to_pytorch.py | 1327 ----------------- .../marian/convert_marian_to_pytorch.py | 717 --------- ..._original_pytorch_checkpoint_to_pytorch.py | 1019 ------------- ..._original_pytorch_checkpoint_to_pytorch.py | 731 --------- .../convert_maskformer_resnet_to_pytorch.py | 390 ----- .../convert_maskformer_swin_to_pytorch.py | 333 ----- ...rt_mbart_original_checkpoint_to_pytorch.py | 83 -- .../convert_megatron_bert_checkpoint.py | 334 ----- .../convert_megatron_gpt2_checkpoint.py | 358 ----- .../convert_mimi_checkpoint_to_pytorch.py | 198 --- .../mistral/convert_mistral_weights_to_hf.py | 282 ---- .../convert_mistral3_weights_to_hf.py | 241 --- .../mixtral/convert_mixtral_weights_to_hf.py | 244 --- .../mllama/convert_mllama_weights_to_hf.py | 639 -------- ..._original_pytorch_checkpoint_to_pytorch.py | 229 --- ...ebert_original_tf_checkpoint_to_pytorch.py | 58 - ...nvert_original_tf_checkpoint_to_pytorch.py | 141 -- ...nvert_original_tf_checkpoint_to_pytorch.py | 177 --- .../mobilevit/convert_mlcvnets_to_pytorch.py | 311 ---- .../convert_mlcvnets_to_pytorch.py | 332 ----- .../moonshine/convert_usefulsensors_to_hf.py | 169 --- .../moshi/convert_moshi_transformers.py | 311 ---- .../mra/convert_mra_pytorch_to_pytorch.py | 110 -- .../musicgen/convert_musicgen_transformers.py | 236 --- .../convert_musicgen_melody_transformers.py | 267 ---- ..._myt5_original_tf_checkpoint_to_pytorch.py | 60 - .../nemotron/convert_nemotron_nemo_to_hf.py | 346 ----- ..._sharded_original_checkpoint_to_pytorch.py | 161 -- .../models/nougat/convert_nougat_to_hf.py | 282 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 111 -- .../models/olmo/convert_olmo_weights_to_hf.py | 248 --- .../olmo2/convert_olmo2_weights_to_hf.py | 306 ---- .../olmoe/convert_olmoe_weights_to_hf.py | 281 ---- .../omdet_turbo/convert_omdet_turbo_to_hf.py | 349 ----- .../oneformer/convert_to_hf_oneformer.py | 1191 --------------- ...penai_original_tf_checkpoint_to_pytorch.py | 74 - ..._original_pytorch_checkpoint_to_pytorch.py | 113 -- .../models/owlv2/convert_owlv2_to_hf.py | 422 ------ .../convert_owlvit_original_flax_to_hf.py | 406 ----- .../convert_paligemma2_weights_to_hf.py | 415 ------ .../convert_paligemma_weights_to_hf.py | 347 ----- .../pegasus/convert_pegasus_tf_to_pytorch.py | 131 -- .../convert_perceiver_haiku_to_pytorch.py | 468 ------ .../convert_persimmon_weights_to_hf.py | 129 -- .../models/phi/convert_phi_weights_to_hf.py | 207 --- .../convert_phi4_multimodal_weights_to_hf.py | 229 --- ...nvert_pix2struct_original_pytorch_to_hf.py | 155 -- .../pixtral/convert_pixtral_weights_to_hf.py | 246 --- ...ert_plbart_original_checkpoint_to_torch.py | 94 -- .../convert_poolformer_original_to_pytorch.py | 214 --- .../convert_pop2piano_weights_to_hf.py | 190 --- .../convert_prompt_depth_anything_to_hf.py | 292 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 159 -- .../models/pvt/convert_pvt_to_pytorch.py | 226 --- .../pvt_v2/convert_pvt_v2_to_pytorch.py | 294 ---- .../convert_recurrent_gemma_to_hf.py | 222 --- ...ert_reformer_trax_checkpoint_to_pytorch.py | 226 --- .../convert_regnet_seer_10b_to_pytorch.py | 308 ---- .../regnet/convert_regnet_to_pytorch.py | 458 ------ ...onvert_rembert_tf_checkpoint_to_pytorch.py | 62 - .../resnet/convert_resnet_to_pytorch.py | 199 --- ..._original_pytorch_checkpoint_to_pytorch.py | 177 --- ..._original_pytorch_checkpoint_to_pytorch.py | 77 - ...ormer_original_tf_checkpoint_to_pytorch.py | 62 - ..._detr_original_pytorch_checkpoint_to_hf.py | 782 ---------- .../convert_rt_detr_v2_weights_to_hf.py | 363 ----- .../rwkv/convert_rwkv_checkpoint_to_hf.py | 209 --- .../models/sam/convert_sam_to_hf.py | 251 ---- .../seamless_m4t/convert_fairseq2_to_hf.py | 396 ----- .../seamless_m4t_v2/convert_fairseq2_to_hf.py | 404 ----- .../convert_segformer_original_to_pytorch.py | 387 ----- .../models/seggpt/convert_seggpt_to_hf.py | 221 --- ..._original_pytorch_checkpoint_to_pytorch.py | 305 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 317 ---- ...onvert_shieldgemma2_weights_orbax_to_hf.py | 470 ------ .../models/siglip/convert_siglip_to_hf.py | 533 ------- .../models/siglip2/convert_siglip2_to_hf.py | 438 ------ ...rt_wav2vec2_seq2seq_original_to_pytorch.py | 357 ----- ...xt_wav2vec2_seq2seq_original_to_pytorch.py | 316 ---- .../convert_s2t_fairseq_to_tfms.py | 121 -- .../models/speecht5/convert_hifigan.py | 108 -- ..._original_pytorch_checkpoint_to_pytorch.py | 401 ----- .../superglue/convert_superglue_to_hf.py | 342 ----- .../convert_superpoint_to_pytorch.py | 175 --- .../convert_swiftformer_original_to_hf.py | 175 --- .../swin/convert_swin_simmim_to_pytorch.py | 182 --- .../swin/convert_swin_timm_to_pytorch.py | 173 --- .../convert_swin2sr_original_to_pytorch.py | 278 ---- .../swinv2/convert_swinv2_timm_to_pytorch.py | 219 --- .../switch_transformers/convert_big_switch.py | 194 --- ...ers_original_flax_checkpoint_to_pytorch.py | 203 --- ...rt_t5_original_tf_checkpoint_to_pytorch.py | 59 - .../t5/convert_t5x_checkpoint_to_flax.py | 235 --- .../t5/convert_t5x_checkpoint_to_pytorch.py | 238 --- .../convert_table_transformer_to_hf.py | 317 ---- ...convert_table_transformer_to_hf_no_timm.py | 434 ------ ...tapas_original_tf_checkpoint_to_pytorch.py | 137 -- .../models/textnet/convert_textnet_to_hf.py | 208 --- .../convert_timesformer_to_pytorch.py | 253 ---- .../trocr/convert_trocr_unilm_to_pytorch.py | 237 --- .../models/udop/convert_udop_to_hf.py | 224 --- .../convert_umt5_checkpoint_to_pytorch.py | 274 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 273 ---- ...ch_original_s3prl_checkpoint_to_pytorch.py | 109 -- ..._original_pytorch_checkpoint_to_pytorch.py | 224 --- .../models/univnet/convert_univnet.py | 162 -- .../convert_convnext_upernet_to_pytorch.py | 214 --- .../convert_swin_upernet_to_pytorch.py | 297 ---- .../convert_video_llava_weights_to_hf.py | 159 -- .../videomae/convert_videomae_to_pytorch.py | 324 ---- .../vilt/convert_vilt_original_to_pytorch.py | 299 ---- .../convert_vipllava_weights_to_hf.py | 132 -- ..._original_pytorch_checkpoint_to_pytorch.py | 149 -- .../models/vit/convert_dino_to_pytorch.py | 218 --- .../models/vit/convert_vit_timm_to_pytorch.py | 254 ---- .../vit_mae/convert_vit_mae_to_pytorch.py | 178 --- .../models/vit_msn/convert_msn_to_pytorch.py | 245 --- .../models/vitmatte/convert_vitmatte_to_hf.py | 170 --- .../models/vitpose/convert_vitpose_to_hf.py | 428 ------ .../vits/convert_original_checkpoint.py | 390 ----- .../vivit/convert_vivit_flax_to_pytorch.py | 231 --- ..._original_pytorch_checkpoint_to_pytorch.py | 385 ----- ...c2_original_s3prl_checkpoint_to_pytorch.py | 109 -- .../convert_wav2vec2_seamless_checkpoint.py | 217 --- ..._original_pytorch_checkpoint_to_pytorch.py | 309 ---- ..._original_pytorch_checkpoint_to_pytorch.py | 206 --- ...lm_original_s3prl_checkpoint_to_pytorch.py | 109 -- .../models/whisper/convert_openai_to_hf.py | 370 ----- .../convert_x_clip_original_pytorch_to_hf.py | 386 ----- .../convert_xglm_original_ckpt_to_trfms.py | 68 - ..._original_pytorch_checkpoint_to_pytorch.py | 77 - ..._original_pytorch_checkpoint_to_pytorch.py | 183 --- ...xlnet_original_tf_checkpoint_to_pytorch.py | 113 -- ..._original_pytorch_checkpoint_to_pytorch.py | 212 --- .../models/yolos/convert_yolos_to_pytorch.py | 267 ---- .../yoso/convert_yoso_pytorch_to_pytorch.py | 108 -- .../models/zoedepth/convert_zoedepth_to_hf.py | 426 ------ 312 files changed, 53 insertions(+), 66972 deletions(-) delete mode 100644 src/transformers/models/albert/convert_albert_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/align/convert_align_tf_to_hf.py delete mode 100644 src/transformers/models/aria/convert_aria_weights_to_hf.py delete mode 100644 src/transformers/models/audio_spectrogram_transformer/convert_audio_spectrogram_transformer_original_to_pytorch.py delete mode 100644 src/transformers/models/bamba/convert_mamba_ssm_checkpoint.py delete mode 100644 src/transformers/models/bark/convert_suno_to_hf.py delete mode 100644 src/transformers/models/bart/convert_bart_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/beit/convert_beit_unilm_to_pytorch.py delete mode 100644 src/transformers/models/bert/convert_bert_original_tf2_checkpoint_to_pytorch.py delete mode 100755 src/transformers/models/bert/convert_bert_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/bert/convert_bert_pytorch_checkpoint_to_original_tf.py delete mode 100644 src/transformers/models/bert/convert_bert_token_dropping_original_tf2_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/big_bird/convert_bigbird_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/bigbird_pegasus/convert_bigbird_pegasus_tf_to_pytorch.py delete mode 100755 src/transformers/models/biogpt/convert_biogpt_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/bit/convert_bit_to_pytorch.py delete mode 100644 src/transformers/models/blenderbot/convert_blenderbot_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/blip/convert_blip_original_pytorch_to_hf.py delete mode 100644 src/transformers/models/blip_2/convert_blip_2_original_to_pytorch.py delete mode 100644 src/transformers/models/bloom/convert_bloom_original_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/bros/convert_bros_to_pytorch.py delete mode 100755 src/transformers/models/byt5/convert_byt5_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/canine/convert_canine_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/chameleon/convert_chameleon_weights_to_hf.py delete mode 100644 src/transformers/models/chinese_clip/convert_chinese_clip_original_pytorch_to_hf.py delete mode 100644 src/transformers/models/clap/convert_clap_original_pytorch_to_hf.py delete mode 100644 src/transformers/models/clip/convert_clip_original_pytorch_to_hf.py delete mode 100644 src/transformers/models/clipseg/convert_clipseg_original_pytorch_to_hf.py delete mode 100644 src/transformers/models/clvp/convert_clvp_to_hf.py delete mode 100644 src/transformers/models/colpali/convert_colpali_weights_to_hf.py delete mode 100644 src/transformers/models/conditional_detr/convert_conditional_detr_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/convbert/convert_convbert_original_tf1_checkpoint_to_pytorch_and_tf2.py delete mode 100644 src/transformers/models/convnext/convert_convnext_to_pytorch.py delete mode 100644 src/transformers/models/convnextv2/convert_convnextv2_to_pytorch.py delete mode 100644 src/transformers/models/cvt/convert_cvt_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/dab_detr/convert_dab_detr_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/dac/convert_dac_checkpoint.py delete mode 100644 src/transformers/models/data2vec/convert_data2vec_audio_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/data2vec/convert_data2vec_text_original_pytorch_checkpoint_to_pytorch.py delete mode 100755 src/transformers/models/data2vec/convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/deformable_detr/convert_deformable_detr_to_pytorch.py delete mode 100644 src/transformers/models/deit/convert_deit_timm_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/bort/convert_bort_original_gluonnlp_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/deta/convert_deta_resnet_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/deta/convert_deta_swin_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/efficientformer/convert_efficientformer_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/gptsan_japanese/convert_gptsan_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/jukebox/convert_jukebox.py delete mode 100644 src/transformers/models/deprecated/mega/convert_mega_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/trajectory_transformer/convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/transfo_xl/convert_transfo_xl_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/van/convert_van_to_pytorch.py delete mode 100644 src/transformers/models/deprecated/vit_hybrid/convert_vit_hybrid_timm_to_pytorch.py delete mode 100644 src/transformers/models/depth_anything/convert_depth_anything_to_hf.py delete mode 100644 src/transformers/models/depth_anything/convert_distill_any_depth_to_hf.py delete mode 100644 src/transformers/models/depth_pro/convert_depth_pro_weights_to_hf.py delete mode 100644 src/transformers/models/detr/convert_detr_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/detr/convert_detr_to_pytorch.py delete mode 100644 src/transformers/models/dialogpt/convert_dialogpt_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/dinov2/convert_dinov2_to_hf.py delete mode 100644 src/transformers/models/dinov2_with_registers/convert_dinov2_with_registers_to_hf.py delete mode 100644 src/transformers/models/dit/convert_dit_unilm_to_pytorch.py delete mode 100644 src/transformers/models/donut/convert_donut_to_pytorch.py delete mode 100644 src/transformers/models/dpr/convert_dpr_original_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/dpt/convert_dinov2_depth_to_hf.py delete mode 100644 src/transformers/models/dpt/convert_dpt_beit_to_hf.py delete mode 100644 src/transformers/models/dpt/convert_dpt_hybrid_to_pytorch.py delete mode 100644 src/transformers/models/dpt/convert_dpt_swinv2_to_hf.py delete mode 100644 src/transformers/models/dpt/convert_dpt_to_pytorch.py delete mode 100644 src/transformers/models/efficientnet/convert_efficientnet_to_pytorch.py delete mode 100644 src/transformers/models/electra/convert_electra_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/emu3/convert_emu3_weights_to_hf.py delete mode 100644 src/transformers/models/encodec/convert_encodec_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/esm/convert_esm.py delete mode 100644 src/transformers/models/falcon/convert_custom_code_checkpoint.py delete mode 100644 src/transformers/models/fastspeech2_conformer/convert_fastspeech2_conformer_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/fastspeech2_conformer/convert_hifigan.py delete mode 100644 src/transformers/models/fastspeech2_conformer/convert_model_with_hifigan.py delete mode 100644 src/transformers/models/flava/convert_dalle_to_flava_codebook.py delete mode 100644 src/transformers/models/flava/convert_flava_original_pytorch_to_hf.py delete mode 100644 src/transformers/models/fnet/convert_fnet_original_flax_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/focalnet/convert_focalnet_to_hf_format.py delete mode 100755 src/transformers/models/fsmt/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py delete mode 100755 src/transformers/models/funnel/convert_funnel_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/fuyu/convert_fuyu_model_weights_to_hf.py delete mode 100644 src/transformers/models/gemma/convert_gemma_weights_to_hf.py delete mode 100644 src/transformers/models/gemma2/convert_gemma2_weights_to_hf.py delete mode 100644 src/transformers/models/gemma3/convert_gemma3_weights_orbax_to_hf.py delete mode 100644 src/transformers/models/git/convert_git_to_pytorch.py delete mode 100644 src/transformers/models/glm/convert_glm_weights_to_hf.py delete mode 100644 src/transformers/models/glpn/convert_glpn_to_pytorch.py delete mode 100644 src/transformers/models/got_ocr2/convert_got_ocr2_weights_to_hf.py delete mode 100755 src/transformers/models/gpt2/convert_gpt2_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/gpt_neo/convert_gpt_neo_mesh_tf_to_pytorch.py delete mode 100644 src/transformers/models/gpt_sw3/convert_megatron_to_pytorch.py delete mode 100644 src/transformers/models/grounding_dino/convert_grounding_dino_to_hf.py delete mode 100644 src/transformers/models/groupvit/convert_groupvit_nvlab_to_hf.py delete mode 100644 src/transformers/models/hiera/convert_hiera_to_hf.py delete mode 100644 src/transformers/models/hubert/convert_distilhubert_original_s3prl_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/hubert/convert_hubert_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/hubert/convert_hubert_original_s3prl_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/idefics2/convert_idefics2_weights_to_hf.py delete mode 100644 src/transformers/models/idefics3/convert_idefics3_weights_to_hf.py delete mode 100644 src/transformers/models/ijepa/convert_ijepa_to_hf.py delete mode 100644 src/transformers/models/imagegpt/convert_imagegpt_original_tf2_to_pytorch.py delete mode 100644 src/transformers/models/instructblip/convert_instructblip_original_to_pytorch.py delete mode 100644 src/transformers/models/instructblipvideo/convert_instructblipvideo_original_to_pytorch.py delete mode 100644 src/transformers/models/kosmos2/convert_kosmos2_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/levit/convert_levit_timm_to_pytorch.py delete mode 100644 src/transformers/models/llama/convert_llama_weights_to_hf.py delete mode 100644 src/transformers/models/llama4/convert_llama4_weights_to_hf.py delete mode 100644 src/transformers/models/llava/convert_llava_weights_to_hf.py delete mode 100644 src/transformers/models/llava_next/convert_llava_next_weights_to_hf.py delete mode 100644 src/transformers/models/llava_next_video/convert_llava_next_video_weights_to_hf.py delete mode 100644 src/transformers/models/llava_onevision/convert_llava_onevision_weights_to_hf.py delete mode 100644 src/transformers/models/longformer/convert_longformer_original_pytorch_lightning_to_pytorch.py delete mode 100644 src/transformers/models/longt5/convert_longt5x_checkpoint_to_flax.py delete mode 100644 src/transformers/models/luke/convert_luke_original_pytorch_checkpoint_to_pytorch.py delete mode 100755 src/transformers/models/lxmert/convert_lxmert_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/m2m_100/convert_m2m100_original_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/mamba/convert_mamba_ssm_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/mamba2/convert_mamba2_ssm_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/marian/convert_marian_tatoeba_to_pytorch.py delete mode 100644 src/transformers/models/marian/convert_marian_to_pytorch.py delete mode 100644 src/transformers/models/mask2former/convert_mask2former_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/maskformer/convert_maskformer_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/maskformer/convert_maskformer_resnet_to_pytorch.py delete mode 100644 src/transformers/models/maskformer/convert_maskformer_swin_to_pytorch.py delete mode 100644 src/transformers/models/mbart/convert_mbart_original_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py delete mode 100644 src/transformers/models/megatron_gpt2/convert_megatron_gpt2_checkpoint.py delete mode 100644 src/transformers/models/mimi/convert_mimi_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/mistral/convert_mistral_weights_to_hf.py delete mode 100644 src/transformers/models/mistral3/convert_mistral3_weights_to_hf.py delete mode 100644 src/transformers/models/mixtral/convert_mixtral_weights_to_hf.py delete mode 100644 src/transformers/models/mllama/convert_mllama_weights_to_hf.py delete mode 100644 src/transformers/models/mluke/convert_mluke_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/mobilebert/convert_mobilebert_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/mobilenet_v1/convert_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/mobilenet_v2/convert_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/mobilevit/convert_mlcvnets_to_pytorch.py delete mode 100644 src/transformers/models/mobilevitv2/convert_mlcvnets_to_pytorch.py delete mode 100644 src/transformers/models/moonshine/convert_usefulsensors_to_hf.py delete mode 100644 src/transformers/models/moshi/convert_moshi_transformers.py delete mode 100644 src/transformers/models/mra/convert_mra_pytorch_to_pytorch.py delete mode 100644 src/transformers/models/musicgen/convert_musicgen_transformers.py delete mode 100644 src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py delete mode 100644 src/transformers/models/myt5/convert_myt5_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/nemotron/convert_nemotron_nemo_to_hf.py delete mode 100644 src/transformers/models/nllb_moe/convert_nllb_moe_sharded_original_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/nougat/convert_nougat_to_hf.py delete mode 100644 src/transformers/models/nystromformer/convert_nystromformer_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/olmo/convert_olmo_weights_to_hf.py delete mode 100644 src/transformers/models/olmo2/convert_olmo2_weights_to_hf.py delete mode 100644 src/transformers/models/olmoe/convert_olmoe_weights_to_hf.py delete mode 100644 src/transformers/models/omdet_turbo/convert_omdet_turbo_to_hf.py delete mode 100644 src/transformers/models/oneformer/convert_to_hf_oneformer.py delete mode 100755 src/transformers/models/openai/convert_openai_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/opt/convert_opt_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/owlv2/convert_owlv2_to_hf.py delete mode 100644 src/transformers/models/owlvit/convert_owlvit_original_flax_to_hf.py delete mode 100644 src/transformers/models/paligemma/convert_paligemma2_weights_to_hf.py delete mode 100644 src/transformers/models/paligemma/convert_paligemma_weights_to_hf.py delete mode 100644 src/transformers/models/pegasus/convert_pegasus_tf_to_pytorch.py delete mode 100644 src/transformers/models/perceiver/convert_perceiver_haiku_to_pytorch.py delete mode 100644 src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py delete mode 100644 src/transformers/models/phi/convert_phi_weights_to_hf.py delete mode 100644 src/transformers/models/phi4_multimodal/convert_phi4_multimodal_weights_to_hf.py delete mode 100644 src/transformers/models/pix2struct/convert_pix2struct_original_pytorch_to_hf.py delete mode 100644 src/transformers/models/pixtral/convert_pixtral_weights_to_hf.py delete mode 100644 src/transformers/models/plbart/convert_plbart_original_checkpoint_to_torch.py delete mode 100644 src/transformers/models/poolformer/convert_poolformer_original_to_pytorch.py delete mode 100644 src/transformers/models/pop2piano/convert_pop2piano_weights_to_hf.py delete mode 100644 src/transformers/models/prompt_depth_anything/convert_prompt_depth_anything_to_hf.py delete mode 100644 src/transformers/models/prophetnet/convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/pvt/convert_pvt_to_pytorch.py delete mode 100644 src/transformers/models/pvt_v2/convert_pvt_v2_to_pytorch.py delete mode 100644 src/transformers/models/recurrent_gemma/convert_recurrent_gemma_to_hf.py delete mode 100755 src/transformers/models/reformer/convert_reformer_trax_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/regnet/convert_regnet_seer_10b_to_pytorch.py delete mode 100644 src/transformers/models/regnet/convert_regnet_to_pytorch.py delete mode 100755 src/transformers/models/rembert/convert_rembert_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/resnet/convert_resnet_to_pytorch.py delete mode 100644 src/transformers/models/roberta/convert_roberta_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/roberta_prelayernorm/convert_roberta_prelayernorm_original_pytorch_checkpoint_to_pytorch.py delete mode 100755 src/transformers/models/roformer/convert_roformer_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/rt_detr/convert_rt_detr_original_pytorch_checkpoint_to_hf.py delete mode 100644 src/transformers/models/rt_detr_v2/convert_rt_detr_v2_weights_to_hf.py delete mode 100644 src/transformers/models/rwkv/convert_rwkv_checkpoint_to_hf.py delete mode 100644 src/transformers/models/sam/convert_sam_to_hf.py delete mode 100644 src/transformers/models/seamless_m4t/convert_fairseq2_to_hf.py delete mode 100644 src/transformers/models/seamless_m4t_v2/convert_fairseq2_to_hf.py delete mode 100644 src/transformers/models/segformer/convert_segformer_original_to_pytorch.py delete mode 100644 src/transformers/models/seggpt/convert_seggpt_to_hf.py delete mode 100644 src/transformers/models/sew/convert_sew_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/sew_d/convert_sew_d_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/shieldgemma2/convert_shieldgemma2_weights_orbax_to_hf.py delete mode 100644 src/transformers/models/siglip/convert_siglip_to_hf.py delete mode 100644 src/transformers/models/siglip2/convert_siglip2_to_hf.py delete mode 100644 src/transformers/models/speech_encoder_decoder/convert_mbart_wav2vec2_seq2seq_original_to_pytorch.py delete mode 100644 src/transformers/models/speech_encoder_decoder/convert_speech_to_text_wav2vec2_seq2seq_original_to_pytorch.py delete mode 100644 src/transformers/models/speech_to_text/convert_s2t_fairseq_to_tfms.py delete mode 100644 src/transformers/models/speecht5/convert_hifigan.py delete mode 100644 src/transformers/models/speecht5/convert_speecht5_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/superglue/convert_superglue_to_hf.py delete mode 100644 src/transformers/models/superpoint/convert_superpoint_to_pytorch.py delete mode 100644 src/transformers/models/swiftformer/convert_swiftformer_original_to_hf.py delete mode 100644 src/transformers/models/swin/convert_swin_simmim_to_pytorch.py delete mode 100644 src/transformers/models/swin/convert_swin_timm_to_pytorch.py delete mode 100644 src/transformers/models/swin2sr/convert_swin2sr_original_to_pytorch.py delete mode 100644 src/transformers/models/swinv2/convert_swinv2_timm_to_pytorch.py delete mode 100644 src/transformers/models/switch_transformers/convert_big_switch.py delete mode 100644 src/transformers/models/switch_transformers/convert_switch_transformers_original_flax_checkpoint_to_pytorch.py delete mode 100755 src/transformers/models/t5/convert_t5_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/t5/convert_t5x_checkpoint_to_flax.py delete mode 100755 src/transformers/models/t5/convert_t5x_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/table_transformer/convert_table_transformer_to_hf.py delete mode 100644 src/transformers/models/table_transformer/convert_table_transformer_to_hf_no_timm.py delete mode 100644 src/transformers/models/tapas/convert_tapas_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/textnet/convert_textnet_to_hf.py delete mode 100644 src/transformers/models/timesformer/convert_timesformer_to_pytorch.py delete mode 100644 src/transformers/models/trocr/convert_trocr_unilm_to_pytorch.py delete mode 100644 src/transformers/models/udop/convert_udop_to_hf.py delete mode 100644 src/transformers/models/umt5/convert_umt5_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/unispeech/convert_unispeech_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/unispeech_sat/convert_unispeech_original_s3prl_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/unispeech_sat/convert_unispeech_sat_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/univnet/convert_univnet.py delete mode 100644 src/transformers/models/upernet/convert_convnext_upernet_to_pytorch.py delete mode 100644 src/transformers/models/upernet/convert_swin_upernet_to_pytorch.py delete mode 100644 src/transformers/models/video_llava/convert_video_llava_weights_to_hf.py delete mode 100644 src/transformers/models/videomae/convert_videomae_to_pytorch.py delete mode 100644 src/transformers/models/vilt/convert_vilt_original_to_pytorch.py delete mode 100644 src/transformers/models/vipllava/convert_vipllava_weights_to_hf.py delete mode 100644 src/transformers/models/visual_bert/convert_visual_bert_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/vit/convert_dino_to_pytorch.py delete mode 100644 src/transformers/models/vit/convert_vit_timm_to_pytorch.py delete mode 100644 src/transformers/models/vit_mae/convert_vit_mae_to_pytorch.py delete mode 100644 src/transformers/models/vit_msn/convert_msn_to_pytorch.py delete mode 100644 src/transformers/models/vitmatte/convert_vitmatte_to_hf.py delete mode 100644 src/transformers/models/vitpose/convert_vitpose_to_hf.py delete mode 100644 src/transformers/models/vits/convert_original_checkpoint.py delete mode 100644 src/transformers/models/vivit/convert_vivit_flax_to_pytorch.py delete mode 100644 src/transformers/models/wav2vec2/convert_wav2vec2_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/wav2vec2/convert_wav2vec2_original_s3prl_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/wav2vec2_bert/convert_wav2vec2_seamless_checkpoint.py delete mode 100644 src/transformers/models/wav2vec2_conformer/convert_wav2vec2_conformer_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/wavlm/convert_wavlm_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/wavlm/convert_wavlm_original_s3prl_checkpoint_to_pytorch.py delete mode 100755 src/transformers/models/whisper/convert_openai_to_hf.py delete mode 100644 src/transformers/models/x_clip/convert_x_clip_original_pytorch_to_hf.py delete mode 100644 src/transformers/models/xglm/convert_xglm_original_ckpt_to_trfms.py delete mode 100755 src/transformers/models/xlm/convert_xlm_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/xlm_roberta_xl/convert_xlm_roberta_xl_original_pytorch_checkpoint_to_pytorch.py delete mode 100755 src/transformers/models/xlnet/convert_xlnet_original_tf_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/xmod/convert_xmod_original_pytorch_checkpoint_to_pytorch.py delete mode 100644 src/transformers/models/yolos/convert_yolos_to_pytorch.py delete mode 100644 src/transformers/models/yoso/convert_yoso_pytorch_to_pytorch.py delete mode 100644 src/transformers/models/zoedepth/convert_zoedepth_to_hf.py", "patch_text_b64": "From 0720e206c6ba28887e4d60ef60a6a089f6c1cc76 Mon Sep 17 00:00:00 2001
From: Lysandre <hi@lysand.re>
Date: Sat, 5 Apr 2025 22:03:17 +0200
Subject: [PATCH] Release: v4.51.0

---
 examples/flax/question-answering/run_qa.py    |    2 +-
 .../run_flax_speech_recognition_seq2seq.py    |    2 +-
 .../flax/text-classification/run_flax_glue.py |    2 +-
 .../flax/token-classification/run_flax_ner.py |    2 +-
 .../run_audio_classification.py               |    2 +-
 .../contrastive-image-text/run_clip.py        |    2 +-
 .../run_image_classification.py               |    2 +-
 .../run_image_classification_no_trainer.py    |    2 +-
 examples/pytorch/image-pretraining/run_mae.py |    2 +-
 examples/pytorch/image-pretraining/run_mim.py |    2 +-
 .../image-pretraining/run_mim_no_trainer.py   |    2 +-
 .../run_instance_segmentation.py              |    2 +-
 .../run_instance_segmentation_no_trainer.py   |    2 +-
 examples/pytorch/language-modeling/run_clm.py |    2 +-
 .../language-modeling/run_clm_no_trainer.py   |    2 +-
 examples/pytorch/language-modeling/run_fim.py |    2 +-
 .../language-modeling/run_fim_no_trainer.py   |    2 +-
 examples/pytorch/language-modeling/run_mlm.py |    2 +-
 .../language-modeling/run_mlm_no_trainer.py   |    2 +-
 examples/pytorch/language-modeling/run_plm.py |    2 +-
 examples/pytorch/multiple-choice/run_swag.py  |    2 +-
 .../multiple-choice/run_swag_no_trainer.py    |    2 +-
 .../object-detection/run_object_detection.py  |    2 +-
 .../run_object_detection_no_trainer.py        |    2 +-
 examples/pytorch/question-answering/run_qa.py |    2 +-
 .../question-answering/run_qa_beam_search.py  |    2 +-
 .../run_qa_beam_search_no_trainer.py          |    2 +-
 .../question-answering/run_qa_no_trainer.py   |    2 +-
 .../question-answering/run_seq2seq_qa.py      |    2 +-
 .../run_semantic_segmentation.py              |    2 +-
 .../run_semantic_segmentation_no_trainer.py   |    2 +-
 .../run_speech_recognition_ctc.py             |    2 +-
 .../run_speech_recognition_ctc_adapter.py     |    2 +-
 .../run_speech_recognition_seq2seq.py         |    2 +-
 .../summarization/run_summarization.py        |    2 +-
 .../run_summarization_no_trainer.py           |    2 +-
 .../text-classification/run_classification.py |    2 +-
 .../pytorch/text-classification/run_glue.py   |    2 +-
 .../run_glue_no_trainer.py                    |    2 +-
 .../pytorch/text-classification/run_xnli.py   |    2 +-
 .../pytorch/token-classification/run_ner.py   |    2 +-
 .../run_ner_no_trainer.py                     |    2 +-
 .../pytorch/translation/run_translation.py    |    2 +-
 .../translation/run_translation_no_trainer.py |    2 +-
 .../contrastive-image-text/run_clip.py        |    2 +-
 .../run_image_classification.py               |    2 +-
 .../tensorflow/multiple-choice/run_swag.py    |    2 +-
 .../tensorflow/question-answering/run_qa.py   |    2 +-
 .../summarization/run_summarization.py        |    2 +-
 .../text-classification/run_glue.py           |    2 +-
 .../tensorflow/translation/run_translation.py |    2 +-
 setup.py                                      |    2 +-
 src/transformers/__init__.py                  |    2 +-
 ...lbert_original_tf_checkpoint_to_pytorch.py |   62 -
 .../models/align/convert_align_tf_to_hf.py    |  389 -----
 .../models/aria/convert_aria_weights_to_hf.py |  162 --
 ...trogram_transformer_original_to_pytorch.py |  279 ----
 .../bamba/convert_mamba_ssm_checkpoint.py     |  273 ----
 .../models/bark/convert_suno_to_hf.py         |  263 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  156 --
 .../beit/convert_beit_unilm_to_pytorch.py     |  373 -----
 ...bert_original_tf2_checkpoint_to_pytorch.py |  246 ---
 ..._bert_original_tf_checkpoint_to_pytorch.py |   62 -
 ..._bert_pytorch_checkpoint_to_original_tf.py |  112 --
 ...ping_original_tf2_checkpoint_to_pytorch.py |  188 ---
 ...gbird_original_tf_checkpoint_to_pytorch.py |   69 -
 .../convert_bigbird_pegasus_tf_to_pytorch.py  |  170 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  292 ----
 .../models/bit/convert_bit_to_pytorch.py      |  177 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  114 --
 .../convert_blip_original_pytorch_to_hf.py    |  191 ---
 .../convert_blip_2_original_to_pytorch.py     |  390 -----
 ...rt_bloom_original_checkpoint_to_pytorch.py |  254 ----
 .../models/bros/convert_bros_to_pytorch.py    |  145 --
 ..._byt5_original_tf_checkpoint_to_pytorch.py |   59 -
 ...anine_original_tf_checkpoint_to_pytorch.py |   65 -
 .../convert_chameleon_weights_to_hf.py        |  476 ------
 ...ert_chinese_clip_original_pytorch_to_hf.py |  134 --
 .../convert_clap_original_pytorch_to_hf.py    |  133 --
 .../convert_clip_original_pytorch_to_hf.py    |  156 --
 .../convert_clipseg_original_pytorch_to_hf.py |  264 ----
 .../models/clvp/convert_clvp_to_hf.py         |  234 ---
 .../colpali/convert_colpali_weights_to_hf.py  |  214 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  324 ----
 ...ginal_tf1_checkpoint_to_pytorch_and_tf2.py |   57 -
 .../convnext/convert_convnext_to_pytorch.py   |  242 ---
 .../convert_convnextv2_to_pytorch.py          |  286 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  362 -----
 ..._original_pytorch_checkpoint_to_pytorch.py |  233 ---
 .../models/dac/convert_dac_checkpoint.py      |  261 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  285 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  207 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  374 -----
 .../convert_deformable_detr_to_pytorch.py     |  236 ---
 .../deit/convert_deit_timm_to_pytorch.py      |  218 ---
 ...original_gluonnlp_checkpoint_to_pytorch.py |  318 ----
 .../deta/convert_deta_resnet_to_pytorch.py    |  319 ----
 .../deta/convert_deta_swin_to_pytorch.py      |  326 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  252 ----
 ...convert_gptsan_tf_checkpoint_to_pytorch.py |  181 ---
 .../deprecated/jukebox/convert_jukebox.py     |  279 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  292 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |   70 -
 ...fo_xl_original_tf_checkpoint_to_pytorch.py |  121 --
 .../deprecated/van/convert_van_to_pytorch.py  |  290 ----
 .../convert_vit_hybrid_timm_to_pytorch.py     |  282 ----
 .../convert_depth_anything_to_hf.py           |  368 -----
 .../convert_distill_any_depth_to_hf.py        |  246 ---
 .../convert_depth_pro_weights_to_hf.py        |  254 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  277 ----
 .../models/detr/convert_detr_to_pytorch.py    |  385 -----
 ..._original_pytorch_checkpoint_to_pytorch.py |   46 -
 .../models/dinov2/convert_dinov2_to_hf.py     |  285 ----
 .../convert_dinov2_with_registers_to_hf.py    |  291 ----
 .../dit/convert_dit_unilm_to_pytorch.py       |  230 ---
 .../models/donut/convert_donut_to_pytorch.py  |  234 ---
 ...vert_dpr_original_checkpoint_to_pytorch.py |  143 --
 .../models/dpt/convert_dinov2_depth_to_hf.py  |  383 -----
 .../models/dpt/convert_dpt_beit_to_hf.py      |  305 ----
 .../dpt/convert_dpt_hybrid_to_pytorch.py      |  315 ----
 .../models/dpt/convert_dpt_swinv2_to_hf.py    |  321 ----
 .../models/dpt/convert_dpt_to_pytorch.py      |  285 ----
 .../convert_efficientnet_to_pytorch.py        |  339 -----
 ...ectra_original_tf_checkpoint_to_pytorch.py |   79 -
 .../models/emu3/convert_emu3_weights_to_hf.py |  448 ------
 .../convert_encodec_checkpoint_to_pytorch.py  |  365 -----
 src/transformers/models/esm/convert_esm.py    |  399 -----
 .../falcon/convert_custom_code_checkpoint.py  |   74 -
 ..._original_pytorch_checkpoint_to_pytorch.py |  210 ---
 .../fastspeech2_conformer/convert_hifigan.py  |  134 --
 .../convert_model_with_hifigan.py             |  102 --
 .../flava/convert_dalle_to_flava_codebook.py  |  102 --
 .../convert_flava_original_pytorch_to_hf.py   |   99 --
 ...net_original_flax_checkpoint_to_pytorch.py |  156 --
 .../focalnet/convert_focalnet_to_hf_format.py |  237 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  280 ----
 ...unnel_original_tf_checkpoint_to_pytorch.py |   67 -
 .../fuyu/convert_fuyu_model_weights_to_hf.py  |  134 --
 .../gemma/convert_gemma_weights_to_hf.py      |  206 ---
 .../gemma2/convert_gemma2_weights_to_hf.py    |  239 ---
 .../convert_gemma3_weights_orbax_to_hf.py     |  589 --------
 .../models/git/convert_git_to_pytorch.py      |  448 ------
 .../models/glm/convert_glm_weights_to_hf.py   |  195 ---
 .../models/glpn/convert_glpn_to_pytorch.py    |  218 ---
 .../convert_got_ocr2_weights_to_hf.py         |  274 ----
 ..._gpt2_original_tf_checkpoint_to_pytorch.py |   68 -
 .../convert_gpt_neo_mesh_tf_to_pytorch.py     |   71 -
 .../gpt_sw3/convert_megatron_to_pytorch.py    |  197 ---
 .../convert_grounding_dino_to_hf.py           |  491 ------
 .../groupvit/convert_groupvit_nvlab_to_hf.py  |  217 ---
 .../models/hiera/convert_hiera_to_hf.py       |  369 -----
 ...rt_original_s3prl_checkpoint_to_pytorch.py |  222 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  261 ----
 ...rt_original_s3prl_checkpoint_to_pytorch.py |   68 -
 .../convert_idefics2_weights_to_hf.py         |  185 ---
 .../convert_idefics3_weights_to_hf.py         |  214 ---
 .../models/ijepa/convert_ijepa_to_hf.py       |  267 ----
 ...onvert_imagegpt_original_tf2_to_pytorch.py |   71 -
 ...onvert_instructblip_original_to_pytorch.py |  303 ----
 ...t_instructblipvideo_original_to_pytorch.py |  305 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |   77 -
 .../levit/convert_levit_timm_to_pytorch.py    |  181 ---
 .../llama/convert_llama_weights_to_hf.py      |  601 --------
 .../llama4/convert_llama4_weights_to_hf.py    |  736 ---------
 .../llava/convert_llava_weights_to_hf.py      |  204 ---
 .../convert_llava_next_weights_to_hf.py       |  397 -----
 .../convert_llava_next_video_weights_to_hf.py |  276 ----
 .../convert_llava_onevision_weights_to_hf.py  |  388 -----
 ...r_original_pytorch_lightning_to_pytorch.py |   85 --
 .../convert_longt5x_checkpoint_to_flax.py     |  215 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  170 ---
 ...xmert_original_tf_checkpoint_to_pytorch.py |   59 -
 ...t_m2m100_original_checkpoint_to_pytorch.py |   85 --
 ...convert_mamba_ssm_checkpoint_to_pytorch.py |  153 --
 ...onvert_mamba2_ssm_checkpoint_to_pytorch.py |  193 ---
 .../convert_marian_tatoeba_to_pytorch.py      | 1327 -----------------
 .../marian/convert_marian_to_pytorch.py       |  717 ---------
 ..._original_pytorch_checkpoint_to_pytorch.py | 1019 -------------
 ..._original_pytorch_checkpoint_to_pytorch.py |  731 ---------
 .../convert_maskformer_resnet_to_pytorch.py   |  390 -----
 .../convert_maskformer_swin_to_pytorch.py     |  333 -----
 ...rt_mbart_original_checkpoint_to_pytorch.py |   83 --
 .../convert_megatron_bert_checkpoint.py       |  334 -----
 .../convert_megatron_gpt2_checkpoint.py       |  358 -----
 .../convert_mimi_checkpoint_to_pytorch.py     |  198 ---
 .../mistral/convert_mistral_weights_to_hf.py  |  282 ----
 .../convert_mistral3_weights_to_hf.py         |  241 ---
 .../mixtral/convert_mixtral_weights_to_hf.py  |  244 ---
 .../mllama/convert_mllama_weights_to_hf.py    |  639 --------
 ..._original_pytorch_checkpoint_to_pytorch.py |  229 ---
 ...ebert_original_tf_checkpoint_to_pytorch.py |   58 -
 ...nvert_original_tf_checkpoint_to_pytorch.py |  141 --
 ...nvert_original_tf_checkpoint_to_pytorch.py |  177 ---
 .../mobilevit/convert_mlcvnets_to_pytorch.py  |  311 ----
 .../convert_mlcvnets_to_pytorch.py            |  332 -----
 .../moonshine/convert_usefulsensors_to_hf.py  |  169 ---
 .../moshi/convert_moshi_transformers.py       |  311 ----
 .../mra/convert_mra_pytorch_to_pytorch.py     |  110 --
 .../musicgen/convert_musicgen_transformers.py |  236 ---
 .../convert_musicgen_melody_transformers.py   |  267 ----
 ..._myt5_original_tf_checkpoint_to_pytorch.py |   60 -
 .../nemotron/convert_nemotron_nemo_to_hf.py   |  346 -----
 ..._sharded_original_checkpoint_to_pytorch.py |  161 --
 .../models/nougat/convert_nougat_to_hf.py     |  282 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  111 --
 .../models/olmo/convert_olmo_weights_to_hf.py |  248 ---
 .../olmo2/convert_olmo2_weights_to_hf.py      |  306 ----
 .../olmoe/convert_olmoe_weights_to_hf.py      |  281 ----
 .../omdet_turbo/convert_omdet_turbo_to_hf.py  |  349 -----
 .../oneformer/convert_to_hf_oneformer.py      | 1191 ---------------
 ...penai_original_tf_checkpoint_to_pytorch.py |   74 -
 ..._original_pytorch_checkpoint_to_pytorch.py |  113 --
 .../models/owlv2/convert_owlv2_to_hf.py       |  422 ------
 .../convert_owlvit_original_flax_to_hf.py     |  406 -----
 .../convert_paligemma2_weights_to_hf.py       |  415 ------
 .../convert_paligemma_weights_to_hf.py        |  347 -----
 .../pegasus/convert_pegasus_tf_to_pytorch.py  |  131 --
 .../convert_perceiver_haiku_to_pytorch.py     |  468 ------
 .../convert_persimmon_weights_to_hf.py        |  129 --
 .../models/phi/convert_phi_weights_to_hf.py   |  207 ---
 .../convert_phi4_multimodal_weights_to_hf.py  |  229 ---
 ...nvert_pix2struct_original_pytorch_to_hf.py |  155 --
 .../pixtral/convert_pixtral_weights_to_hf.py  |  246 ---
 ...ert_plbart_original_checkpoint_to_torch.py |   94 --
 .../convert_poolformer_original_to_pytorch.py |  214 ---
 .../convert_pop2piano_weights_to_hf.py        |  190 ---
 .../convert_prompt_depth_anything_to_hf.py    |  292 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  159 --
 .../models/pvt/convert_pvt_to_pytorch.py      |  226 ---
 .../pvt_v2/convert_pvt_v2_to_pytorch.py       |  294 ----
 .../convert_recurrent_gemma_to_hf.py          |  222 ---
 ...ert_reformer_trax_checkpoint_to_pytorch.py |  226 ---
 .../convert_regnet_seer_10b_to_pytorch.py     |  308 ----
 .../regnet/convert_regnet_to_pytorch.py       |  458 ------
 ...onvert_rembert_tf_checkpoint_to_pytorch.py |   62 -
 .../resnet/convert_resnet_to_pytorch.py       |  199 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  177 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |   77 -
 ...ormer_original_tf_checkpoint_to_pytorch.py |   62 -
 ..._detr_original_pytorch_checkpoint_to_hf.py |  782 ----------
 .../convert_rt_detr_v2_weights_to_hf.py       |  363 -----
 .../rwkv/convert_rwkv_checkpoint_to_hf.py     |  209 ---
 .../models/sam/convert_sam_to_hf.py           |  251 ----
 .../seamless_m4t/convert_fairseq2_to_hf.py    |  396 -----
 .../seamless_m4t_v2/convert_fairseq2_to_hf.py |  404 -----
 .../convert_segformer_original_to_pytorch.py  |  387 -----
 .../models/seggpt/convert_seggpt_to_hf.py     |  221 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  305 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  317 ----
 ...onvert_shieldgemma2_weights_orbax_to_hf.py |  470 ------
 .../models/siglip/convert_siglip_to_hf.py     |  533 -------
 .../models/siglip2/convert_siglip2_to_hf.py   |  438 ------
 ...rt_wav2vec2_seq2seq_original_to_pytorch.py |  357 -----
 ...xt_wav2vec2_seq2seq_original_to_pytorch.py |  316 ----
 .../convert_s2t_fairseq_to_tfms.py            |  121 --
 .../models/speecht5/convert_hifigan.py        |  108 --
 ..._original_pytorch_checkpoint_to_pytorch.py |  401 -----
 .../superglue/convert_superglue_to_hf.py      |  342 -----
 .../convert_superpoint_to_pytorch.py          |  175 ---
 .../convert_swiftformer_original_to_hf.py     |  175 ---
 .../swin/convert_swin_simmim_to_pytorch.py    |  182 ---
 .../swin/convert_swin_timm_to_pytorch.py      |  173 ---
 .../convert_swin2sr_original_to_pytorch.py    |  278 ----
 .../swinv2/convert_swinv2_timm_to_pytorch.py  |  219 ---
 .../switch_transformers/convert_big_switch.py |  194 ---
 ...ers_original_flax_checkpoint_to_pytorch.py |  203 ---
 ...rt_t5_original_tf_checkpoint_to_pytorch.py |   59 -
 .../t5/convert_t5x_checkpoint_to_flax.py      |  235 ---
 .../t5/convert_t5x_checkpoint_to_pytorch.py   |  238 ---
 .../convert_table_transformer_to_hf.py        |  317 ----
 ...convert_table_transformer_to_hf_no_timm.py |  434 ------
 ...tapas_original_tf_checkpoint_to_pytorch.py |  137 --
 .../models/textnet/convert_textnet_to_hf.py   |  208 ---
 .../convert_timesformer_to_pytorch.py         |  253 ----
 .../trocr/convert_trocr_unilm_to_pytorch.py   |  237 ---
 .../models/udop/convert_udop_to_hf.py         |  224 ---
 .../convert_umt5_checkpoint_to_pytorch.py     |  274 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  273 ----
 ...ch_original_s3prl_checkpoint_to_pytorch.py |  109 --
 ..._original_pytorch_checkpoint_to_pytorch.py |  224 ---
 .../models/univnet/convert_univnet.py         |  162 --
 .../convert_convnext_upernet_to_pytorch.py    |  214 ---
 .../convert_swin_upernet_to_pytorch.py        |  297 ----
 .../convert_video_llava_weights_to_hf.py      |  159 --
 .../videomae/convert_videomae_to_pytorch.py   |  324 ----
 .../vilt/convert_vilt_original_to_pytorch.py  |  299 ----
 .../convert_vipllava_weights_to_hf.py         |  132 --
 ..._original_pytorch_checkpoint_to_pytorch.py |  149 --
 .../models/vit/convert_dino_to_pytorch.py     |  218 ---
 .../models/vit/convert_vit_timm_to_pytorch.py |  254 ----
 .../vit_mae/convert_vit_mae_to_pytorch.py     |  178 ---
 .../models/vit_msn/convert_msn_to_pytorch.py  |  245 ---
 .../models/vitmatte/convert_vitmatte_to_hf.py |  170 ---
 .../models/vitpose/convert_vitpose_to_hf.py   |  428 ------
 .../vits/convert_original_checkpoint.py       |  390 -----
 .../vivit/convert_vivit_flax_to_pytorch.py    |  231 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  385 -----
 ...c2_original_s3prl_checkpoint_to_pytorch.py |  109 --
 .../convert_wav2vec2_seamless_checkpoint.py   |  217 ---
 ..._original_pytorch_checkpoint_to_pytorch.py |  309 ----
 ..._original_pytorch_checkpoint_to_pytorch.py |  206 ---
 ...lm_original_s3prl_checkpoint_to_pytorch.py |  109 --
 .../models/whisper/convert_openai_to_hf.py    |  370 -----
 .../convert_x_clip_original_pytorch_to_hf.py  |  386 -----
 .../convert_xglm_original_ckpt_to_trfms.py    |   68 -
 ..._original_pytorch_checkpoint_to_pytorch.py |   77 -
 ..._original_pytorch_checkpoint_to_pytorch.py |  183 ---
 ...xlnet_original_tf_checkpoint_to_pytorch.py |  113 --
 ..._original_pytorch_checkpoint_to_pytorch.py |  212 ---
 .../models/yolos/convert_yolos_to_pytorch.py  |  267 ----
 .../yoso/convert_yoso_pytorch_to_pytorch.py   |  108 --
 .../models/zoedepth/convert_zoedepth_to_hf.py |  426 ------
 312 files changed, 53 insertions(+), 66972 deletions(-)
 delete mode 100644 src/transformers/models/albert/convert_albert_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/align/convert_align_tf_to_hf.py
 delete mode 100644 src/transformers/models/aria/convert_aria_weights_to_hf.py
 delete mode 100644 src/transformers/models/audio_spectrogram_transformer/convert_audio_spectrogram_transformer_original_to_pytorch.py
 delete mode 100644 src/transformers/models/bamba/convert_mamba_ssm_checkpoint.py
 delete mode 100644 src/transformers/models/bark/convert_suno_to_hf.py
 delete mode 100644 src/transformers/models/bart/convert_bart_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/beit/convert_beit_unilm_to_pytorch.py
 delete mode 100644 src/transformers/models/bert/convert_bert_original_tf2_checkpoint_to_pytorch.py
 delete mode 100755 src/transformers/models/bert/convert_bert_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/bert/convert_bert_pytorch_checkpoint_to_original_tf.py
 delete mode 100644 src/transformers/models/bert/convert_bert_token_dropping_original_tf2_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/big_bird/convert_bigbird_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/bigbird_pegasus/convert_bigbird_pegasus_tf_to_pytorch.py
 delete mode 100755 src/transformers/models/biogpt/convert_biogpt_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/bit/convert_bit_to_pytorch.py
 delete mode 100644 src/transformers/models/blenderbot/convert_blenderbot_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/blip/convert_blip_original_pytorch_to_hf.py
 delete mode 100644 src/transformers/models/blip_2/convert_blip_2_original_to_pytorch.py
 delete mode 100644 src/transformers/models/bloom/convert_bloom_original_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/bros/convert_bros_to_pytorch.py
 delete mode 100755 src/transformers/models/byt5/convert_byt5_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/canine/convert_canine_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/chameleon/convert_chameleon_weights_to_hf.py
 delete mode 100644 src/transformers/models/chinese_clip/convert_chinese_clip_original_pytorch_to_hf.py
 delete mode 100644 src/transformers/models/clap/convert_clap_original_pytorch_to_hf.py
 delete mode 100644 src/transformers/models/clip/convert_clip_original_pytorch_to_hf.py
 delete mode 100644 src/transformers/models/clipseg/convert_clipseg_original_pytorch_to_hf.py
 delete mode 100644 src/transformers/models/clvp/convert_clvp_to_hf.py
 delete mode 100644 src/transformers/models/colpali/convert_colpali_weights_to_hf.py
 delete mode 100644 src/transformers/models/conditional_detr/convert_conditional_detr_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/convbert/convert_convbert_original_tf1_checkpoint_to_pytorch_and_tf2.py
 delete mode 100644 src/transformers/models/convnext/convert_convnext_to_pytorch.py
 delete mode 100644 src/transformers/models/convnextv2/convert_convnextv2_to_pytorch.py
 delete mode 100644 src/transformers/models/cvt/convert_cvt_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/dab_detr/convert_dab_detr_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/dac/convert_dac_checkpoint.py
 delete mode 100644 src/transformers/models/data2vec/convert_data2vec_audio_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/data2vec/convert_data2vec_text_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100755 src/transformers/models/data2vec/convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/deformable_detr/convert_deformable_detr_to_pytorch.py
 delete mode 100644 src/transformers/models/deit/convert_deit_timm_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/bort/convert_bort_original_gluonnlp_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/deta/convert_deta_resnet_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/deta/convert_deta_swin_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/efficientformer/convert_efficientformer_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/gptsan_japanese/convert_gptsan_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/jukebox/convert_jukebox.py
 delete mode 100644 src/transformers/models/deprecated/mega/convert_mega_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/trajectory_transformer/convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/transfo_xl/convert_transfo_xl_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/van/convert_van_to_pytorch.py
 delete mode 100644 src/transformers/models/deprecated/vit_hybrid/convert_vit_hybrid_timm_to_pytorch.py
 delete mode 100644 src/transformers/models/depth_anything/convert_depth_anything_to_hf.py
 delete mode 100644 src/transformers/models/depth_anything/convert_distill_any_depth_to_hf.py
 delete mode 100644 src/transformers/models/depth_pro/convert_depth_pro_weights_to_hf.py
 delete mode 100644 src/transformers/models/detr/convert_detr_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/detr/convert_detr_to_pytorch.py
 delete mode 100644 src/transformers/models/dialogpt/convert_dialogpt_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/dinov2/convert_dinov2_to_hf.py
 delete mode 100644 src/transformers/models/dinov2_with_registers/convert_dinov2_with_registers_to_hf.py
 delete mode 100644 src/transformers/models/dit/convert_dit_unilm_to_pytorch.py
 delete mode 100644 src/transformers/models/donut/convert_donut_to_pytorch.py
 delete mode 100644 src/transformers/models/dpr/convert_dpr_original_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/dpt/convert_dinov2_depth_to_hf.py
 delete mode 100644 src/transformers/models/dpt/convert_dpt_beit_to_hf.py
 delete mode 100644 src/transformers/models/dpt/convert_dpt_hybrid_to_pytorch.py
 delete mode 100644 src/transformers/models/dpt/convert_dpt_swinv2_to_hf.py
 delete mode 100644 src/transformers/models/dpt/convert_dpt_to_pytorch.py
 delete mode 100644 src/transformers/models/efficientnet/convert_efficientnet_to_pytorch.py
 delete mode 100644 src/transformers/models/electra/convert_electra_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/emu3/convert_emu3_weights_to_hf.py
 delete mode 100644 src/transformers/models/encodec/convert_encodec_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/esm/convert_esm.py
 delete mode 100644 src/transformers/models/falcon/convert_custom_code_checkpoint.py
 delete mode 100644 src/transformers/models/fastspeech2_conformer/convert_fastspeech2_conformer_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/fastspeech2_conformer/convert_hifigan.py
 delete mode 100644 src/transformers/models/fastspeech2_conformer/convert_model_with_hifigan.py
 delete mode 100644 src/transformers/models/flava/convert_dalle_to_flava_codebook.py
 delete mode 100644 src/transformers/models/flava/convert_flava_original_pytorch_to_hf.py
 delete mode 100644 src/transformers/models/fnet/convert_fnet_original_flax_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/focalnet/convert_focalnet_to_hf_format.py
 delete mode 100755 src/transformers/models/fsmt/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100755 src/transformers/models/funnel/convert_funnel_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/fuyu/convert_fuyu_model_weights_to_hf.py
 delete mode 100644 src/transformers/models/gemma/convert_gemma_weights_to_hf.py
 delete mode 100644 src/transformers/models/gemma2/convert_gemma2_weights_to_hf.py
 delete mode 100644 src/transformers/models/gemma3/convert_gemma3_weights_orbax_to_hf.py
 delete mode 100644 src/transformers/models/git/convert_git_to_pytorch.py
 delete mode 100644 src/transformers/models/glm/convert_glm_weights_to_hf.py
 delete mode 100644 src/transformers/models/glpn/convert_glpn_to_pytorch.py
 delete mode 100644 src/transformers/models/got_ocr2/convert_got_ocr2_weights_to_hf.py
 delete mode 100755 src/transformers/models/gpt2/convert_gpt2_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/gpt_neo/convert_gpt_neo_mesh_tf_to_pytorch.py
 delete mode 100644 src/transformers/models/gpt_sw3/convert_megatron_to_pytorch.py
 delete mode 100644 src/transformers/models/grounding_dino/convert_grounding_dino_to_hf.py
 delete mode 100644 src/transformers/models/groupvit/convert_groupvit_nvlab_to_hf.py
 delete mode 100644 src/transformers/models/hiera/convert_hiera_to_hf.py
 delete mode 100644 src/transformers/models/hubert/convert_distilhubert_original_s3prl_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/hubert/convert_hubert_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/hubert/convert_hubert_original_s3prl_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/idefics2/convert_idefics2_weights_to_hf.py
 delete mode 100644 src/transformers/models/idefics3/convert_idefics3_weights_to_hf.py
 delete mode 100644 src/transformers/models/ijepa/convert_ijepa_to_hf.py
 delete mode 100644 src/transformers/models/imagegpt/convert_imagegpt_original_tf2_to_pytorch.py
 delete mode 100644 src/transformers/models/instructblip/convert_instructblip_original_to_pytorch.py
 delete mode 100644 src/transformers/models/instructblipvideo/convert_instructblipvideo_original_to_pytorch.py
 delete mode 100644 src/transformers/models/kosmos2/convert_kosmos2_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/levit/convert_levit_timm_to_pytorch.py
 delete mode 100644 src/transformers/models/llama/convert_llama_weights_to_hf.py
 delete mode 100644 src/transformers/models/llama4/convert_llama4_weights_to_hf.py
 delete mode 100644 src/transformers/models/llava/convert_llava_weights_to_hf.py
 delete mode 100644 src/transformers/models/llava_next/convert_llava_next_weights_to_hf.py
 delete mode 100644 src/transformers/models/llava_next_video/convert_llava_next_video_weights_to_hf.py
 delete mode 100644 src/transformers/models/llava_onevision/convert_llava_onevision_weights_to_hf.py
 delete mode 100644 src/transformers/models/longformer/convert_longformer_original_pytorch_lightning_to_pytorch.py
 delete mode 100644 src/transformers/models/longt5/convert_longt5x_checkpoint_to_flax.py
 delete mode 100644 src/transformers/models/luke/convert_luke_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100755 src/transformers/models/lxmert/convert_lxmert_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/m2m_100/convert_m2m100_original_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/mamba/convert_mamba_ssm_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/mamba2/convert_mamba2_ssm_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/marian/convert_marian_tatoeba_to_pytorch.py
 delete mode 100644 src/transformers/models/marian/convert_marian_to_pytorch.py
 delete mode 100644 src/transformers/models/mask2former/convert_mask2former_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/maskformer/convert_maskformer_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/maskformer/convert_maskformer_resnet_to_pytorch.py
 delete mode 100644 src/transformers/models/maskformer/convert_maskformer_swin_to_pytorch.py
 delete mode 100644 src/transformers/models/mbart/convert_mbart_original_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py
 delete mode 100644 src/transformers/models/megatron_gpt2/convert_megatron_gpt2_checkpoint.py
 delete mode 100644 src/transformers/models/mimi/convert_mimi_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/mistral/convert_mistral_weights_to_hf.py
 delete mode 100644 src/transformers/models/mistral3/convert_mistral3_weights_to_hf.py
 delete mode 100644 src/transformers/models/mixtral/convert_mixtral_weights_to_hf.py
 delete mode 100644 src/transformers/models/mllama/convert_mllama_weights_to_hf.py
 delete mode 100644 src/transformers/models/mluke/convert_mluke_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/mobilebert/convert_mobilebert_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/mobilenet_v1/convert_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/mobilenet_v2/convert_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/mobilevit/convert_mlcvnets_to_pytorch.py
 delete mode 100644 src/transformers/models/mobilevitv2/convert_mlcvnets_to_pytorch.py
 delete mode 100644 src/transformers/models/moonshine/convert_usefulsensors_to_hf.py
 delete mode 100644 src/transformers/models/moshi/convert_moshi_transformers.py
 delete mode 100644 src/transformers/models/mra/convert_mra_pytorch_to_pytorch.py
 delete mode 100644 src/transformers/models/musicgen/convert_musicgen_transformers.py
 delete mode 100644 src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py
 delete mode 100644 src/transformers/models/myt5/convert_myt5_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/nemotron/convert_nemotron_nemo_to_hf.py
 delete mode 100644 src/transformers/models/nllb_moe/convert_nllb_moe_sharded_original_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/nougat/convert_nougat_to_hf.py
 delete mode 100644 src/transformers/models/nystromformer/convert_nystromformer_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/olmo/convert_olmo_weights_to_hf.py
 delete mode 100644 src/transformers/models/olmo2/convert_olmo2_weights_to_hf.py
 delete mode 100644 src/transformers/models/olmoe/convert_olmoe_weights_to_hf.py
 delete mode 100644 src/transformers/models/omdet_turbo/convert_omdet_turbo_to_hf.py
 delete mode 100644 src/transformers/models/oneformer/convert_to_hf_oneformer.py
 delete mode 100755 src/transformers/models/openai/convert_openai_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/opt/convert_opt_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/owlv2/convert_owlv2_to_hf.py
 delete mode 100644 src/transformers/models/owlvit/convert_owlvit_original_flax_to_hf.py
 delete mode 100644 src/transformers/models/paligemma/convert_paligemma2_weights_to_hf.py
 delete mode 100644 src/transformers/models/paligemma/convert_paligemma_weights_to_hf.py
 delete mode 100644 src/transformers/models/pegasus/convert_pegasus_tf_to_pytorch.py
 delete mode 100644 src/transformers/models/perceiver/convert_perceiver_haiku_to_pytorch.py
 delete mode 100644 src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py
 delete mode 100644 src/transformers/models/phi/convert_phi_weights_to_hf.py
 delete mode 100644 src/transformers/models/phi4_multimodal/convert_phi4_multimodal_weights_to_hf.py
 delete mode 100644 src/transformers/models/pix2struct/convert_pix2struct_original_pytorch_to_hf.py
 delete mode 100644 src/transformers/models/pixtral/convert_pixtral_weights_to_hf.py
 delete mode 100644 src/transformers/models/plbart/convert_plbart_original_checkpoint_to_torch.py
 delete mode 100644 src/transformers/models/poolformer/convert_poolformer_original_to_pytorch.py
 delete mode 100644 src/transformers/models/pop2piano/convert_pop2piano_weights_to_hf.py
 delete mode 100644 src/transformers/models/prompt_depth_anything/convert_prompt_depth_anything_to_hf.py
 delete mode 100644 src/transformers/models/prophetnet/convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/pvt/convert_pvt_to_pytorch.py
 delete mode 100644 src/transformers/models/pvt_v2/convert_pvt_v2_to_pytorch.py
 delete mode 100644 src/transformers/models/recurrent_gemma/convert_recurrent_gemma_to_hf.py
 delete mode 100755 src/transformers/models/reformer/convert_reformer_trax_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/regnet/convert_regnet_seer_10b_to_pytorch.py
 delete mode 100644 src/transformers/models/regnet/convert_regnet_to_pytorch.py
 delete mode 100755 src/transformers/models/rembert/convert_rembert_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/resnet/convert_resnet_to_pytorch.py
 delete mode 100644 src/transformers/models/roberta/convert_roberta_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/roberta_prelayernorm/convert_roberta_prelayernorm_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100755 src/transformers/models/roformer/convert_roformer_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/rt_detr/convert_rt_detr_original_pytorch_checkpoint_to_hf.py
 delete mode 100644 src/transformers/models/rt_detr_v2/convert_rt_detr_v2_weights_to_hf.py
 delete mode 100644 src/transformers/models/rwkv/convert_rwkv_checkpoint_to_hf.py
 delete mode 100644 src/transformers/models/sam/convert_sam_to_hf.py
 delete mode 100644 src/transformers/models/seamless_m4t/convert_fairseq2_to_hf.py
 delete mode 100644 src/transformers/models/seamless_m4t_v2/convert_fairseq2_to_hf.py
 delete mode 100644 src/transformers/models/segformer/convert_segformer_original_to_pytorch.py
 delete mode 100644 src/transformers/models/seggpt/convert_seggpt_to_hf.py
 delete mode 100644 src/transformers/models/sew/convert_sew_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/sew_d/convert_sew_d_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/shieldgemma2/convert_shieldgemma2_weights_orbax_to_hf.py
 delete mode 100644 src/transformers/models/siglip/convert_siglip_to_hf.py
 delete mode 100644 src/transformers/models/siglip2/convert_siglip2_to_hf.py
 delete mode 100644 src/transformers/models/speech_encoder_decoder/convert_mbart_wav2vec2_seq2seq_original_to_pytorch.py
 delete mode 100644 src/transformers/models/speech_encoder_decoder/convert_speech_to_text_wav2vec2_seq2seq_original_to_pytorch.py
 delete mode 100644 src/transformers/models/speech_to_text/convert_s2t_fairseq_to_tfms.py
 delete mode 100644 src/transformers/models/speecht5/convert_hifigan.py
 delete mode 100644 src/transformers/models/speecht5/convert_speecht5_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/superglue/convert_superglue_to_hf.py
 delete mode 100644 src/transformers/models/superpoint/convert_superpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/swiftformer/convert_swiftformer_original_to_hf.py
 delete mode 100644 src/transformers/models/swin/convert_swin_simmim_to_pytorch.py
 delete mode 100644 src/transformers/models/swin/convert_swin_timm_to_pytorch.py
 delete mode 100644 src/transformers/models/swin2sr/convert_swin2sr_original_to_pytorch.py
 delete mode 100644 src/transformers/models/swinv2/convert_swinv2_timm_to_pytorch.py
 delete mode 100644 src/transformers/models/switch_transformers/convert_big_switch.py
 delete mode 100644 src/transformers/models/switch_transformers/convert_switch_transformers_original_flax_checkpoint_to_pytorch.py
 delete mode 100755 src/transformers/models/t5/convert_t5_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/t5/convert_t5x_checkpoint_to_flax.py
 delete mode 100755 src/transformers/models/t5/convert_t5x_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/table_transformer/convert_table_transformer_to_hf.py
 delete mode 100644 src/transformers/models/table_transformer/convert_table_transformer_to_hf_no_timm.py
 delete mode 100644 src/transformers/models/tapas/convert_tapas_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/textnet/convert_textnet_to_hf.py
 delete mode 100644 src/transformers/models/timesformer/convert_timesformer_to_pytorch.py
 delete mode 100644 src/transformers/models/trocr/convert_trocr_unilm_to_pytorch.py
 delete mode 100644 src/transformers/models/udop/convert_udop_to_hf.py
 delete mode 100644 src/transformers/models/umt5/convert_umt5_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/unispeech/convert_unispeech_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/unispeech_sat/convert_unispeech_original_s3prl_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/unispeech_sat/convert_unispeech_sat_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/univnet/convert_univnet.py
 delete mode 100644 src/transformers/models/upernet/convert_convnext_upernet_to_pytorch.py
 delete mode 100644 src/transformers/models/upernet/convert_swin_upernet_to_pytorch.py
 delete mode 100644 src/transformers/models/video_llava/convert_video_llava_weights_to_hf.py
 delete mode 100644 src/transformers/models/videomae/convert_videomae_to_pytorch.py
 delete mode 100644 src/transformers/models/vilt/convert_vilt_original_to_pytorch.py
 delete mode 100644 src/transformers/models/vipllava/convert_vipllava_weights_to_hf.py
 delete mode 100644 src/transformers/models/visual_bert/convert_visual_bert_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/vit/convert_dino_to_pytorch.py
 delete mode 100644 src/transformers/models/vit/convert_vit_timm_to_pytorch.py
 delete mode 100644 src/transformers/models/vit_mae/convert_vit_mae_to_pytorch.py
 delete mode 100644 src/transformers/models/vit_msn/convert_msn_to_pytorch.py
 delete mode 100644 src/transformers/models/vitmatte/convert_vitmatte_to_hf.py
 delete mode 100644 src/transformers/models/vitpose/convert_vitpose_to_hf.py
 delete mode 100644 src/transformers/models/vits/convert_original_checkpoint.py
 delete mode 100644 src/transformers/models/vivit/convert_vivit_flax_to_pytorch.py
 delete mode 100644 src/transformers/models/wav2vec2/convert_wav2vec2_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/wav2vec2/convert_wav2vec2_original_s3prl_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/wav2vec2_bert/convert_wav2vec2_seamless_checkpoint.py
 delete mode 100644 src/transformers/models/wav2vec2_conformer/convert_wav2vec2_conformer_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/wavlm/convert_wavlm_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/wavlm/convert_wavlm_original_s3prl_checkpoint_to_pytorch.py
 delete mode 100755 src/transformers/models/whisper/convert_openai_to_hf.py
 delete mode 100644 src/transformers/models/x_clip/convert_x_clip_original_pytorch_to_hf.py
 delete mode 100644 src/transformers/models/xglm/convert_xglm_original_ckpt_to_trfms.py
 delete mode 100755 src/transformers/models/xlm/convert_xlm_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/xlm_roberta_xl/convert_xlm_roberta_xl_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100755 src/transformers/models/xlnet/convert_xlnet_original_tf_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/xmod/convert_xmod_original_pytorch_checkpoint_to_pytorch.py
 delete mode 100644 src/transformers/models/yolos/convert_yolos_to_pytorch.py
 delete mode 100644 src/transformers/models/yoso/convert_yoso_pytorch_to_pytorch.py
 delete mode 100644 src/transformers/models/zoedepth/convert_zoedepth_to_hf.py

diff --git a/examples/flax/question-answering/run_qa.py b/examples/flax/question-answering/run_qa.py
index c42911f6638d..63d9c918cc44 100644
--- a/examples/flax/question-answering/run_qa.py
+++ b/examples/flax/question-answering/run_qa.py
@@ -61,7 +61,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 Array = Any
 Dataset = datasets.arrow_dataset.Dataset
diff --git a/examples/flax/speech-recognition/run_flax_speech_recognition_seq2seq.py b/examples/flax/speech-recognition/run_flax_speech_recognition_seq2seq.py
index 6028f7408bad..38258ecec303 100644
--- a/examples/flax/speech-recognition/run_flax_speech_recognition_seq2seq.py
+++ b/examples/flax/speech-recognition/run_flax_speech_recognition_seq2seq.py
@@ -60,7 +60,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risk.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.14.0", "To fix: pip install -r examples/flax/speech-recognition/requirements.txt")
 
diff --git a/examples/flax/text-classification/run_flax_glue.py b/examples/flax/text-classification/run_flax_glue.py
index 522a601551da..a3d952a1a2bb 100755
--- a/examples/flax/text-classification/run_flax_glue.py
+++ b/examples/flax/text-classification/run_flax_glue.py
@@ -56,7 +56,7 @@
 
 logger = logging.getLogger(__name__)
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 Array = Any
 Dataset = datasets.arrow_dataset.Dataset
diff --git a/examples/flax/token-classification/run_flax_ner.py b/examples/flax/token-classification/run_flax_ner.py
index 5c8fa77cbb93..4b232115c0d4 100644
--- a/examples/flax/token-classification/run_flax_ner.py
+++ b/examples/flax/token-classification/run_flax_ner.py
@@ -57,7 +57,7 @@
 
 logger = logging.getLogger(__name__)
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/token-classification/requirements.txt")
 
diff --git a/examples/pytorch/audio-classification/run_audio_classification.py b/examples/pytorch/audio-classification/run_audio_classification.py
index 5d1e0390f61d..89915308a1e0 100644
--- a/examples/pytorch/audio-classification/run_audio_classification.py
+++ b/examples/pytorch/audio-classification/run_audio_classification.py
@@ -45,7 +45,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.14.0", "To fix: pip install -r examples/pytorch/audio-classification/requirements.txt")
 
diff --git a/examples/pytorch/contrastive-image-text/run_clip.py b/examples/pytorch/contrastive-image-text/run_clip.py
index 232c58c417a1..bdd803e646b4 100644
--- a/examples/pytorch/contrastive-image-text/run_clip.py
+++ b/examples/pytorch/contrastive-image-text/run_clip.py
@@ -54,7 +54,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/contrastive-image-text/requirements.txt")
 
diff --git a/examples/pytorch/image-classification/run_image_classification.py b/examples/pytorch/image-classification/run_image_classification.py
index c941465babe0..c0d2001b9bea 100755
--- a/examples/pytorch/image-classification/run_image_classification.py
+++ b/examples/pytorch/image-classification/run_image_classification.py
@@ -57,7 +57,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.14.0", "To fix: pip install -r examples/pytorch/image-classification/requirements.txt")
 
diff --git a/examples/pytorch/image-classification/run_image_classification_no_trainer.py b/examples/pytorch/image-classification/run_image_classification_no_trainer.py
index 564588a52b8b..d837440405ba 100644
--- a/examples/pytorch/image-classification/run_image_classification_no_trainer.py
+++ b/examples/pytorch/image-classification/run_image_classification_no_trainer.py
@@ -49,7 +49,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 
diff --git a/examples/pytorch/image-pretraining/run_mae.py b/examples/pytorch/image-pretraining/run_mae.py
index fdffbda0beea..208c43c2b4e6 100644
--- a/examples/pytorch/image-pretraining/run_mae.py
+++ b/examples/pytorch/image-pretraining/run_mae.py
@@ -43,7 +43,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/image-pretraining/requirements.txt")
 
diff --git a/examples/pytorch/image-pretraining/run_mim.py b/examples/pytorch/image-pretraining/run_mim.py
index 3f497252d3a6..c0ae1cec1c1d 100644
--- a/examples/pytorch/image-pretraining/run_mim.py
+++ b/examples/pytorch/image-pretraining/run_mim.py
@@ -48,7 +48,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/image-pretraining/requirements.txt")
 
diff --git a/examples/pytorch/image-pretraining/run_mim_no_trainer.py b/examples/pytorch/image-pretraining/run_mim_no_trainer.py
index 5935ce438478..c60787764c24 100644
--- a/examples/pytorch/image-pretraining/run_mim_no_trainer.py
+++ b/examples/pytorch/image-pretraining/run_mim_no_trainer.py
@@ -53,7 +53,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/image-pretraining/requirements.txt")
 
diff --git a/examples/pytorch/instance-segmentation/run_instance_segmentation.py b/examples/pytorch/instance-segmentation/run_instance_segmentation.py
index 6229c6f36583..6cb6859fd976 100644
--- a/examples/pytorch/instance-segmentation/run_instance_segmentation.py
+++ b/examples/pytorch/instance-segmentation/run_instance_segmentation.py
@@ -46,7 +46,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.0.0", "To fix: pip install -r examples/pytorch/instance-segmentation/requirements.txt")
 
diff --git a/examples/pytorch/instance-segmentation/run_instance_segmentation_no_trainer.py b/examples/pytorch/instance-segmentation/run_instance_segmentation_no_trainer.py
index 7e23fc520202..60c791f4aa9b 100644
--- a/examples/pytorch/instance-segmentation/run_instance_segmentation_no_trainer.py
+++ b/examples/pytorch/instance-segmentation/run_instance_segmentation_no_trainer.py
@@ -52,7 +52,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.0.0", "To fix: pip install -r examples/pytorch/instance-segmentation/requirements.txt")
 
diff --git a/examples/pytorch/language-modeling/run_clm.py b/examples/pytorch/language-modeling/run_clm.py
index 308e3a99626c..5b0a011db6c7 100755
--- a/examples/pytorch/language-modeling/run_clm.py
+++ b/examples/pytorch/language-modeling/run_clm.py
@@ -55,7 +55,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.14.0", "To fix: pip install -r examples/pytorch/language-modeling/requirements.txt")
 
diff --git a/examples/pytorch/language-modeling/run_clm_no_trainer.py b/examples/pytorch/language-modeling/run_clm_no_trainer.py
index ed8a03d87803..fa05c57d9c6a 100755
--- a/examples/pytorch/language-modeling/run_clm_no_trainer.py
+++ b/examples/pytorch/language-modeling/run_clm_no_trainer.py
@@ -57,7 +57,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 
diff --git a/examples/pytorch/language-modeling/run_fim.py b/examples/pytorch/language-modeling/run_fim.py
index a201479ae8f9..3b1e7931f0ef 100644
--- a/examples/pytorch/language-modeling/run_fim.py
+++ b/examples/pytorch/language-modeling/run_fim.py
@@ -58,7 +58,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.14.0", "To fix: pip install -r examples/pytorch/language-modeling/requirements.txt")
 
diff --git a/examples/pytorch/language-modeling/run_fim_no_trainer.py b/examples/pytorch/language-modeling/run_fim_no_trainer.py
index 44d083bc6313..2e1e5dd58e21 100644
--- a/examples/pytorch/language-modeling/run_fim_no_trainer.py
+++ b/examples/pytorch/language-modeling/run_fim_no_trainer.py
@@ -60,7 +60,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 
diff --git a/examples/pytorch/language-modeling/run_mlm.py b/examples/pytorch/language-modeling/run_mlm.py
index c8cf999b87d4..4bc2a41cf712 100755
--- a/examples/pytorch/language-modeling/run_mlm.py
+++ b/examples/pytorch/language-modeling/run_mlm.py
@@ -54,7 +54,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.14.0", "To fix: pip install -r examples/pytorch/language-modeling/requirements.txt")
 
diff --git a/examples/pytorch/language-modeling/run_mlm_no_trainer.py b/examples/pytorch/language-modeling/run_mlm_no_trainer.py
index faa52e21c50c..2ea58d91cfc3 100755
--- a/examples/pytorch/language-modeling/run_mlm_no_trainer.py
+++ b/examples/pytorch/language-modeling/run_mlm_no_trainer.py
@@ -57,7 +57,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 require_version("datasets>=2.14.0", "To fix: pip install -r examples/pytorch/language-modeling/requirements.txt")
diff --git a/examples/pytorch/language-modeling/run_plm.py b/examples/pytorch/language-modeling/run_plm.py
index ea295283e7d2..9f54bb6f68d6 100755
--- a/examples/pytorch/language-modeling/run_plm.py
+++ b/examples/pytorch/language-modeling/run_plm.py
@@ -47,7 +47,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.14.0", "To fix: pip install -r examples/pytorch/language-modeling/requirements.txt")
 
diff --git a/examples/pytorch/multiple-choice/run_swag.py b/examples/pytorch/multiple-choice/run_swag.py
index 78943f974a07..f8e85d22256a 100755
--- a/examples/pytorch/multiple-choice/run_swag.py
+++ b/examples/pytorch/multiple-choice/run_swag.py
@@ -46,7 +46,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = logging.getLogger(__name__)
 
diff --git a/examples/pytorch/multiple-choice/run_swag_no_trainer.py b/examples/pytorch/multiple-choice/run_swag_no_trainer.py
index d3f223cd5c67..182c64480c1f 100755
--- a/examples/pytorch/multiple-choice/run_swag_no_trainer.py
+++ b/examples/pytorch/multiple-choice/run_swag_no_trainer.py
@@ -54,7 +54,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 # You should update this to your particular problem to have better documentation of `model_type`
diff --git a/examples/pytorch/object-detection/run_object_detection.py b/examples/pytorch/object-detection/run_object_detection.py
index 27433db411ca..8f28132043e6 100644
--- a/examples/pytorch/object-detection/run_object_detection.py
+++ b/examples/pytorch/object-detection/run_object_detection.py
@@ -48,7 +48,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.0.0", "To fix: pip install -r examples/pytorch/object-detection/requirements.txt")
 
diff --git a/examples/pytorch/object-detection/run_object_detection_no_trainer.py b/examples/pytorch/object-detection/run_object_detection_no_trainer.py
index bc1ab9256709..b1b8b504d8bc 100644
--- a/examples/pytorch/object-detection/run_object_detection_no_trainer.py
+++ b/examples/pytorch/object-detection/run_object_detection_no_trainer.py
@@ -51,7 +51,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logging.basicConfig(level=logging.INFO)
 logger = get_logger(__name__)
diff --git a/examples/pytorch/question-answering/run_qa.py b/examples/pytorch/question-answering/run_qa.py
index 8e4d39836fc9..11e0cd08ca09 100755
--- a/examples/pytorch/question-answering/run_qa.py
+++ b/examples/pytorch/question-answering/run_qa.py
@@ -50,7 +50,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/question-answering/requirements.txt")
 
diff --git a/examples/pytorch/question-answering/run_qa_beam_search.py b/examples/pytorch/question-answering/run_qa_beam_search.py
index f58b6918328f..d7b6d9661949 100755
--- a/examples/pytorch/question-answering/run_qa_beam_search.py
+++ b/examples/pytorch/question-answering/run_qa_beam_search.py
@@ -48,7 +48,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/question-answering/requirements.txt")
 
diff --git a/examples/pytorch/question-answering/run_qa_beam_search_no_trainer.py b/examples/pytorch/question-answering/run_qa_beam_search_no_trainer.py
index e7dbee34dfec..2288939d02a5 100644
--- a/examples/pytorch/question-answering/run_qa_beam_search_no_trainer.py
+++ b/examples/pytorch/question-answering/run_qa_beam_search_no_trainer.py
@@ -55,7 +55,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/question-answering/requirements.txt")
 
diff --git a/examples/pytorch/question-answering/run_qa_no_trainer.py b/examples/pytorch/question-answering/run_qa_no_trainer.py
index 12193590d0b3..131774497036 100755
--- a/examples/pytorch/question-answering/run_qa_no_trainer.py
+++ b/examples/pytorch/question-answering/run_qa_no_trainer.py
@@ -57,7 +57,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/question-answering/requirements.txt")
 
diff --git a/examples/pytorch/question-answering/run_seq2seq_qa.py b/examples/pytorch/question-answering/run_seq2seq_qa.py
index 56c0c6722efa..c67706da187b 100644
--- a/examples/pytorch/question-answering/run_seq2seq_qa.py
+++ b/examples/pytorch/question-answering/run_seq2seq_qa.py
@@ -46,7 +46,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/question-answering/requirements.txt")
 
diff --git a/examples/pytorch/semantic-segmentation/run_semantic_segmentation.py b/examples/pytorch/semantic-segmentation/run_semantic_segmentation.py
index 1aed64fa7559..0ef3eb241735 100644
--- a/examples/pytorch/semantic-segmentation/run_semantic_segmentation.py
+++ b/examples/pytorch/semantic-segmentation/run_semantic_segmentation.py
@@ -51,7 +51,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=2.0.0", "To fix: pip install -r examples/pytorch/semantic-segmentation/requirements.txt")
 
diff --git a/examples/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py b/examples/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py
index e5b3af08dc63..ef0514733a83 100644
--- a/examples/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py
+++ b/examples/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py
@@ -50,7 +50,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 
diff --git a/examples/pytorch/speech-recognition/run_speech_recognition_ctc.py b/examples/pytorch/speech-recognition/run_speech_recognition_ctc.py
index 7d943203b450..b64c25446d43 100755
--- a/examples/pytorch/speech-recognition/run_speech_recognition_ctc.py
+++ b/examples/pytorch/speech-recognition/run_speech_recognition_ctc.py
@@ -50,7 +50,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.18.0", "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt")
 
diff --git a/examples/pytorch/speech-recognition/run_speech_recognition_ctc_adapter.py b/examples/pytorch/speech-recognition/run_speech_recognition_ctc_adapter.py
index c2091c2af91f..6d3bbe3781d3 100755
--- a/examples/pytorch/speech-recognition/run_speech_recognition_ctc_adapter.py
+++ b/examples/pytorch/speech-recognition/run_speech_recognition_ctc_adapter.py
@@ -53,7 +53,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.18.0", "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt")
 
diff --git a/examples/pytorch/speech-recognition/run_speech_recognition_seq2seq.py b/examples/pytorch/speech-recognition/run_speech_recognition_seq2seq.py
index ff19c0ffa358..60cb0c24d0bb 100755
--- a/examples/pytorch/speech-recognition/run_speech_recognition_seq2seq.py
+++ b/examples/pytorch/speech-recognition/run_speech_recognition_seq2seq.py
@@ -48,7 +48,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.18.0", "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt")
 
diff --git a/examples/pytorch/summarization/run_summarization.py b/examples/pytorch/summarization/run_summarization.py
index 49ad6687840e..b39ab45e997f 100755
--- a/examples/pytorch/summarization/run_summarization.py
+++ b/examples/pytorch/summarization/run_summarization.py
@@ -52,7 +52,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/summarization/requirements.txt")
 
diff --git a/examples/pytorch/summarization/run_summarization_no_trainer.py b/examples/pytorch/summarization/run_summarization_no_trainer.py
index b9dd85e217b0..3d58ffc9ab1b 100644
--- a/examples/pytorch/summarization/run_summarization_no_trainer.py
+++ b/examples/pytorch/summarization/run_summarization_no_trainer.py
@@ -56,7 +56,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/summarization/requirements.txt")
diff --git a/examples/pytorch/text-classification/run_classification.py b/examples/pytorch/text-classification/run_classification.py
index 28bd9a7025d2..6cc1f0770a89 100755
--- a/examples/pytorch/text-classification/run_classification.py
+++ b/examples/pytorch/text-classification/run_classification.py
@@ -47,7 +47,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt")
 
diff --git a/examples/pytorch/text-classification/run_glue.py b/examples/pytorch/text-classification/run_glue.py
index db3101abdaf6..97c7df8f34e7 100755
--- a/examples/pytorch/text-classification/run_glue.py
+++ b/examples/pytorch/text-classification/run_glue.py
@@ -48,7 +48,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt")
 
diff --git a/examples/pytorch/text-classification/run_glue_no_trainer.py b/examples/pytorch/text-classification/run_glue_no_trainer.py
index aa714fa3ce28..206e8dd1f56f 100644
--- a/examples/pytorch/text-classification/run_glue_no_trainer.py
+++ b/examples/pytorch/text-classification/run_glue_no_trainer.py
@@ -49,7 +49,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 
diff --git a/examples/pytorch/text-classification/run_xnli.py b/examples/pytorch/text-classification/run_xnli.py
index d85a7646ef3f..e6e801d7fd73 100755
--- a/examples/pytorch/text-classification/run_xnli.py
+++ b/examples/pytorch/text-classification/run_xnli.py
@@ -48,7 +48,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt")
 
diff --git a/examples/pytorch/token-classification/run_ner.py b/examples/pytorch/token-classification/run_ner.py
index 85eb285a780b..b9d7008d27ae 100755
--- a/examples/pytorch/token-classification/run_ner.py
+++ b/examples/pytorch/token-classification/run_ner.py
@@ -49,7 +49,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/token-classification/requirements.txt")
 
diff --git a/examples/pytorch/token-classification/run_ner_no_trainer.py b/examples/pytorch/token-classification/run_ner_no_trainer.py
index 87f0a79466c5..54708fd08a6e 100755
--- a/examples/pytorch/token-classification/run_ner_no_trainer.py
+++ b/examples/pytorch/token-classification/run_ner_no_trainer.py
@@ -56,7 +56,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/token-classification/requirements.txt")
diff --git a/examples/pytorch/translation/run_translation.py b/examples/pytorch/translation/run_translation.py
index 656fb5e0f2b9..6e14b6402cd5 100755
--- a/examples/pytorch/translation/run_translation.py
+++ b/examples/pytorch/translation/run_translation.py
@@ -52,7 +52,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/translation/requirements.txt")
 
diff --git a/examples/pytorch/translation/run_translation_no_trainer.py b/examples/pytorch/translation/run_translation_no_trainer.py
index 973548c2ce0c..765e9af924e5 100644
--- a/examples/pytorch/translation/run_translation_no_trainer.py
+++ b/examples/pytorch/translation/run_translation_no_trainer.py
@@ -57,7 +57,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = get_logger(__name__)
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/translation/requirements.txt")
diff --git a/examples/tensorflow/contrastive-image-text/run_clip.py b/examples/tensorflow/contrastive-image-text/run_clip.py
index 1f87d42fac4a..8071cb3189f7 100644
--- a/examples/tensorflow/contrastive-image-text/run_clip.py
+++ b/examples/tensorflow/contrastive-image-text/run_clip.py
@@ -51,7 +51,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version(
     "datasets>=1.8.0", "To fix: pip install -r examples/tensorflow/contrastive-image-text/requirements.txt"
diff --git a/examples/tensorflow/image-classification/run_image_classification.py b/examples/tensorflow/image-classification/run_image_classification.py
index d5468e4d2c0c..acda9cd38789 100644
--- a/examples/tensorflow/image-classification/run_image_classification.py
+++ b/examples/tensorflow/image-classification/run_image_classification.py
@@ -55,7 +55,7 @@
 logger = logging.getLogger(__name__)
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/image-classification/requirements.txt")
 
diff --git a/examples/tensorflow/multiple-choice/run_swag.py b/examples/tensorflow/multiple-choice/run_swag.py
index 40a59bb36096..224863d24296 100644
--- a/examples/tensorflow/multiple-choice/run_swag.py
+++ b/examples/tensorflow/multiple-choice/run_swag.py
@@ -50,7 +50,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = logging.getLogger(__name__)
 
diff --git a/examples/tensorflow/question-answering/run_qa.py b/examples/tensorflow/question-answering/run_qa.py
index f2cdc75a15e9..087d9095534d 100755
--- a/examples/tensorflow/question-answering/run_qa.py
+++ b/examples/tensorflow/question-answering/run_qa.py
@@ -62,7 +62,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 logger = logging.getLogger(__name__)
 
diff --git a/examples/tensorflow/summarization/run_summarization.py b/examples/tensorflow/summarization/run_summarization.py
index b3fcf1e70211..dc9ff9fe3b07 100644
--- a/examples/tensorflow/summarization/run_summarization.py
+++ b/examples/tensorflow/summarization/run_summarization.py
@@ -53,7 +53,7 @@
 
 # region Checking dependencies
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/summarization/requirements.txt")
 
diff --git a/examples/tensorflow/text-classification/run_glue.py b/examples/tensorflow/text-classification/run_glue.py
index 747b3a7b8c42..031ebad19eb2 100644
--- a/examples/tensorflow/text-classification/run_glue.py
+++ b/examples/tensorflow/text-classification/run_glue.py
@@ -47,7 +47,7 @@
 
 
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 task_to_keys = {
     "cola": ("sentence", None),
diff --git a/examples/tensorflow/translation/run_translation.py b/examples/tensorflow/translation/run_translation.py
index 3b9a9a9c1cd5..2a5ec42bf13f 100644
--- a/examples/tensorflow/translation/run_translation.py
+++ b/examples/tensorflow/translation/run_translation.py
@@ -56,7 +56,7 @@
 
 # region Dependencies and constants
 # Will error if the minimal version of Transformers is not installed. Remove at your own risks.
-check_min_version("4.51.0.dev0")
+check_min_version("4.51.0")
 
 require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/summarization/requirements.txt")
 
diff --git a/setup.py b/setup.py
index 04615a9aa3e6..0094a3b6ff5f 100644
--- a/setup.py
+++ b/setup.py
@@ -453,7 +453,7 @@ def run(self):
 
 setup(
     name="transformers",
-    version="4.51.0.dev0",  # expected format is one of x.y.z.dev0, or x.y.z.rc1 or x.y.z (no to dashes, yes to dots)
+    version="4.51.0",  # expected format is one of x.y.z.dev0, or x.y.z.rc1 or x.y.z (no to dashes, yes to dots)
     author="The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/transformers/graphs/contributors)",
     author_email="transformers@huggingface.co",
     description="State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow",
diff --git a/src/transformers/__init__.py b/src/transformers/__init__.py
index 3b525f7f1548..609bc08df3a0 100644
--- a/src/transformers/__init__.py
+++ b/src/transformers/__init__.py
@@ -18,7 +18,7 @@
 # to defer the actual importing for when the objects are requested. This way `import transformers` provides the names
 # in the namespace without actually importing anything (and especially none of the backends).
 
-__version__ = "4.51.0.dev0"
+__version__ = "4.51.0"
 
 from typing import TYPE_CHECKING
 
diff --git a/src/transformers/models/albert/convert_albert_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/albert/convert_albert_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index df2a22610187..000000000000
--- a/src/transformers/models/albert/convert_albert_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ALBERT checkpoint."""
-
-import argparse
-
-import torch
-
-from ...utils import logging
-from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, albert_config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = AlbertConfig.from_json_file(albert_config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = AlbertForPreTraining(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_albert(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--albert_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained ALBERT model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/align/convert_align_tf_to_hf.py b/src/transformers/models/align/convert_align_tf_to_hf.py
deleted file mode 100644
index 610db8482f91..000000000000
--- a/src/transformers/models/align/convert_align_tf_to_hf.py
+++ /dev/null
@@ -1,389 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ALIGN checkpoints from the original repository."""
-
-import argparse
-import os
-
-import align
-import numpy as np
-import requests
-import tensorflow as tf
-import torch
-from PIL import Image
-from tokenizer import Tokenizer
-
-from transformers import (
-    AlignConfig,
-    AlignModel,
-    AlignProcessor,
-    BertConfig,
-    BertTokenizer,
-    EfficientNetConfig,
-    EfficientNetImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def preprocess(image):
-    image = tf.image.resize(image, (346, 346))
-    image = tf.image.crop_to_bounding_box(image, (346 - 289) // 2, (346 - 289) // 2, 289, 289)
-    return image
-
-
-def get_align_config():
-    vision_config = EfficientNetConfig.from_pretrained("google/efficientnet-b7")
-    vision_config.image_size = 289
-    vision_config.hidden_dim = 640
-    vision_config.id2label = {"0": "LABEL_0", "1": "LABEL_1"}
-    vision_config.label2id = {"LABEL_0": 0, "LABEL_1": 1}
-    vision_config.depthwise_padding = []
-
-    text_config = BertConfig()
-    config = AlignConfig.from_text_vision_configs(
-        text_config=text_config, vision_config=vision_config, projection_dim=640
-    )
-    return config
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-def get_processor():
-    image_processor = EfficientNetImageProcessor(
-        do_center_crop=True,
-        rescale_factor=1 / 127.5,
-        rescale_offset=True,
-        do_normalize=False,
-        include_top=False,
-        resample=Image.BILINEAR,
-    )
-    tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
-    tokenizer.model_max_length = 64
-    processor = AlignProcessor(image_processor=image_processor, tokenizer=tokenizer)
-    return processor
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def rename_keys(original_param_names):
-    # EfficientNet image encoder
-    block_names = [v.split("_")[0].split("block")[1] for v in original_param_names if v.startswith("block")]
-    block_names = list(set(block_names))
-    block_names = sorted(block_names)
-    num_blocks = len(block_names)
-    block_name_mapping = {b: str(i) for b, i in zip(block_names, range(num_blocks))}
-
-    rename_keys = []
-    rename_keys.append(("stem_conv/kernel:0", "embeddings.convolution.weight"))
-    rename_keys.append(("stem_bn/gamma:0", "embeddings.batchnorm.weight"))
-    rename_keys.append(("stem_bn/beta:0", "embeddings.batchnorm.bias"))
-    rename_keys.append(("stem_bn/moving_mean:0", "embeddings.batchnorm.running_mean"))
-    rename_keys.append(("stem_bn/moving_variance:0", "embeddings.batchnorm.running_var"))
-
-    for b in block_names:
-        hf_b = block_name_mapping[b]
-        rename_keys.append((f"block{b}_expand_conv/kernel:0", f"encoder.blocks.{hf_b}.expansion.expand_conv.weight"))
-        rename_keys.append((f"block{b}_expand_bn/gamma:0", f"encoder.blocks.{hf_b}.expansion.expand_bn.weight"))
-        rename_keys.append((f"block{b}_expand_bn/beta:0", f"encoder.blocks.{hf_b}.expansion.expand_bn.bias"))
-        rename_keys.append(
-            (f"block{b}_expand_bn/moving_mean:0", f"encoder.blocks.{hf_b}.expansion.expand_bn.running_mean")
-        )
-        rename_keys.append(
-            (f"block{b}_expand_bn/moving_variance:0", f"encoder.blocks.{hf_b}.expansion.expand_bn.running_var")
-        )
-        rename_keys.append(
-            (f"block{b}_dwconv/depthwise_kernel:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight")
-        )
-        rename_keys.append((f"block{b}_bn/gamma:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight"))
-        rename_keys.append((f"block{b}_bn/beta:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias"))
-        rename_keys.append(
-            (f"block{b}_bn/moving_mean:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean")
-        )
-        rename_keys.append(
-            (f"block{b}_bn/moving_variance:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var")
-        )
-
-        rename_keys.append((f"block{b}_se_reduce/kernel:0", f"encoder.blocks.{hf_b}.squeeze_excite.reduce.weight"))
-        rename_keys.append((f"block{b}_se_reduce/bias:0", f"encoder.blocks.{hf_b}.squeeze_excite.reduce.bias"))
-        rename_keys.append((f"block{b}_se_expand/kernel:0", f"encoder.blocks.{hf_b}.squeeze_excite.expand.weight"))
-        rename_keys.append((f"block{b}_se_expand/bias:0", f"encoder.blocks.{hf_b}.squeeze_excite.expand.bias"))
-        rename_keys.append(
-            (f"block{b}_project_conv/kernel:0", f"encoder.blocks.{hf_b}.projection.project_conv.weight")
-        )
-        rename_keys.append((f"block{b}_project_bn/gamma:0", f"encoder.blocks.{hf_b}.projection.project_bn.weight"))
-        rename_keys.append((f"block{b}_project_bn/beta:0", f"encoder.blocks.{hf_b}.projection.project_bn.bias"))
-        rename_keys.append(
-            (f"block{b}_project_bn/moving_mean:0", f"encoder.blocks.{hf_b}.projection.project_bn.running_mean")
-        )
-        rename_keys.append(
-            (f"block{b}_project_bn/moving_variance:0", f"encoder.blocks.{hf_b}.projection.project_bn.running_var")
-        )
-
-    key_mapping = {}
-    for item in rename_keys:
-        if item[0] in original_param_names:
-            key_mapping[item[0]] = "vision_model." + item[1]
-
-    # BERT text encoder
-    rename_keys = []
-    old = "tf_bert_model/bert"
-    new = "text_model"
-    for i in range(12):
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/self/query/kernel:0",
-                f"{new}.encoder.layer.{i}.attention.self.query.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/self/query/bias:0",
-                f"{new}.encoder.layer.{i}.attention.self.query.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/self/key/kernel:0",
-                f"{new}.encoder.layer.{i}.attention.self.key.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/self/key/bias:0",
-                f"{new}.encoder.layer.{i}.attention.self.key.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/self/value/kernel:0",
-                f"{new}.encoder.layer.{i}.attention.self.value.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/self/value/bias:0",
-                f"{new}.encoder.layer.{i}.attention.self.value.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/output/dense/kernel:0",
-                f"{new}.encoder.layer.{i}.attention.output.dense.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/output/dense/bias:0",
-                f"{new}.encoder.layer.{i}.attention.output.dense.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/output/LayerNorm/gamma:0",
-                f"{new}.encoder.layer.{i}.attention.output.LayerNorm.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/attention/output/LayerNorm/beta:0",
-                f"{new}.encoder.layer.{i}.attention.output.LayerNorm.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/intermediate/dense/kernel:0",
-                f"{new}.encoder.layer.{i}.intermediate.dense.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"{old}/encoder/layer_._{i}/intermediate/dense/bias:0",
-                f"{new}.encoder.layer.{i}.intermediate.dense.bias",
-            )
-        )
-        rename_keys.append(
-            (f"{old}/encoder/layer_._{i}/output/dense/kernel:0", f"{new}.encoder.layer.{i}.output.dense.weight")
-        )
-        rename_keys.append(
-            (f"{old}/encoder/layer_._{i}/output/dense/bias:0", f"{new}.encoder.layer.{i}.output.dense.bias")
-        )
-        rename_keys.append(
-            (f"{old}/encoder/layer_._{i}/output/LayerNorm/gamma:0", f"{new}.encoder.layer.{i}.output.LayerNorm.weight")
-        )
-        rename_keys.append(
-            (f"{old}/encoder/layer_._{i}/output/LayerNorm/beta:0", f"{new}.encoder.layer.{i}.output.LayerNorm.bias")
-        )
-
-    rename_keys.append((f"{old}/embeddings/word_embeddings/weight:0", f"{new}.embeddings.word_embeddings.weight"))
-    rename_keys.append(
-        (f"{old}/embeddings/position_embeddings/embeddings:0", f"{new}.embeddings.position_embeddings.weight")
-    )
-    rename_keys.append(
-        (f"{old}/embeddings/token_type_embeddings/embeddings:0", f"{new}.embeddings.token_type_embeddings.weight")
-    )
-    rename_keys.append((f"{old}/embeddings/LayerNorm/gamma:0", f"{new}.embeddings.LayerNorm.weight"))
-    rename_keys.append((f"{old}/embeddings/LayerNorm/beta:0", f"{new}.embeddings.LayerNorm.bias"))
-
-    rename_keys.append((f"{old}/pooler/dense/kernel:0", f"{new}.pooler.dense.weight"))
-    rename_keys.append((f"{old}/pooler/dense/bias:0", f"{new}.pooler.dense.bias"))
-    rename_keys.append(("dense/kernel:0", "text_projection.weight"))
-    rename_keys.append(("dense/bias:0", "text_projection.bias"))
-    rename_keys.append(("dense/bias:0", "text_projection.bias"))
-    rename_keys.append(("temperature:0", "temperature"))
-
-    for item in rename_keys:
-        if item[0] in original_param_names:
-            key_mapping[item[0]] = item[1]
-    return key_mapping
-
-
-def replace_params(hf_params, tf_params, key_mapping):
-    list(hf_params.keys())
-
-    for key, value in tf_params.items():
-        if key not in key_mapping:
-            continue
-
-        hf_key = key_mapping[key]
-        if "_conv" in key and "kernel" in key:
-            new_hf_value = torch.from_numpy(value).permute(3, 2, 0, 1)
-        elif "embeddings" in key:
-            new_hf_value = torch.from_numpy(value)
-        elif "depthwise_kernel" in key:
-            new_hf_value = torch.from_numpy(value).permute(2, 3, 0, 1)
-        elif "kernel" in key:
-            new_hf_value = torch.from_numpy(np.transpose(value))
-        elif "temperature" in key:
-            new_hf_value = value
-        elif "bn/gamma" or "bn/beta" in key:
-            new_hf_value = torch.from_numpy(np.transpose(value)).squeeze()
-        else:
-            new_hf_value = torch.from_numpy(value)
-
-        # Replace HF parameters with original TF model parameters
-        hf_params[hf_key].copy_(new_hf_value)
-
-
-@torch.no_grad()
-def convert_align_checkpoint(checkpoint_path, pytorch_dump_folder_path, save_model, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our ALIGN structure.
-    """
-    # Load original model
-    seq_length = 64
-    tok = Tokenizer(seq_length)
-    original_model = align.Align("efficientnet-b7", "bert-base", 640, seq_length, tok.get_vocab_size())
-    original_model.compile()
-    original_model.load_weights(checkpoint_path)
-
-    tf_params = original_model.trainable_variables
-    tf_non_train_params = original_model.non_trainable_variables
-    tf_params = {param.name: param.numpy() for param in tf_params}
-    for param in tf_non_train_params:
-        tf_params[param.name] = param.numpy()
-    tf_param_names = list(tf_params.keys())
-
-    # Load HuggingFace model
-    config = get_align_config()
-    hf_model = AlignModel(config).eval()
-    hf_params = hf_model.state_dict()
-
-    # Create src-to-dst parameter name mapping dictionary
-    print("Converting parameters...")
-    key_mapping = rename_keys(tf_param_names)
-    replace_params(hf_params, tf_params, key_mapping)
-
-    # Initialize processor
-    processor = get_processor()
-    inputs = processor(
-        images=prepare_img(), text="A picture of a cat", padding="max_length", max_length=64, return_tensors="pt"
-    )
-
-    # HF model inference
-    hf_model.eval()
-    with torch.no_grad():
-        outputs = hf_model(**inputs)
-
-    hf_image_features = outputs.image_embeds.detach().numpy()
-    hf_text_features = outputs.text_embeds.detach().numpy()
-
-    # Original model inference
-    original_model.trainable = False
-    tf_image_processor = EfficientNetImageProcessor(
-        do_center_crop=True,
-        do_rescale=False,
-        do_normalize=False,
-        include_top=False,
-        resample=Image.BILINEAR,
-    )
-    image = tf_image_processor(images=prepare_img(), return_tensors="tf", data_format="channels_last")["pixel_values"]
-    text = tok(tf.constant(["A picture of a cat"]))
-
-    image_features = original_model.image_encoder(image, training=False)
-    text_features = original_model.text_encoder(text, training=False)
-
-    image_features = tf.nn.l2_normalize(image_features, axis=-1)
-    text_features = tf.nn.l2_normalize(text_features, axis=-1)
-
-    # Check whether original and HF model outputs match  -> np.allclose
-    if not np.allclose(image_features, hf_image_features, atol=1e-3):
-        raise ValueError("The predicted image features are not the same.")
-    if not np.allclose(text_features, hf_text_features, atol=1e-3):
-        raise ValueError("The predicted text features are not the same.")
-    print("Model outputs match!")
-
-    if save_model:
-        # Create folder to save model
-        if not os.path.isdir(pytorch_dump_folder_path):
-            os.mkdir(pytorch_dump_folder_path)
-        # Save converted model and image processor
-        hf_model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        # Push model and image processor to hub
-        print("Pushing converted ALIGN to the hub...")
-        processor.push_to_hub("align-base")
-        hf_model.push_to_hub("align-base")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_path",
-        default="./weights/model-weights",
-        type=str,
-        help="Path to the pretrained TF ALIGN checkpoint.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="hf_model",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--save_model", action="store_true", help="Save model to local")
-    parser.add_argument("--push_to_hub", action="store_true", help="Push model and image processor to the hub")
-
-    args = parser.parse_args()
-    convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)
diff --git a/src/transformers/models/aria/convert_aria_weights_to_hf.py b/src/transformers/models/aria/convert_aria_weights_to_hf.py
deleted file mode 100644
index dcc9e4d13976..000000000000
--- a/src/transformers/models/aria/convert_aria_weights_to_hf.py
+++ /dev/null
@@ -1,162 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import glob
-
-import torch
-from huggingface_hub import snapshot_download
-from safetensors import safe_open
-
-from transformers import (
-    AddedToken,
-    AriaForConditionalGeneration,
-    AriaProcessor,
-    AutoConfig,
-    AutoTokenizer,
-)
-
-
-EPILOG_TXT = """Example:
-    python transformers/src/transformers/models/aria/convert_aria_weights_to_hf.py --text_model_id rhymes-ai/Aria --vision_model_id rhymes-ai/Aria --output_hub_path m-ric/Aria_hf_2 --old_state_dict_id rhymes-ai/Aria
-
-Example for creating the old state dict file with Python:
-
-    import torch
-    from aria.model.language_model.aria_llama import AriaTextForCausalLM
-
-    # load model
-    kwargs = {"device_map": "auto", "torch_dtype": torch.float16}
-    model = AriaTextForCausalLM.from_pretrained("rhymes-ai/Aria", low_cpu_mem_usage=True, **kwargs)
-
-    # load vision tower
-    model.get_vision_tower().load_model()
-
-    # Save state dict
-    torch.save(model.state_dict(), "tmp/hf_models/aria/model_state_dict.bin")
-"""
-
-KEYS_TO_MODIFY_MAPPING = {
-    "vision_tower.vision_model": "vision_tower",
-    "ln_ffn": "layer_norm",
-    "ffn": "feed_forward",
-    "ln_kv": "layer_norm_kv",
-}
-
-
-def load_original_state_dict(model_id):
-    directory_path = snapshot_download(repo_id=model_id, allow_patterns=["*.safetensors"])
-
-    original_state_dict = {}
-    for path in glob.glob(f"{directory_path}/*"):
-        if path.endswith(".safetensors"):
-            with safe_open(path, framework="pt", device="cpu") as f:
-                for key in f.keys():
-                    original_state_dict[key] = f.get_tensor(key)
-
-    return original_state_dict
-
-
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if key.endswith(".inv_freq"):
-            continue
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        new_state_dict[key] = value
-    new_state_dict["vision_tower.post_layernorm.weight"] = torch.zeros((1152,))
-    new_state_dict["vision_tower.post_layernorm.bias"] = torch.zeros((1152,))
-
-    return new_state_dict
-
-
-def convert_aria_llama_to_hf(text_model_id, vision_model_id, output_hub_path, old_state_dict_id):
-    torch.set_default_dtype(torch.float16)
-
-    tokenizer = AutoTokenizer.from_pretrained(
-        text_model_id,
-        extra_special_tokens={
-            "image_token": "<|img|>",
-            "pad_token": "<pad>",
-        },
-    )
-    tokenizer.add_tokens(AddedToken("<|img|>", special=True, normalized=False), special_tokens=True)
-    tokenizer.add_special_tokens({"pad_token": "<pad>"})
-    tokenizer.chat_template = "{% if not add_generation_prompt is defined %}{% set add_generation_prompt = false %}{% endif %}{% for message in messages %}<|im_start|>{{ message['role'] }}\n{% if message['content'] is string %}{{ message['content'] }}{% elif message['content'] is iterable %}{% for item in message['content'] %}{% if item['type'] == 'text' %}{{ item['text'] }}{% elif item['type'] == 'image' %}<fim_prefix><|img|><fim_suffix>{% endif %}{% endfor %}{% endif %}<|im_end|>\n{% endfor %}{% if add_generation_prompt %}<|im_start|>assistant\n{% endif %}"
-
-    processor = AriaProcessor.from_pretrained(
-        text_model_id,
-        tokenizer=tokenizer,
-    )
-
-    config = AutoConfig.from_pretrained(text_model_id)
-    config.vision_config.hidden_size = 1152
-    config.vision_config.attention_heads = 16
-    config.pad_token_id = 2
-    config.image_token_index = 9
-    config.intermediate_size = config.moe_intermediate_size
-    config.auto_map = {
-        "AutoConfig": "modeling_aria.AriaConfig",
-        "AutoModelForCausalLM": "modeling_aria.AriaForConditionalGeneration",
-    }
-
-    with torch.device("meta"):
-        model = AriaForConditionalGeneration(config)
-
-    state_dict = load_original_state_dict(old_state_dict_id)
-
-    state_dict = convert_state_dict_to_hf(state_dict)
-    model.load_state_dict(state_dict, strict=False, assign=True)
-
-    # print("Saving models")
-    # model.save_pretrained("local_aria", safe_serialization=False)
-    # processor.save_pretrained("local_aria")
-    print("Pushing to hub")
-    model.push_to_hub(output_hub_path, create_pr=True)
-    processor.push_to_hub(output_hub_path, create_pr=True)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        epilog=EPILOG_TXT,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument(
-        "--text_model_id",
-        default="rhymes-ai/Aria",
-        help="Hub location of the text model",
-    )
-    parser.add_argument(
-        "--vision_model_id",
-        default="rhymes-ai/Aria",
-        help="Hub location of the vision model",
-    )
-    parser.add_argument(
-        "--output_hub_path",
-        default="rhymes-ai/Aria",
-        help="Location on the hub of the converted model",
-    )
-    parser.add_argument(
-        "--old_state_dict_id",
-        default="rhymes-ai/Aria",
-        help="Location on the hub of the raw state dict of the original model. The filename needs to be `model_state_dict.bin`",
-    )
-    args = parser.parse_args()
-    convert_aria_llama_to_hf(args.text_model_id, args.vision_model_id, args.output_hub_path, args.old_state_dict_id)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/audio_spectrogram_transformer/convert_audio_spectrogram_transformer_original_to_pytorch.py b/src/transformers/models/audio_spectrogram_transformer/convert_audio_spectrogram_transformer_original_to_pytorch.py
deleted file mode 100644
index d211ef7ab058..000000000000
--- a/src/transformers/models/audio_spectrogram_transformer/convert_audio_spectrogram_transformer_original_to_pytorch.py
+++ /dev/null
@@ -1,279 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Audio Spectrogram Transformer checkpoints from the original repository. URL: https://github.com/YuanGongND/ast"""
-
-import argparse
-import json
-from pathlib import Path
-
-import torch
-import torchaudio
-from datasets import load_dataset
-from huggingface_hub import hf_hub_download
-
-from transformers import ASTConfig, ASTFeatureExtractor, ASTForAudioClassification
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_audio_spectrogram_transformer_config(model_name):
-    config = ASTConfig()
-
-    if "10-10" in model_name:
-        pass
-    elif "speech-commands" in model_name:
-        config.max_length = 128
-    elif "12-12" in model_name:
-        config.time_stride = 12
-        config.frequency_stride = 12
-    elif "14-14" in model_name:
-        config.time_stride = 14
-        config.frequency_stride = 14
-    elif "16-16" in model_name:
-        config.time_stride = 16
-        config.frequency_stride = 16
-    else:
-        raise ValueError("Model not supported")
-
-    repo_id = "huggingface/label-files"
-    if "speech-commands" in model_name:
-        config.num_labels = 35
-        filename = "speech-commands-v2-id2label.json"
-    else:
-        config.num_labels = 527
-        filename = "audioset-id2label.json"
-
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-def rename_key(name):
-    if "module.v" in name:
-        name = name.replace("module.v", "audio_spectrogram_transformer")
-    if "cls_token" in name:
-        name = name.replace("cls_token", "embeddings.cls_token")
-    if "dist_token" in name:
-        name = name.replace("dist_token", "embeddings.distillation_token")
-    if "pos_embed" in name:
-        name = name.replace("pos_embed", "embeddings.position_embeddings")
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-    # transformer blocks
-    if "blocks" in name:
-        name = name.replace("blocks", "encoder.layer")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name:
-        name = name.replace("attn", "attention.self")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    # final layernorm
-    if "audio_spectrogram_transformer.norm" in name:
-        name = name.replace("audio_spectrogram_transformer.norm", "audio_spectrogram_transformer.layernorm")
-    # classifier head
-    if "module.mlp_head.0" in name:
-        name = name.replace("module.mlp_head.0", "classifier.layernorm")
-    if "module.mlp_head.1" in name:
-        name = name.replace("module.mlp_head.1", "classifier.dense")
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, config):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[3])
-            dim = config.hidden_size
-            if "weight" in key:
-                orig_state_dict[
-                    f"audio_spectrogram_transformer.encoder.layer.{layer_num}.attention.attention.query.weight"
-                ] = val[:dim, :]
-                orig_state_dict[
-                    f"audio_spectrogram_transformer.encoder.layer.{layer_num}.attention.attention.key.weight"
-                ] = val[dim : dim * 2, :]
-                orig_state_dict[
-                    f"audio_spectrogram_transformer.encoder.layer.{layer_num}.attention.attention.value.weight"
-                ] = val[-dim:, :]
-            else:
-                orig_state_dict[
-                    f"audio_spectrogram_transformer.encoder.layer.{layer_num}.attention.attention.query.bias"
-                ] = val[:dim]
-                orig_state_dict[
-                    f"audio_spectrogram_transformer.encoder.layer.{layer_num}.attention.attention.key.bias"
-                ] = val[dim : dim * 2]
-                orig_state_dict[
-                    f"audio_spectrogram_transformer.encoder.layer.{layer_num}.attention.attention.value.bias"
-                ] = val[-dim:]
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-def remove_keys(state_dict):
-    ignore_keys = [
-        "module.v.head.weight",
-        "module.v.head.bias",
-        "module.v.head_dist.weight",
-        "module.v.head_dist.bias",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-@torch.no_grad()
-def convert_audio_spectrogram_transformer_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our Audio Spectrogram Transformer structure.
-    """
-    config = get_audio_spectrogram_transformer_config(model_name)
-
-    model_name_to_url = {
-        "ast-finetuned-audioset-10-10-0.4593": (
-            "https://www.dropbox.com/s/ca0b1v2nlxzyeb4/audioset_10_10_0.4593.pth?dl=1"
-        ),
-        "ast-finetuned-audioset-10-10-0.450": (
-            "https://www.dropbox.com/s/1tv0hovue1bxupk/audioset_10_10_0.4495.pth?dl=1"
-        ),
-        "ast-finetuned-audioset-10-10-0.448": (
-            "https://www.dropbox.com/s/6u5sikl4b9wo4u5/audioset_10_10_0.4483.pth?dl=1"
-        ),
-        "ast-finetuned-audioset-10-10-0.448-v2": (
-            "https://www.dropbox.com/s/kt6i0v9fvfm1mbq/audioset_10_10_0.4475.pth?dl=1"
-        ),
-        "ast-finetuned-audioset-12-12-0.447": (
-            "https://www.dropbox.com/s/snfhx3tizr4nuc8/audioset_12_12_0.4467.pth?dl=1"
-        ),
-        "ast-finetuned-audioset-14-14-0.443": (
-            "https://www.dropbox.com/s/z18s6pemtnxm4k7/audioset_14_14_0.4431.pth?dl=1"
-        ),
-        "ast-finetuned-audioset-16-16-0.442": (
-            "https://www.dropbox.com/s/mdsa4t1xmcimia6/audioset_16_16_0.4422.pth?dl=1"
-        ),
-        "ast-finetuned-speech-commands-v2": (
-            "https://www.dropbox.com/s/q0tbqpwv44pquwy/speechcommands_10_10_0.9812.pth?dl=1"
-        ),
-    }
-
-    # load original state_dict
-    checkpoint_url = model_name_to_url[model_name]
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
-    # remove some keys
-    remove_keys(state_dict)
-    # rename some keys
-    new_state_dict = convert_state_dict(state_dict, config)
-
-    # load 🤗 model
-    model = ASTForAudioClassification(config)
-    model.eval()
-
-    model.load_state_dict(new_state_dict)
-
-    # verify outputs on dummy input
-    # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
-    mean = -4.2677393 if "speech-commands" not in model_name else -6.845978
-    std = 4.5689974 if "speech-commands" not in model_name else 5.5654526
-    max_length = 1024 if "speech-commands" not in model_name else 128
-    feature_extractor = ASTFeatureExtractor(mean=mean, std=std, max_length=max_length)
-
-    if "speech-commands" in model_name:
-        # TODO: Convert dataset to Parquet
-        dataset = load_dataset("google/speech_commands", "v0.02", split="validation", trust_remote_code=True)
-        waveform = dataset[0]["audio"]["array"]
-    else:
-        filepath = hf_hub_download(
-            repo_id="nielsr/audio-spectogram-transformer-checkpoint",
-            filename="sample_audio.flac",
-            repo_type="dataset",
-        )
-
-        waveform, _ = torchaudio.load(filepath)
-        waveform = waveform.squeeze().numpy()
-
-    inputs = feature_extractor(waveform, sampling_rate=16000, return_tensors="pt")
-
-    # forward pass
-    outputs = model(**inputs)
-    logits = outputs.logits
-
-    if model_name == "ast-finetuned-audioset-10-10-0.4593":
-        expected_slice = torch.tensor([-0.8760, -7.0042, -8.6602])
-    elif model_name == "ast-finetuned-audioset-10-10-0.450":
-        expected_slice = torch.tensor([-1.1986, -7.0903, -8.2718])
-    elif model_name == "ast-finetuned-audioset-10-10-0.448":
-        expected_slice = torch.tensor([-2.6128, -8.0080, -9.4344])
-    elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
-        expected_slice = torch.tensor([-1.5080, -7.4534, -8.8917])
-    elif model_name == "ast-finetuned-audioset-12-12-0.447":
-        expected_slice = torch.tensor([-0.5050, -6.5833, -8.0843])
-    elif model_name == "ast-finetuned-audioset-14-14-0.443":
-        expected_slice = torch.tensor([-0.3826, -7.0336, -8.2413])
-    elif model_name == "ast-finetuned-audioset-16-16-0.442":
-        expected_slice = torch.tensor([-1.2113, -6.9101, -8.3470])
-    elif model_name == "ast-finetuned-speech-commands-v2":
-        expected_slice = torch.tensor([6.1589, -8.0566, -8.7984])
-    else:
-        raise ValueError("Unknown model name")
-    if not torch.allclose(logits[0, :3], expected_slice, atol=1e-4):
-        raise ValueError("Logits don't match")
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving feature extractor to {pytorch_dump_folder_path}")
-        feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model and feature extractor to the hub...")
-        model.push_to_hub(f"MIT/{model_name}")
-        feature_extractor.push_to_hub(f"MIT/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="ast-finetuned-audioset-10-10-0.4593",
-        type=str,
-        help="Name of the Audio Spectrogram Transformer model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/bamba/convert_mamba_ssm_checkpoint.py b/src/transformers/models/bamba/convert_mamba_ssm_checkpoint.py
deleted file mode 100644
index 92ddcc88d4c2..000000000000
--- a/src/transformers/models/bamba/convert_mamba_ssm_checkpoint.py
+++ /dev/null
@@ -1,273 +0,0 @@
-# coding=utf-8
-# Copyright 2024 IBM and the HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""This script can be used to convert checkpoints provided in the `mamba_ssm` library into the format provided in HuggingFace `transformers`. It depends on the `mamba2_ssm` package to be installed."""
-
-import argparse
-import json
-import os
-import re
-from os import path
-from typing import Dict, Optional, Union
-
-import torch
-from huggingface_hub import split_torch_state_dict_into_shards
-from safetensors.torch import save_file
-
-from transformers import AutoTokenizer
-from transformers.utils import SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME
-
-from .configuration_bamba import BambaConfig
-
-
-def convert_state_dict_from_mamba_ssm(original_sd: Dict) -> Dict[str, torch.Tensor]:
-    state_dict = {}
-
-    for orig_k, param in original_sd.items():
-        k = orig_k.replace("backbone", "model")
-
-        # for embeddings
-        k = k.replace("embedding", "embed_tokens")
-
-        # for mixer
-        k = k.replace("mixer", "mamba")
-
-        # for final layernorm
-        k = k.replace("norm_f", "final_layernorm")
-
-        # for block layernorm
-        k = re.sub(r"(\d+)\.norm\.", r"\1.input_layernorm.", k)
-        k = re.sub(r"(\d+)\.norm2\.", r"\1.pre_ff_layernorm.", k)
-
-        # for mlp
-        k = k.replace("mlp.fc2", "feed_forward.down_proj")
-
-        if "mlp.fc1" in k:
-            param, param2 = torch.chunk(param, 2, dim=0)
-            k2 = k.replace("mlp.fc1", "feed_forward.gate_proj")
-            state_dict[k2] = param2
-            k = k.replace("mlp.fc1", "feed_forward.up_proj")
-
-        if ("in_proj" in k and orig_k.replace("in_proj", "conv1d") in original_sd) or (
-            "out_proj" in k and orig_k.replace("out_proj", "conv1d") in original_sd
-        ):
-            # then this must be a mamba
-            pass
-        else:
-            # for attn
-            # - because mixer was replaced to mamba above
-            k = k.replace("mamba.out_proj", "self_attn.o_proj")
-            if "mamba.in_proj" in k:
-                m, n = param.shape
-                d = (m - n) // 2
-                param, param2, param3 = torch.split(param, [n, d, d], dim=0)
-                k2 = k.replace("mamba.in_proj", "self_attn.k_proj")
-                state_dict[k2] = param2
-                k2 = k.replace("mamba.in_proj", "self_attn.v_proj")
-                state_dict[k2] = param3
-                k = k.replace("mamba.in_proj", "self_attn.q_proj")
-
-        state_dict[k] = param
-
-    return state_dict
-
-
-# Adapted from transformers.models.mamba.convert_mamba_ssm_checkpoint_to_pytorch.py
-def convert_ssm_config_to_hf_config(
-    config_ssm: Dict,
-    **kwargs,
-) -> BambaConfig:
-    """Convert a config from mamba_ssm to a BambaConfig from here."""
-    hf_config: BambaConfig = BambaConfig(**kwargs)
-
-    hf_config.architectures = ["BambaForCausalLM"]
-
-    # Set important values from config and recalculate other resulting entries
-    hf_config.hidden_size = config_ssm["d_model"]
-    hf_config.intermediate_size = config_ssm["d_intermediate"]
-    hf_config.mamba_n_heads = (hf_config.hidden_size * hf_config.mamba_expand) // hf_config.mamba_d_head
-    hf_config.num_hidden_layers = config_ssm["n_layer"]
-    hf_config.tie_word_embeddings = config_ssm["tie_embeddings"]
-
-    # currently this script assumes config_ssm belongs to v2
-    if config_ssm["ssm_cfg"].get("layer") != "Mamba2":
-        raise ValueError("Conversion script only supports Mamba2")
-
-    # Set attention values
-    attn_cfg = config_ssm.get("attn_cfg")
-    if attn_cfg:
-        assert attn_cfg["causal"], "Only support non-causal attention."
-        assert not attn_cfg["qkv_proj_bias"], "Only support no qkv bias."
-        assert not attn_cfg["out_proj_bias"], "Only support no out bias."
-        hf_config.attn_rotary_emb = attn_cfg["rotary_emb_dim"]
-        hf_config.num_attention_heads = attn_cfg["num_heads"]
-        hf_config.num_key_value_heads = attn_cfg["num_heads_kv"]
-
-    attention_layer_indices = config_ssm.get("attn_layer_idx")
-    if attention_layer_indices:
-        hf_config.attn_layer_indices = attention_layer_indices
-
-    # Padded vocab size, mostly of 16 but 32 is also very common in different models
-    vocab_size = config_ssm["vocab_size"]
-    pad_vocab_size_multiple = config_ssm["pad_vocab_size_multiple"]
-    if (vocab_size % pad_vocab_size_multiple) != 0:
-        vocab_size += pad_vocab_size_multiple - (vocab_size % pad_vocab_size_multiple)
-    hf_config.vocab_size = vocab_size
-
-    return hf_config
-
-
-def save_single_safetensor(
-    state_dict: Dict,
-    save_directory: str,
-    metadata: Dict,
-):
-    save_file(
-        state_dict,
-        os.path.join(save_directory, SAFE_WEIGHTS_NAME),
-        metadata,
-    )
-
-
-def save_sharded_safetensors(
-    state_dict: Dict,
-    save_directory: str,
-    metadata: Dict,
-    max_shard_size: Union[int, str] = "5GB",
-):
-    filename_pattern = SAFE_WEIGHTS_NAME.replace(".bin", "{suffix}.bin").replace(
-        ".safetensors", "{suffix}.safetensors"
-    )
-    state_dict_split = split_torch_state_dict_into_shards(
-        state_dict, filename_pattern=filename_pattern, max_shard_size=max_shard_size
-    )
-    index = {
-        "metadata": state_dict_split.metadata,
-        "weight_map": state_dict_split.tensor_to_filename,
-    }
-    # Save the index
-    with open(os.path.join(save_directory, SAFE_WEIGHTS_INDEX_NAME), "w", encoding="utf-8") as f:
-        content = json.dumps(index, indent=2, sort_keys=True) + "\n"
-        f.write(content)
-
-    filename_to_tensors = state_dict_split.filename_to_tensors.items()
-    for shard_file, tensors in filename_to_tensors:
-        shard = {tensor: state_dict[tensor].contiguous() for tensor in tensors}
-        save_file(shard, os.path.join(save_directory, shard_file), metadata=metadata)
-
-
-# Adapted from transformers.models.mamba.convert_mamba_ssm_checkpoint_to_pytorch.py
-def convert_mamba_ssm_checkpoint_file_to_huggingface_model_file(
-    mamba_ssm_checkpoint_path: str,
-    precision: str,
-    output_dir: str,
-    tokenizer_path: Optional[str] = None,
-    save_model: Union[bool, str] = True,
-) -> None:
-    # load tokenizer if provided, this will be used to set the
-    # token_ids in the config file
-    token_ids = {}
-    if tokenizer_path:
-        tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
-        for key in [
-            "bos_token_id",
-            "eos_token_id",
-            "pad_token_id",
-        ]:
-            id = getattr(tokenizer, key, None)
-            if id:
-                token_ids[key] = id
-
-    # there are some configs unsettable by mamba_ssn config, so
-    # if there are changes from the defaults, have to pass them into
-    # the function
-    unsettables = {
-        "mamba_d_head": 64,
-        "mamba_d_state": 128,
-        "mamba_n_groups": 1,
-        "rms_norm_eps": 1e-5,
-    }
-
-    # Load and save config based on name
-    config_path = path.join(mamba_ssm_checkpoint_path, "config.json")
-    with open(config_path, "r", encoding="utf-8") as json_file:
-        config = json.load(json_file)
-
-    # convert the config
-    hf_config = convert_ssm_config_to_hf_config(
-        config_ssm=config,
-        **token_ids,
-        **unsettables,
-    )
-    hf_config.save_pretrained(output_dir)
-
-    # Load state dict of the original model and transfer to hf model
-    state_dict = torch.load(
-        path.join(mamba_ssm_checkpoint_path, "pytorch_model.bin"),
-        map_location="cpu",
-        weights_only=True,
-    )
-    # FIXME: allow other parameters to pass in
-    state_dict = convert_state_dict_from_mamba_ssm(state_dict)
-
-    # Save new model to pytorch_dump_path
-    dtype = torch.float32 if precision == "fp32" else (torch.bfloat16 if precision == "bf16" else torch.float16)
-
-    save_file_fn = None
-    if isinstance(save_model, bool) and save_model:
-        save_file_fn = save_single_safetensor
-    elif isinstance(save_model, str) and save_model == "sharded":
-        save_file_fn = save_sharded_safetensors
-
-    if save_file_fn:
-        save_file_fn({k: v.to(dtype) for k, v in state_dict.items()}, output_dir, metadata={"format": "pt"})
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-i",
-        "--mamba_ssm_checkpoint_directory",
-        type=str,
-        required=True,
-        help="Path to a directory containing the `pytorch_model.bin` mamba_ssm checkpoint file to be converted.",
-    )
-    parser.add_argument(
-        "-p",
-        "--precision",
-        type=str,
-        default="fp16",
-        const="fp16",
-        required=True,
-        choices=("fp32", "fp16", "bf16"),
-        help="The precision the model will be saved in. Select from fp32, fp16 or bf16.",
-    )
-    parser.add_argument(
-        "-o", "--output_dir", type=str, required=True, help="Path to directory to save the converted output model to."
-    )
-    parser.add_argument(
-        "-t",
-        "--tokenizer_model_path",
-        type=str,
-        default=None,
-        required=False,
-        help="Path to a the tokenizer file.",
-    )
-    args = parser.parse_args()
-
-    convert_mamba_ssm_checkpoint_file_to_huggingface_model_file(
-        args.mamba2_checkpoint_directory,
-        args.precision,
-        args.output_dir,
-    )
diff --git a/src/transformers/models/bark/convert_suno_to_hf.py b/src/transformers/models/bark/convert_suno_to_hf.py
deleted file mode 100644
index f8c8399cb61a..000000000000
--- a/src/transformers/models/bark/convert_suno_to_hf.py
+++ /dev/null
@@ -1,263 +0,0 @@
-"""Convert Bark checkpoint."""
-
-import argparse
-import os
-from pathlib import Path
-
-import torch
-from bark.generation import _load_model as _bark_load_model
-from huggingface_hub import hf_hub_download
-
-from transformers import EncodecConfig, EncodecModel, set_seed
-from transformers.models.bark.configuration_bark import (
-    BarkCoarseConfig,
-    BarkConfig,
-    BarkFineConfig,
-    BarkSemanticConfig,
-)
-from transformers.models.bark.generation_configuration_bark import (
-    BarkCoarseGenerationConfig,
-    BarkFineGenerationConfig,
-    BarkGenerationConfig,
-    BarkSemanticGenerationConfig,
-)
-from transformers.models.bark.modeling_bark import BarkCoarseModel, BarkFineModel, BarkModel, BarkSemanticModel
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-set_seed(770)
-
-
-new_layer_name_dict = {
-    "c_attn": "att_proj",
-    "c_proj": "out_proj",
-    "c_fc": "in_proj",
-    "transformer.": "",
-    "h.": "layers.",
-    "ln_1": "layernorm_1",
-    "ln_2": "layernorm_2",
-    "ln_f": "layernorm_final",
-    "wpe": "position_embeds_layer",
-    "wte": "input_embeds_layer",
-}
-
-
-REMOTE_MODEL_PATHS = {
-    "text_small": {
-        "repo_id": "suno/bark",
-        "file_name": "text.pt",
-    },
-    "coarse_small": {
-        "repo_id": "suno/bark",
-        "file_name": "coarse.pt",
-    },
-    "fine_small": {
-        "repo_id": "suno/bark",
-        "file_name": "fine.pt",
-    },
-    "text": {
-        "repo_id": "suno/bark",
-        "file_name": "text_2.pt",
-    },
-    "coarse": {
-        "repo_id": "suno/bark",
-        "file_name": "coarse_2.pt",
-    },
-    "fine": {
-        "repo_id": "suno/bark",
-        "file_name": "fine_2.pt",
-    },
-}
-
-CUR_PATH = os.path.dirname(os.path.abspath(__file__))
-default_cache_dir = os.path.join(os.path.expanduser("~"), ".cache")
-CACHE_DIR = os.path.join(os.getenv("XDG_CACHE_HOME", default_cache_dir), "suno", "bark_v0")
-
-
-def _get_ckpt_path(model_type, use_small=False):
-    key = model_type
-    if use_small:
-        key += "_small"
-    return os.path.join(CACHE_DIR, REMOTE_MODEL_PATHS[key]["file_name"])
-
-
-def _download(from_hf_path, file_name):
-    os.makedirs(CACHE_DIR, exist_ok=True)
-    hf_hub_download(repo_id=from_hf_path, filename=file_name, local_dir=CACHE_DIR)
-
-
-def _load_model(ckpt_path, device, use_small=False, model_type="text"):
-    if model_type == "text":
-        ModelClass = BarkSemanticModel
-        ConfigClass = BarkSemanticConfig
-        GenerationConfigClass = BarkSemanticGenerationConfig
-    elif model_type == "coarse":
-        ModelClass = BarkCoarseModel
-        ConfigClass = BarkCoarseConfig
-        GenerationConfigClass = BarkCoarseGenerationConfig
-    elif model_type == "fine":
-        ModelClass = BarkFineModel
-        ConfigClass = BarkFineConfig
-        GenerationConfigClass = BarkFineGenerationConfig
-    else:
-        raise NotImplementedError()
-    model_key = f"{model_type}_small" if use_small else model_type
-    model_info = REMOTE_MODEL_PATHS[model_key]
-    if not os.path.exists(ckpt_path):
-        logger.info(f"{model_type} model not found, downloading into `{CACHE_DIR}`.")
-        _download(model_info["repo_id"], model_info["file_name"])
-    checkpoint = torch.load(ckpt_path, map_location=device)
-    # this is a hack
-    model_args = checkpoint["model_args"]
-    if "input_vocab_size" not in model_args:
-        model_args["input_vocab_size"] = model_args["vocab_size"]
-        model_args["output_vocab_size"] = model_args["vocab_size"]
-        del model_args["vocab_size"]
-
-    # convert Bark model arguments to HF Bark model arguments
-    model_args["num_heads"] = model_args.pop("n_head")
-    model_args["hidden_size"] = model_args.pop("n_embd")
-    model_args["num_layers"] = model_args.pop("n_layer")
-
-    model_config = ConfigClass(**checkpoint["model_args"])
-    model = ModelClass(config=model_config)
-    model_generation_config = GenerationConfigClass()
-
-    model.generation_config = model_generation_config
-    state_dict = checkpoint["model"]
-    # fixup checkpoint
-    unwanted_prefix = "_orig_mod."
-    for k, v in list(state_dict.items()):
-        if k.startswith(unwanted_prefix):
-            # replace part of the key with corresponding layer name in HF implementation
-            new_k = k[len(unwanted_prefix) :]
-            for old_layer_name in new_layer_name_dict:
-                new_k = new_k.replace(old_layer_name, new_layer_name_dict[old_layer_name])
-
-            state_dict[new_k] = state_dict.pop(k)
-
-    extra_keys = set(state_dict.keys()) - set(model.state_dict().keys())
-    extra_keys = {k for k in extra_keys if not k.endswith(".attn.bias")}
-    missing_keys = set(model.state_dict().keys()) - set(state_dict.keys())
-    missing_keys = {k for k in missing_keys if not k.endswith(".attn.bias")}
-    if len(extra_keys) != 0:
-        raise ValueError(f"extra keys found: {extra_keys}")
-    if len(missing_keys) != 0:
-        raise ValueError(f"missing keys: {missing_keys}")
-    model.load_state_dict(state_dict, strict=False)
-    n_params = model.num_parameters(exclude_embeddings=True)
-    val_loss = checkpoint["best_val_loss"].item()
-    logger.info(f"model loaded: {round(n_params / 1e6, 1)}M params, {round(val_loss, 3)} loss")
-    model.eval()
-    model.to(device)
-    del checkpoint, state_dict
-
-    return model
-
-
-def load_model(pytorch_dump_folder_path, use_small=False, model_type="text"):
-    if model_type not in ("text", "coarse", "fine"):
-        raise NotImplementedError()
-
-    device = "cpu"  # do conversion on cpu
-
-    ckpt_path = _get_ckpt_path(model_type, use_small=use_small)
-    model = _load_model(ckpt_path, device, model_type=model_type, use_small=use_small)
-
-    # load bark initial model
-    bark_model = _bark_load_model(ckpt_path, "cpu", model_type=model_type, use_small=use_small)
-
-    if model_type == "text":
-        bark_model = bark_model["model"]
-
-    if model.num_parameters(exclude_embeddings=True) != bark_model.get_num_params():
-        raise ValueError("initial and new models don't have the same number of parameters")
-
-    # check if same output as the bark model
-    batch_size = 5
-    sequence_length = 10
-
-    if model_type in ["text", "coarse"]:
-        vec = torch.randint(256, (batch_size, sequence_length), dtype=torch.int)
-        output_old_model = bark_model(vec)[0]
-
-        output_new_model_total = model(vec)
-
-        # take last logits
-        output_new_model = output_new_model_total.logits[:, [-1], :]
-
-    else:
-        prediction_codebook_channel = 3
-        n_codes_total = 8
-        vec = torch.randint(256, (batch_size, sequence_length, n_codes_total), dtype=torch.int)
-
-        output_new_model_total = model(prediction_codebook_channel, vec)
-        output_old_model = bark_model(prediction_codebook_channel, vec)
-
-        output_new_model = output_new_model_total.logits
-
-    # output difference should come from the difference of self-attention implementation design
-    if output_new_model.shape != output_old_model.shape:
-        raise ValueError("initial and new outputs don't have the same shape")
-    if (output_new_model - output_old_model).abs().max().item() > 1e-3:
-        raise ValueError("initial and new outputs are not equal")
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-def load_whole_bark_model(
-    semantic_path,
-    coarse_path,
-    fine_path,
-    append_text,
-    hub_path,
-    folder_path,
-):
-    pytorch_dump_folder_path = os.path.join(folder_path, append_text)
-
-    semanticConfig = BarkSemanticConfig.from_pretrained(os.path.join(semantic_path, "config.json"))
-    coarseAcousticConfig = BarkCoarseConfig.from_pretrained(os.path.join(coarse_path, "config.json"))
-    fineAcousticConfig = BarkFineConfig.from_pretrained(os.path.join(fine_path, "config.json"))
-    codecConfig = EncodecConfig.from_pretrained("facebook/encodec_24khz")
-
-    semantic = BarkSemanticModel.from_pretrained(semantic_path)
-    coarseAcoustic = BarkCoarseModel.from_pretrained(coarse_path)
-    fineAcoustic = BarkFineModel.from_pretrained(fine_path)
-    codec = EncodecModel.from_pretrained("facebook/encodec_24khz")
-
-    bark_config = BarkConfig.from_sub_model_configs(
-        semanticConfig, coarseAcousticConfig, fineAcousticConfig, codecConfig
-    )
-
-    bark_generation_config = BarkGenerationConfig.from_sub_model_configs(
-        semantic.generation_config, coarseAcoustic.generation_config, fineAcoustic.generation_config
-    )
-
-    bark = BarkModel(bark_config)
-
-    bark.semantic = semantic
-    bark.coarse_acoustics = coarseAcoustic
-    bark.fine_acoustics = fineAcoustic
-    bark.codec_model = codec
-
-    bark.generation_config = bark_generation_config
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    bark.save_pretrained(pytorch_dump_folder_path, repo_id=hub_path, push_to_hub=True)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-
-    parser.add_argument("model_type", type=str, help="text, coarse or fine.")
-    parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--is_small", action="store_true", help="convert the small version instead of the large.")
-
-    args = parser.parse_args()
-
-    load_model(args.pytorch_dump_folder_path, model_type=args.model_type, use_small=args.is_small)
diff --git a/src/transformers/models/bart/convert_bart_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/bart/convert_bart_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index e694d96ca0df..000000000000
--- a/src/transformers/models/bart/convert_bart_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,156 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert BART checkpoint."""
-
-import argparse
-import os
-from pathlib import Path
-
-import fairseq
-import torch
-from packaging import version
-from torch import nn
-
-from transformers import (
-    BartConfig,
-    BartForConditionalGeneration,
-    BartForSequenceClassification,
-    BartModel,
-    BartTokenizer,
-)
-from transformers.utils import logging
-
-
-FAIRSEQ_MODELS = ["bart.large", "bart.large.mnli", "bart.large.cnn", "bart_xsum/model.pt"]
-extra_arch = {"bart.large": BartModel, "bart.large.mnli": BartForSequenceClassification}
-if version.parse(fairseq.__version__) < version.parse("0.9.0"):
-    raise Exception("requires fairseq >= 0.9.0")
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-SAMPLE_TEXT = " Hello world! cécé herlolip"
-
-mnli_rename_keys = [
-    ("model.classification_heads.mnli.dense.weight", "classification_head.dense.weight"),
-    ("model.classification_heads.mnli.dense.bias", "classification_head.dense.bias"),
-    ("model.classification_heads.mnli.out_proj.weight", "classification_head.out_proj.weight"),
-    ("model.classification_heads.mnli.out_proj.bias", "classification_head.out_proj.bias"),
-]
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = [
-        "encoder.version",
-        "decoder.version",
-        "model.encoder.version",
-        "model.decoder.version",
-        "_float_tensor",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def load_xsum_checkpoint(checkpoint_path):
-    """Checkpoint path should end in model.pt"""
-    sd = torch.load(checkpoint_path, map_location="cpu")
-    hub_interface = torch.hub.load("pytorch/fairseq", "bart.large.cnn").eval()
-    hub_interface.model.load_state_dict(sd["model"])
-    return hub_interface
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-@torch.no_grad()
-def convert_bart_checkpoint(checkpoint_path, pytorch_dump_folder_path, hf_checkpoint_name=None):
-    """
-    Copy/paste/tweak model's weights to our BERT structure.
-    """
-    if not os.path.exists(checkpoint_path):
-        bart = torch.hub.load("pytorch/fairseq", checkpoint_path).eval()
-    else:
-        bart = load_xsum_checkpoint(checkpoint_path)
-
-    bart.model.upgrade_state_dict(bart.model.state_dict())
-    if hf_checkpoint_name is None:
-        hf_checkpoint_name = checkpoint_path.replace(".", "-")
-    config = BartConfig.from_pretrained(hf_checkpoint_name)
-    tokens = bart.encode(SAMPLE_TEXT).unsqueeze(0)
-    tokens2 = BartTokenizer.from_pretrained(hf_checkpoint_name).encode(SAMPLE_TEXT, return_tensors="pt").unsqueeze(0)
-    if not torch.eq(tokens, tokens2).all():
-        raise ValueError(
-            f"converted tokenizer and pretrained tokenizer returned different output: {tokens} != {tokens2}"
-        )
-
-    if checkpoint_path == "bart.large.mnli":
-        state_dict = bart.state_dict()
-        remove_ignore_keys_(state_dict)
-        state_dict["model.shared.weight"] = state_dict["model.decoder.embed_tokens.weight"]
-        for src, dest in mnli_rename_keys:
-            rename_key(state_dict, src, dest)
-        model = BartForSequenceClassification(config).eval()
-        model.load_state_dict(state_dict)
-        fairseq_output = bart.predict("mnli", tokens, return_logits=True)
-        new_model_outputs = model(tokens)[0]  # logits
-    else:  # no classification heads to worry about
-        state_dict = bart.model.state_dict()
-        remove_ignore_keys_(state_dict)
-        state_dict["shared.weight"] = state_dict["decoder.embed_tokens.weight"]
-        fairseq_output = bart.extract_features(tokens)
-        if hf_checkpoint_name == "facebook/bart-large":
-            model = BartModel(config).eval()
-            model.load_state_dict(state_dict)
-            new_model_outputs = model(tokens).model[0]
-        else:
-            model = BartForConditionalGeneration(config).eval()  # an existing summarization ckpt
-            model.model.load_state_dict(state_dict)
-            if hasattr(model, "lm_head"):
-                model.lm_head = make_linear_from_emb(model.model.shared)
-            new_model_outputs = model.model(tokens)[0]
-
-    # Check results
-    if fairseq_output.shape != new_model_outputs.shape:
-        raise ValueError(
-            f"`fairseq_output` shape and `new_model_output` shape are different: {fairseq_output.shape=}, {new_model_outputs.shape}"
-        )
-    if (fairseq_output != new_model_outputs).any().item():
-        raise ValueError("Some values in `fairseq_output` are different from `new_model_outputs`")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "fairseq_path", type=str, help="bart.large, bart.large.cnn or a path to a model.pt on local filesystem."
-    )
-    parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument(
-        "--hf_config", default=None, type=str, help="Which huggingface architecture to use: bart-large-xsum"
-    )
-    args = parser.parse_args()
-    convert_bart_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, hf_checkpoint_name=args.hf_config)
diff --git a/src/transformers/models/beit/convert_beit_unilm_to_pytorch.py b/src/transformers/models/beit/convert_beit_unilm_to_pytorch.py
deleted file mode 100644
index 46c72a97f495..000000000000
--- a/src/transformers/models/beit/convert_beit_unilm_to_pytorch.py
+++ /dev/null
@@ -1,373 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert BEiT checkpoints from the unilm repository."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from datasets import load_dataset
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    BeitConfig,
-    BeitForImageClassification,
-    BeitForMaskedImageModeling,
-    BeitForSemanticSegmentation,
-    BeitImageProcessor,
-)
-from transformers.image_utils import PILImageResampling
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, has_lm_head=False, is_semantic=False):
-    prefix = "backbone." if is_semantic else ""
-
-    rename_keys = []
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"{prefix}blocks.{i}.norm1.weight", f"beit.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.norm1.bias", f"beit.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.attn.proj.weight", f"beit.encoder.layer.{i}.attention.output.dense.weight")
-        )
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.attn.proj.bias", f"beit.encoder.layer.{i}.attention.output.dense.bias")
-        )
-        rename_keys.append((f"{prefix}blocks.{i}.norm2.weight", f"beit.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.norm2.bias", f"beit.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc1.weight", f"beit.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc1.bias", f"beit.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc2.weight", f"beit.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc2.bias", f"beit.encoder.layer.{i}.output.dense.bias"))
-
-    # projection layer + position embeddings
-    rename_keys.extend(
-        [
-            (f"{prefix}cls_token", "beit.embeddings.cls_token"),
-            (f"{prefix}patch_embed.proj.weight", "beit.embeddings.patch_embeddings.projection.weight"),
-            (f"{prefix}patch_embed.proj.bias", "beit.embeddings.patch_embeddings.projection.bias"),
-        ]
-    )
-
-    if has_lm_head:
-        # mask token + shared relative position bias + layernorm
-        rename_keys.extend(
-            [
-                ("mask_token", "beit.embeddings.mask_token"),
-                (
-                    "rel_pos_bias.relative_position_bias_table",
-                    "beit.encoder.relative_position_bias.relative_position_bias_table",
-                ),
-                (
-                    "rel_pos_bias.relative_position_index",
-                    "beit.encoder.relative_position_bias.relative_position_index",
-                ),
-                ("norm.weight", "layernorm.weight"),
-                ("norm.bias", "layernorm.bias"),
-            ]
-        )
-    elif is_semantic:
-        # semantic segmentation classification heads
-        rename_keys.extend(
-            [
-                ("decode_head.conv_seg.weight", "decode_head.classifier.weight"),
-                ("decode_head.conv_seg.bias", "decode_head.classifier.bias"),
-                ("auxiliary_head.conv_seg.weight", "auxiliary_head.classifier.weight"),
-                ("auxiliary_head.conv_seg.bias", "auxiliary_head.classifier.bias"),
-            ]
-        )
-    else:
-        # layernorm + classification head
-        rename_keys.extend(
-            [
-                ("fc_norm.weight", "beit.pooler.layernorm.weight"),
-                ("fc_norm.bias", "beit.pooler.layernorm.bias"),
-                ("head.weight", "classifier.weight"),
-                ("head.bias", "classifier.bias"),
-            ]
-        )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, has_lm_head=False, is_semantic=False):
-    for i in range(config.num_hidden_layers):
-        prefix = "backbone." if is_semantic else ""
-        # queries, keys and values
-        in_proj_weight = state_dict.pop(f"{prefix}blocks.{i}.attn.qkv.weight")
-        q_bias = state_dict.pop(f"{prefix}blocks.{i}.attn.q_bias")
-        v_bias = state_dict.pop(f"{prefix}blocks.{i}.attn.v_bias")
-
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.query.bias"] = q_bias
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.value.bias"] = v_bias
-
-        # gamma_1 and gamma_2
-        # we call them lambda because otherwise they are renamed when using .from_pretrained
-        gamma_1 = state_dict.pop(f"{prefix}blocks.{i}.gamma_1")
-        gamma_2 = state_dict.pop(f"{prefix}blocks.{i}.gamma_2")
-
-        state_dict[f"beit.encoder.layer.{i}.lambda_1"] = gamma_1
-        state_dict[f"beit.encoder.layer.{i}.lambda_2"] = gamma_2
-
-        # relative_position bias table + index
-        if not has_lm_head:
-            # each layer has its own relative position bias
-            table = state_dict.pop(f"{prefix}blocks.{i}.attn.relative_position_bias_table")
-            index = state_dict.pop(f"{prefix}blocks.{i}.attn.relative_position_index")
-
-            state_dict[
-                f"beit.encoder.layer.{i}.attention.attention.relative_position_bias.relative_position_bias_table"
-            ] = table
-            state_dict[
-                f"beit.encoder.layer.{i}.attention.attention.relative_position_bias.relative_position_index"
-            ] = index
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_beit_checkpoint(checkpoint_url, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our BEiT structure.
-    """
-
-    # define default BEiT configuration
-    config = BeitConfig()
-    has_lm_head = False
-    is_semantic = False
-    repo_id = "huggingface/label-files"
-    # set config parameters based on URL
-    if checkpoint_url[-9:-4] == "pt22k":
-        # masked image modeling
-        config.use_shared_relative_position_bias = True
-        config.use_mask_token = True
-        has_lm_head = True
-    elif checkpoint_url[-9:-4] == "ft22k":
-        # intermediate fine-tuning on ImageNet-22k
-        config.use_relative_position_bias = True
-        config.num_labels = 21841
-        filename = "imagenet-22k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        # this dataset contains 21843 labels but the model only has 21841
-        # we delete the classes as mentioned in https://github.com/google-research/big_transfer/issues/18
-        del id2label[9205]
-        del id2label[15027]
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-    elif checkpoint_url[-8:-4] == "to1k":
-        # fine-tuning on ImageNet-1k
-        config.use_relative_position_bias = True
-        config.num_labels = 1000
-        filename = "imagenet-1k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-        if "384" in checkpoint_url:
-            config.image_size = 384
-        if "512" in checkpoint_url:
-            config.image_size = 512
-    elif "ade20k" in checkpoint_url:
-        # fine-tuning
-        config.use_relative_position_bias = True
-        config.num_labels = 150
-        filename = "ade20k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-        config.image_size = 640
-        is_semantic = True
-    else:
-        raise ValueError("Checkpoint not supported, URL should either end with 'pt22k', 'ft22k', 'to1k' or 'ade20k'")
-
-    # size of the architecture
-    if "base" in checkpoint_url:
-        pass
-    elif "large" in checkpoint_url:
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-        if "ade20k" in checkpoint_url:
-            config.image_size = 640
-            config.out_indices = [7, 11, 15, 23]
-    else:
-        raise ValueError("Should either find 'base' or 'large' in checkpoint URL")
-
-    # load state_dict of original model, remove and rename some keys
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu", check_hash=True)
-    state_dict = state_dict["model"] if "ade20k" not in checkpoint_url else state_dict["state_dict"]
-
-    rename_keys = create_rename_keys(config, has_lm_head=has_lm_head, is_semantic=is_semantic)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config, has_lm_head=has_lm_head, is_semantic=is_semantic)
-    if is_semantic:
-        # add prefix to decoder keys
-        for key, val in state_dict.copy().items():
-            val = state_dict.pop(key)
-            if key.startswith("backbone.fpn"):
-                key = key.replace("backbone.fpn", "fpn")
-            state_dict[key] = val
-
-    # load HuggingFace model
-    if checkpoint_url[-9:-4] == "pt22k":
-        model = BeitForMaskedImageModeling(config)
-    elif "ade20k" in checkpoint_url:
-        model = BeitForSemanticSegmentation(config)
-    else:
-        model = BeitForImageClassification(config)
-    model.eval()
-    model.load_state_dict(state_dict)
-
-    # Check outputs on an image
-    if is_semantic:
-        image_processor = BeitImageProcessor(size=config.image_size, do_center_crop=False)
-        ds = load_dataset("hf-internal-testing/fixtures_ade20k", split="test", trust_remote_code=True)
-        image = Image.open(ds[0]["file"])
-    else:
-        image_processor = BeitImageProcessor(
-            size=config.image_size, resample=PILImageResampling.BILINEAR, do_center_crop=False
-        )
-        image = prepare_img()
-
-    encoding = image_processor(images=image, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    outputs = model(pixel_values)
-    logits = outputs.logits
-
-    # verify logits
-    expected_shape = torch.Size([1, 1000])
-    if checkpoint_url[:-4].endswith("beit_base_patch16_224_pt22k"):
-        expected_shape = torch.Size([1, 196, 8192])
-    elif checkpoint_url[:-4].endswith("beit_large_patch16_224_pt22k"):
-        expected_shape = torch.Size([1, 196, 8192])
-    elif checkpoint_url[:-4].endswith("beit_base_patch16_224_pt22k_ft22k"):
-        expected_shape = torch.Size([1, 21841])
-        expected_logits = torch.tensor([2.2288, 2.4671, 0.7395])
-        expected_class_idx = 2397
-    elif checkpoint_url[:-4].endswith("beit_large_patch16_224_pt22k_ft22k"):
-        expected_shape = torch.Size([1, 21841])
-        expected_logits = torch.tensor([1.6881, -0.2787, 0.5901])
-        expected_class_idx = 2396
-    elif checkpoint_url[:-4].endswith("beit_base_patch16_224_pt22k_ft1k"):
-        expected_logits = torch.tensor([0.1241, 0.0798, -0.6569])
-        expected_class_idx = 285
-    elif checkpoint_url[:-4].endswith("beit_base_patch16_224_pt22k_ft22kto1k"):
-        expected_logits = torch.tensor([-1.2385, -1.0987, -1.0108])
-        expected_class_idx = 281
-    elif checkpoint_url[:-4].endswith("beit_base_patch16_384_pt22k_ft22kto1k"):
-        expected_logits = torch.tensor([-1.5303, -0.9484, -0.3147])
-        expected_class_idx = 761
-    elif checkpoint_url[:-4].endswith("beit_large_patch16_224_pt22k_ft1k"):
-        expected_logits = torch.tensor([0.4610, -0.0928, 0.2086])
-        expected_class_idx = 761
-    elif checkpoint_url[:-4].endswith("beit_large_patch16_224_pt22k_ft22kto1k"):
-        expected_logits = torch.tensor([-0.4804, 0.6257, -0.1837])
-        expected_class_idx = 761
-    elif checkpoint_url[:-4].endswith("beit_large_patch16_384_pt22k_ft22kto1k"):
-        expected_logits = torch.tensor([[-0.5122, 0.5117, -0.2113]])
-        expected_class_idx = 761
-    elif checkpoint_url[:-4].endswith("beit_large_patch16_512_pt22k_ft22kto1k"):
-        expected_logits = torch.tensor([-0.3062, 0.7261, 0.4852])
-        expected_class_idx = 761
-    elif checkpoint_url[:-4].endswith("beit_base_patch16_640_pt22k_ft22ktoade20k"):
-        expected_shape = (1, 150, 160, 160)
-        expected_logits = torch.tensor(
-            [
-                [[-4.9225, -2.3954, -3.0522], [-2.8822, -1.0046, -1.7561], [-2.9549, -1.3228, -2.1347]],
-                [[-5.8168, -3.4129, -4.0778], [-3.8651, -2.2214, -3.0277], [-3.8356, -2.4643, -3.3535]],
-                [[-0.0078, 3.9952, 4.0754], [2.9856, 4.6944, 5.0035], [3.2413, 4.7813, 4.9969]],
-            ]
-        )
-    elif checkpoint_url[:-4].endswith("beit_large_patch16_640_pt22k_ft22ktoade20k"):
-        expected_shape = (1, 150, 160, 160)
-        expected_logits = torch.tensor(
-            [
-                [[-4.3305, -2.3049, -3.0161], [-2.9591, -1.5305, -2.2251], [-3.4198, -1.8004, -2.9062]],
-                [[-5.8922, -3.7435, -4.3978], [-4.2063, -2.7872, -3.4755], [-4.2791, -3.1874, -4.1681]],
-                [[0.9895, 4.3467, 4.7663], [4.2476, 5.6830, 6.1518], [4.5550, 6.2495, 6.5154]],
-            ]
-        )
-    else:
-        raise ValueError("Can't verify logits as model is not supported")
-
-    if logits.shape != expected_shape:
-        raise ValueError(f"Shape of logits not as expected. {logits.shape=}, {expected_shape=}")
-    if not has_lm_head:
-        if is_semantic:
-            if not torch.allclose(logits[0, :3, :3, :3], expected_logits, atol=1e-3):
-                raise ValueError("First elements of logits not as expected")
-        else:
-            print("Predicted class idx:", logits.argmax(-1).item())
-
-            if not torch.allclose(logits[0, :3], expected_logits, atol=1e-3):
-                raise ValueError("First elements of logits not as expected")
-            if logits.argmax(-1).item() != expected_class_idx:
-                raise ValueError("Predicted class index not as expected")
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_base_patch16_224_pt22k_ft22kto1k.pth",
-        type=str,
-        help="URL to the original PyTorch checkpoint (.pth file).",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_beit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/bert/convert_bert_original_tf2_checkpoint_to_pytorch.py b/src/transformers/models/bert/convert_bert_original_tf2_checkpoint_to_pytorch.py
deleted file mode 100644
index 9dfd8da474e3..000000000000
--- a/src/transformers/models/bert/convert_bert_original_tf2_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,246 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-This script can be used to convert a head-less TF2.x Bert model to PyTorch, as published on the official (now
-deprecated) GitHub: https://github.com/tensorflow/models/tree/v2.3.0/official/nlp/bert
-
-TF2.x uses different variable names from the original BERT (TF 1.4) implementation. The script re-maps the TF2.x Bert
-weight names to the original names, so the model can be imported with Huggingface/transformer.
-
-You may adapt this script to include classification/MLM/NSP/etc. heads.
-
-Note: This script is only working with an older version of the TensorFlow models repository (<= v2.3.0).
-      Models trained with never versions are not compatible with this script.
-"""
-
-import argparse
-import os
-import re
-
-import tensorflow as tf
-import torch
-
-from transformers import BertConfig, BertModel
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def load_tf2_weights_in_bert(model, tf_checkpoint_path, config):
-    tf_path = os.path.abspath(tf_checkpoint_path)
-    logger.info(f"Converting TensorFlow checkpoint from {tf_path}")
-    # Load weights from TF model
-    init_vars = tf.train.list_variables(tf_path)
-    names = []
-    arrays = []
-    layer_depth = []
-    for full_name, shape in init_vars:
-        # logger.info(f"Loading TF weight {name} with shape {shape}")
-        name = full_name.split("/")
-        if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
-            logger.info(f"Skipping non-model layer {full_name}")
-            continue
-        if "optimizer" in full_name:
-            logger.info(f"Skipping optimization layer {full_name}")
-            continue
-        if name[0] == "model":
-            # ignore initial 'model'
-            name = name[1:]
-        # figure out how many levels deep the name is
-        depth = 0
-        for _name in name:
-            if _name.startswith("layer_with_weights"):
-                depth += 1
-            else:
-                break
-        layer_depth.append(depth)
-        # read data
-        array = tf.train.load_variable(tf_path, full_name)
-        names.append("/".join(name))
-        arrays.append(array)
-    logger.info(f"Read a total of {len(arrays):,} layers")
-
-    # Sanity check
-    if len(set(layer_depth)) != 1:
-        raise ValueError(f"Found layer names with different depths (layer depth {list(set(layer_depth))})")
-    layer_depth = list(set(layer_depth))[0]
-    if layer_depth != 1:
-        raise ValueError(
-            "The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP"
-            " heads."
-        )
-
-    # convert layers
-    logger.info("Converting weights...")
-    for full_name, array in zip(names, arrays):
-        name = full_name.split("/")
-        pointer = model
-        trace = []
-        for i, m_name in enumerate(name):
-            if m_name == ".ATTRIBUTES":
-                # variable names end with .ATTRIBUTES/VARIABLE_VALUE
-                break
-            if m_name.startswith("layer_with_weights"):
-                layer_num = int(m_name.split("-")[-1])
-                if layer_num <= 2:
-                    # embedding layers
-                    # layer_num 0: word_embeddings
-                    # layer_num 1: position_embeddings
-                    # layer_num 2: token_type_embeddings
-                    continue
-                elif layer_num == 3:
-                    # embedding LayerNorm
-                    trace.extend(["embeddings", "LayerNorm"])
-                    pointer = getattr(pointer, "embeddings")
-                    pointer = getattr(pointer, "LayerNorm")
-                elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
-                    # encoder layers
-                    trace.extend(["encoder", "layer", str(layer_num - 4)])
-                    pointer = getattr(pointer, "encoder")
-                    pointer = getattr(pointer, "layer")
-                    pointer = pointer[layer_num - 4]
-                elif layer_num == config.num_hidden_layers + 4:
-                    # pooler layer
-                    trace.extend(["pooler", "dense"])
-                    pointer = getattr(pointer, "pooler")
-                    pointer = getattr(pointer, "dense")
-            elif m_name == "embeddings":
-                trace.append("embeddings")
-                pointer = getattr(pointer, "embeddings")
-                if layer_num == 0:
-                    trace.append("word_embeddings")
-                    pointer = getattr(pointer, "word_embeddings")
-                elif layer_num == 1:
-                    trace.append("position_embeddings")
-                    pointer = getattr(pointer, "position_embeddings")
-                elif layer_num == 2:
-                    trace.append("token_type_embeddings")
-                    pointer = getattr(pointer, "token_type_embeddings")
-                else:
-                    raise ValueError(f"Unknown embedding layer with name {full_name}")
-                trace.append("weight")
-                pointer = getattr(pointer, "weight")
-            elif m_name == "_attention_layer":
-                # self-attention layer
-                trace.extend(["attention", "self"])
-                pointer = getattr(pointer, "attention")
-                pointer = getattr(pointer, "self")
-            elif m_name == "_attention_layer_norm":
-                # output attention norm
-                trace.extend(["attention", "output", "LayerNorm"])
-                pointer = getattr(pointer, "attention")
-                pointer = getattr(pointer, "output")
-                pointer = getattr(pointer, "LayerNorm")
-            elif m_name == "_attention_output_dense":
-                # output attention dense
-                trace.extend(["attention", "output", "dense"])
-                pointer = getattr(pointer, "attention")
-                pointer = getattr(pointer, "output")
-                pointer = getattr(pointer, "dense")
-            elif m_name == "_output_dense":
-                # output dense
-                trace.extend(["output", "dense"])
-                pointer = getattr(pointer, "output")
-                pointer = getattr(pointer, "dense")
-            elif m_name == "_output_layer_norm":
-                # output dense
-                trace.extend(["output", "LayerNorm"])
-                pointer = getattr(pointer, "output")
-                pointer = getattr(pointer, "LayerNorm")
-            elif m_name == "_key_dense":
-                # attention key
-                trace.append("key")
-                pointer = getattr(pointer, "key")
-            elif m_name == "_query_dense":
-                # attention query
-                trace.append("query")
-                pointer = getattr(pointer, "query")
-            elif m_name == "_value_dense":
-                # attention value
-                trace.append("value")
-                pointer = getattr(pointer, "value")
-            elif m_name == "_intermediate_dense":
-                # attention intermediate dense
-                trace.extend(["intermediate", "dense"])
-                pointer = getattr(pointer, "intermediate")
-                pointer = getattr(pointer, "dense")
-            elif m_name == "_output_layer_norm":
-                # output layer norm
-                trace.append("output")
-                pointer = getattr(pointer, "output")
-            # weights & biases
-            elif m_name in ["bias", "beta"]:
-                trace.append("bias")
-                pointer = getattr(pointer, "bias")
-            elif m_name in ["kernel", "gamma"]:
-                trace.append("weight")
-                pointer = getattr(pointer, "weight")
-            else:
-                logger.warning(f"Ignored {m_name}")
-        # for certain layers reshape is necessary
-        trace = ".".join(trace)
-        if re.match(r"(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)", trace) or re.match(
-            r"(\S+)\.attention\.output\.dense\.weight", trace
-        ):
-            array = array.reshape(pointer.data.shape)
-        if "kernel" in full_name:
-            array = array.transpose()
-        if pointer.shape == array.shape:
-            pointer.data = torch.from_numpy(array)
-        else:
-            raise ValueError(
-                f"Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:"
-                f" {array.shape}"
-            )
-        logger.info(f"Successfully set variable {full_name} to PyTorch layer {trace}")
-    return model
-
-
-def convert_tf2_checkpoint_to_pytorch(tf_checkpoint_path, config_path, pytorch_dump_path):
-    # Instantiate model
-    logger.info(f"Loading model based on config from {config_path}...")
-    config = BertConfig.from_json_file(config_path)
-    model = BertModel(config)
-
-    # Load weights from checkpoint
-    logger.info(f"Loading weights from checkpoint {tf_checkpoint_path}...")
-    load_tf2_weights_in_bert(model, tf_checkpoint_path, config)
-
-    # Save pytorch-model
-    logger.info(f"Saving PyTorch model to {pytorch_dump_path}...")
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--tf_checkpoint_path", type=str, required=True, help="Path to the TensorFlow 2.x checkpoint path."
-    )
-    parser.add_argument(
-        "--bert_config_file",
-        type=str,
-        required=True,
-        help="The config json file corresponding to the BERT model. This specifies the model architecture.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path",
-        type=str,
-        required=True,
-        help="Path to the output PyTorch model (must include filename).",
-    )
-    args = parser.parse_args()
-    convert_tf2_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/bert/convert_bert_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/bert/convert_bert_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index be904ddd7e6c..000000000000
--- a/src/transformers/models/bert/convert_bert_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert BERT checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, bert_config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = BertConfig.from_json_file(bert_config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = BertForPreTraining(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_bert(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--bert_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained BERT model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/bert/convert_bert_pytorch_checkpoint_to_original_tf.py b/src/transformers/models/bert/convert_bert_pytorch_checkpoint_to_original_tf.py
deleted file mode 100644
index f7cb149053a3..000000000000
--- a/src/transformers/models/bert/convert_bert_pytorch_checkpoint_to_original_tf.py
+++ /dev/null
@@ -1,112 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert Huggingface Pytorch checkpoint to Tensorflow checkpoint."""
-
-import argparse
-import os
-
-import numpy as np
-import tensorflow as tf
-import torch
-
-from transformers import BertModel
-
-
-def convert_pytorch_checkpoint_to_tf(model: BertModel, ckpt_dir: str, model_name: str):
-    """
-    Args:
-        model: BertModel Pytorch model instance to be converted
-        ckpt_dir: Tensorflow model directory
-        model_name: model name
-
-    Currently supported HF models:
-
-        - Y BertModel
-        - N BertForMaskedLM
-        - N BertForPreTraining
-        - N BertForMultipleChoice
-        - N BertForNextSentencePrediction
-        - N BertForSequenceClassification
-        - N BertForQuestionAnswering
-    """
-
-    tensors_to_transpose = ("dense.weight", "attention.self.query", "attention.self.key", "attention.self.value")
-
-    var_map = (
-        ("layer.", "layer_"),
-        ("word_embeddings.weight", "word_embeddings"),
-        ("position_embeddings.weight", "position_embeddings"),
-        ("token_type_embeddings.weight", "token_type_embeddings"),
-        (".", "/"),
-        ("LayerNorm/weight", "LayerNorm/gamma"),
-        ("LayerNorm/bias", "LayerNorm/beta"),
-        ("weight", "kernel"),
-    )
-
-    if not os.path.isdir(ckpt_dir):
-        os.makedirs(ckpt_dir)
-
-    state_dict = model.state_dict()
-
-    def to_tf_var_name(name: str):
-        for patt, repl in iter(var_map):
-            name = name.replace(patt, repl)
-        return f"bert/{name}"
-
-    def create_tf_var(tensor: np.ndarray, name: str, session: tf.Session):
-        tf_dtype = tf.dtypes.as_dtype(tensor.dtype)
-        tf_var = tf.get_variable(dtype=tf_dtype, shape=tensor.shape, name=name, initializer=tf.zeros_initializer())
-        session.run(tf.variables_initializer([tf_var]))
-        session.run(tf_var)
-        return tf_var
-
-    tf.reset_default_graph()
-    with tf.Session() as session:
-        for var_name in state_dict:
-            tf_name = to_tf_var_name(var_name)
-            torch_tensor = state_dict[var_name].numpy()
-            if any(x in var_name for x in tensors_to_transpose):
-                torch_tensor = torch_tensor.T
-            tf_var = create_tf_var(tensor=torch_tensor, name=tf_name, session=session)
-            tf_var.assign(tf.cast(torch_tensor, tf_var.dtype))
-            tf_weight = session.run(tf_var)
-            print(f"Successfully created {tf_name}: {np.allclose(tf_weight, torch_tensor)}")
-
-        saver = tf.train.Saver(tf.trainable_variables())
-        saver.save(session, os.path.join(ckpt_dir, model_name.replace("-", "_") + ".ckpt"))
-
-
-def main(raw_args=None):
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model_name", type=str, required=True, help="model name e.g. google-bert/bert-base-uncased")
-    parser.add_argument(
-        "--cache_dir", type=str, default=None, required=False, help="Directory containing pytorch model"
-    )
-    parser.add_argument("--pytorch_model_path", type=str, required=True, help="/path/to/<pytorch-model-name>.bin")
-    parser.add_argument("--tf_cache_dir", type=str, required=True, help="Directory in which to save tensorflow model")
-    args = parser.parse_args(raw_args)
-
-    model = BertModel.from_pretrained(
-        pretrained_model_name_or_path=args.model_name,
-        state_dict=torch.load(args.pytorch_model_path),
-        cache_dir=args.cache_dir,
-    )
-
-    convert_pytorch_checkpoint_to_tf(model=model, ckpt_dir=args.tf_cache_dir, model_name=args.model_name)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/bert/convert_bert_token_dropping_original_tf2_checkpoint_to_pytorch.py b/src/transformers/models/bert/convert_bert_token_dropping_original_tf2_checkpoint_to_pytorch.py
deleted file mode 100644
index cba1e1a2c3f7..000000000000
--- a/src/transformers/models/bert/convert_bert_token_dropping_original_tf2_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,188 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-This script converts a lm-head checkpoint from the "Token Dropping" implementation into a PyTorch-compatible BERT
-model. The official implementation of "Token Dropping" can be found in the TensorFlow Models repository:
-
-https://github.com/tensorflow/models/tree/master/official/projects/token_dropping
-"""
-
-import argparse
-
-import tensorflow as tf
-import torch
-
-from transformers import BertConfig, BertForMaskedLM
-from transformers.models.bert.modeling_bert import (
-    BertIntermediate,
-    BertLayer,
-    BertOutput,
-    BertPooler,
-    BertSelfAttention,
-    BertSelfOutput,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_checkpoint_to_pytorch(tf_checkpoint_path: str, config_path: str, pytorch_dump_path: str):
-    def get_masked_lm_array(name: str):
-        full_name = f"masked_lm/{name}/.ATTRIBUTES/VARIABLE_VALUE"
-        array = tf.train.load_variable(tf_checkpoint_path, full_name)
-
-        if "kernel" in name:
-            array = array.transpose()
-
-        return torch.from_numpy(array)
-
-    def get_encoder_array(name: str):
-        full_name = f"encoder/{name}/.ATTRIBUTES/VARIABLE_VALUE"
-        array = tf.train.load_variable(tf_checkpoint_path, full_name)
-
-        if "kernel" in name:
-            array = array.transpose()
-
-        return torch.from_numpy(array)
-
-    def get_encoder_layer_array(layer_index: int, name: str):
-        full_name = f"encoder/_transformer_layers/{layer_index}/{name}/.ATTRIBUTES/VARIABLE_VALUE"
-        array = tf.train.load_variable(tf_checkpoint_path, full_name)
-
-        if "kernel" in name:
-            array = array.transpose()
-
-        return torch.from_numpy(array)
-
-    def get_encoder_attention_layer_array(layer_index: int, name: str, orginal_shape):
-        full_name = f"encoder/_transformer_layers/{layer_index}/_attention_layer/{name}/.ATTRIBUTES/VARIABLE_VALUE"
-        array = tf.train.load_variable(tf_checkpoint_path, full_name)
-        array = array.reshape(orginal_shape)
-
-        if "kernel" in name:
-            array = array.transpose()
-
-        return torch.from_numpy(array)
-
-    print(f"Loading model based on config from {config_path}...")
-    config = BertConfig.from_json_file(config_path)
-    model = BertForMaskedLM(config)
-
-    # Layers
-    for layer_index in range(0, config.num_hidden_layers):
-        layer: BertLayer = model.bert.encoder.layer[layer_index]
-
-        # Self-attention
-        self_attn: BertSelfAttention = layer.attention.self
-
-        self_attn.query.weight.data = get_encoder_attention_layer_array(
-            layer_index, "_query_dense/kernel", self_attn.query.weight.data.shape
-        )
-        self_attn.query.bias.data = get_encoder_attention_layer_array(
-            layer_index, "_query_dense/bias", self_attn.query.bias.data.shape
-        )
-        self_attn.key.weight.data = get_encoder_attention_layer_array(
-            layer_index, "_key_dense/kernel", self_attn.key.weight.data.shape
-        )
-        self_attn.key.bias.data = get_encoder_attention_layer_array(
-            layer_index, "_key_dense/bias", self_attn.key.bias.data.shape
-        )
-        self_attn.value.weight.data = get_encoder_attention_layer_array(
-            layer_index, "_value_dense/kernel", self_attn.value.weight.data.shape
-        )
-        self_attn.value.bias.data = get_encoder_attention_layer_array(
-            layer_index, "_value_dense/bias", self_attn.value.bias.data.shape
-        )
-
-        # Self-attention Output
-        self_output: BertSelfOutput = layer.attention.output
-
-        self_output.dense.weight.data = get_encoder_attention_layer_array(
-            layer_index, "_output_dense/kernel", self_output.dense.weight.data.shape
-        )
-        self_output.dense.bias.data = get_encoder_attention_layer_array(
-            layer_index, "_output_dense/bias", self_output.dense.bias.data.shape
-        )
-
-        self_output.LayerNorm.weight.data = get_encoder_layer_array(layer_index, "_attention_layer_norm/gamma")
-        self_output.LayerNorm.bias.data = get_encoder_layer_array(layer_index, "_attention_layer_norm/beta")
-
-        # Intermediate
-        intermediate: BertIntermediate = layer.intermediate
-
-        intermediate.dense.weight.data = get_encoder_layer_array(layer_index, "_intermediate_dense/kernel")
-        intermediate.dense.bias.data = get_encoder_layer_array(layer_index, "_intermediate_dense/bias")
-
-        # Output
-        bert_output: BertOutput = layer.output
-
-        bert_output.dense.weight.data = get_encoder_layer_array(layer_index, "_output_dense/kernel")
-        bert_output.dense.bias.data = get_encoder_layer_array(layer_index, "_output_dense/bias")
-
-        bert_output.LayerNorm.weight.data = get_encoder_layer_array(layer_index, "_output_layer_norm/gamma")
-        bert_output.LayerNorm.bias.data = get_encoder_layer_array(layer_index, "_output_layer_norm/beta")
-
-    # Embeddings
-    model.bert.embeddings.position_embeddings.weight.data = get_encoder_array("_position_embedding_layer/embeddings")
-    model.bert.embeddings.token_type_embeddings.weight.data = get_encoder_array("_type_embedding_layer/embeddings")
-    model.bert.embeddings.LayerNorm.weight.data = get_encoder_array("_embedding_norm_layer/gamma")
-    model.bert.embeddings.LayerNorm.bias.data = get_encoder_array("_embedding_norm_layer/beta")
-
-    # LM Head
-    lm_head = model.cls.predictions.transform
-
-    lm_head.dense.weight.data = get_masked_lm_array("dense/kernel")
-    lm_head.dense.bias.data = get_masked_lm_array("dense/bias")
-
-    lm_head.LayerNorm.weight.data = get_masked_lm_array("layer_norm/gamma")
-    lm_head.LayerNorm.bias.data = get_masked_lm_array("layer_norm/beta")
-
-    model.bert.embeddings.word_embeddings.weight.data = get_masked_lm_array("embedding_table")
-
-    # Pooling
-    model.bert.pooler = BertPooler(config=config)
-    model.bert.pooler.dense.weight.data: BertPooler = get_encoder_array("_pooler_layer/kernel")
-    model.bert.pooler.dense.bias.data: BertPooler = get_encoder_array("_pooler_layer/bias")
-
-    # Export final model
-    model.save_pretrained(pytorch_dump_path)
-
-    # Integration test - should load without any errors ;)
-    new_model = BertForMaskedLM.from_pretrained(pytorch_dump_path)
-    print(new_model.eval())
-
-    print("Model conversion was done sucessfully!")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--tf_checkpoint_path", type=str, required=True, help="Path to the TensorFlow Token Dropping checkpoint path."
-    )
-    parser.add_argument(
-        "--bert_config_file",
-        type=str,
-        required=True,
-        help="The config json file corresponding to the BERT model. This specifies the model architecture.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path",
-        type=str,
-        required=True,
-        help="Path to the output PyTorch model.",
-    )
-    args = parser.parse_args()
-    convert_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/big_bird/convert_bigbird_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/big_bird/convert_bigbird_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index 0b8e6590f937..000000000000
--- a/src/transformers/models/big_bird/convert_bigbird_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert BigBird checkpoint."""
-
-import argparse
-
-from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, big_bird_config_file, pytorch_dump_path, is_trivia_qa):
-    # Initialise PyTorch model
-    config = BigBirdConfig.from_json_file(big_bird_config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-
-    if is_trivia_qa:
-        model = BigBirdForQuestionAnswering(config)
-    else:
-        model = BigBirdForPreTraining(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_big_bird(model, tf_checkpoint_path, is_trivia_qa=is_trivia_qa)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--big_bird_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained BERT model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--is_trivia_qa", action="store_true", help="Whether to convert a model with a trivia_qa head."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(
-        args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa
-    )
diff --git a/src/transformers/models/bigbird_pegasus/convert_bigbird_pegasus_tf_to_pytorch.py b/src/transformers/models/bigbird_pegasus/convert_bigbird_pegasus_tf_to_pytorch.py
deleted file mode 100644
index e17369e48041..000000000000
--- a/src/transformers/models/bigbird_pegasus/convert_bigbird_pegasus_tf_to_pytorch.py
+++ /dev/null
@@ -1,170 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-from typing import Dict
-
-import tensorflow as tf
-import torch
-from tqdm import tqdm
-
-from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration
-
-
-INIT_COMMON = [
-    # tf -> hf
-    ("/", "."),
-    ("layer_", "layers."),
-    ("kernel", "weight"),
-    ("beta", "bias"),
-    ("gamma", "weight"),
-    ("pegasus", "model"),
-]
-END_COMMON = [
-    (".output.dense", ".fc2"),
-    ("intermediate.LayerNorm", "final_layer_norm"),
-    ("intermediate.dense", "fc1"),
-]
-
-DECODER_PATTERNS = (
-    INIT_COMMON
-    + [
-        ("attention.self.LayerNorm", "self_attn_layer_norm"),
-        ("attention.output.dense", "self_attn.out_proj"),
-        ("attention.self", "self_attn"),
-        ("attention.encdec.LayerNorm", "encoder_attn_layer_norm"),
-        ("attention.encdec_output.dense", "encoder_attn.out_proj"),
-        ("attention.encdec", "encoder_attn"),
-        ("key", "k_proj"),
-        ("value", "v_proj"),
-        ("query", "q_proj"),
-        ("decoder.LayerNorm", "decoder.layernorm_embedding"),
-    ]
-    + END_COMMON
-)
-
-REMAINING_PATTERNS = (
-    INIT_COMMON
-    + [
-        ("embeddings.word_embeddings", "shared.weight"),
-        ("embeddings.position_embeddings", "embed_positions.weight"),
-        ("attention.self.LayerNorm", "self_attn_layer_norm"),
-        ("attention.output.dense", "self_attn.output"),
-        ("attention.self", "self_attn.self"),
-        ("encoder.LayerNorm", "encoder.layernorm_embedding"),
-    ]
-    + END_COMMON
-)
-
-KEYS_TO_IGNORE = [
-    "encdec/key/bias",
-    "encdec/query/bias",
-    "encdec/value/bias",
-    "self/key/bias",
-    "self/query/bias",
-    "self/value/bias",
-    "encdec_output/dense/bias",
-    "attention/output/dense/bias",
-]
-
-
-def rename_state_dict_key(k, patterns):
-    for tf_name, hf_name in patterns:
-        k = k.replace(tf_name, hf_name)
-    return k
-
-
-def convert_bigbird_pegasus(tf_weights: dict, config_update: dict) -> BigBirdPegasusForConditionalGeneration:
-    cfg = BigBirdPegasusConfig(**config_update)
-    torch_model = BigBirdPegasusForConditionalGeneration(cfg)
-    state_dict = torch_model.state_dict()
-    mapping = {}
-
-    # separating decoder weights
-    decoder_weights = {k: tf_weights[k] for k in tf_weights if k.startswith("pegasus/decoder")}
-    remaining_weights = {k: tf_weights[k] for k in tf_weights if not k.startswith("pegasus/decoder")}
-
-    for k, v in tqdm(decoder_weights.items(), "tf -> hf conversion"):
-        conditions = [k.endswith(ending) for ending in KEYS_TO_IGNORE]
-        if any(conditions):
-            continue
-        patterns = DECODER_PATTERNS
-        new_k = rename_state_dict_key(k, patterns)
-        if new_k not in state_dict:
-            raise ValueError(f"could not find new key {new_k} in state dict. (converted from {k})")
-        if any(True if i in k else False for i in ["dense", "query", "key", "value"]):
-            v = v.T
-        mapping[new_k] = torch.from_numpy(v)
-        assert v.shape == state_dict[new_k].shape, f"{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}"
-
-    for k, v in tqdm(remaining_weights.items(), "tf -> hf conversion"):
-        conditions = [k.endswith(ending) for ending in KEYS_TO_IGNORE]
-        if any(conditions):
-            continue
-        patterns = REMAINING_PATTERNS
-        new_k = rename_state_dict_key(k, patterns)
-        if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings":
-            raise ValueError(f"could not find new key {new_k} in state dict. (converted from {k})")
-        if any(True if i in k else False for i in ["dense", "query", "key", "value"]):
-            v = v.T
-        mapping[new_k] = torch.from_numpy(v)
-        if k != "pegasus/embeddings/position_embeddings":
-            assert v.shape == state_dict[new_k].shape, f"{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}"
-
-    mapping["model.encoder.embed_positions.weight"] = mapping["model.embed_positions.weight"]
-    mapping["model.decoder.embed_positions.weight"] = mapping.pop("model.embed_positions.weight")
-    missing, extra = torch_model.load_state_dict(mapping, strict=False)
-    unexpected_missing = [
-        k
-        for k in missing
-        if k
-        not in [
-            "final_logits_bias",
-            "model.encoder.embed_tokens.weight",
-            "model.decoder.embed_tokens.weight",
-            "lm_head.weight",
-        ]
-    ]
-    assert unexpected_missing == [], f"no matches found for the following torch keys {unexpected_missing}"
-    assert extra == [], f"no matches found for the following tf keys {extra}"
-    return torch_model
-
-
-def get_tf_weights_as_numpy(path) -> Dict:
-    init_vars = tf.train.list_variables(path)
-    tf_weights = {}
-    ignore_name = ["global_step"]
-    for name, shape in tqdm(init_vars, desc="converting tf checkpoint to dict"):
-        skip_key = any(pat in name for pat in ignore_name)
-        if skip_key:
-            continue
-        array = tf.train.load_variable(path, name)
-        tf_weights[name] = array
-    return tf_weights
-
-
-def convert_bigbird_pegasus_ckpt_to_pytorch(ckpt_path: str, save_dir: str, config_update: dict):
-    tf_weights = get_tf_weights_as_numpy(ckpt_path)
-    torch_model = convert_bigbird_pegasus(tf_weights, config_update)
-    torch_model.save_pretrained(save_dir)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--tf_ckpt_path", type=str, help="passed to tf.train.list_variables")
-    parser.add_argument("--save_dir", default=None, type=str, help="Path to the output PyTorch model.")
-    args = parser.parse_args()
-    config_update = {}
-    convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)
diff --git a/src/transformers/models/biogpt/convert_biogpt_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/biogpt/convert_biogpt_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100755
index c930a850462c..000000000000
--- a/src/transformers/models/biogpt/convert_biogpt_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,292 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import argparse
-import json
-import os
-import re
-import shutil
-
-import torch
-
-from transformers import BioGptConfig, BioGptForCausalLM
-from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES
-from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE
-from transformers.utils import WEIGHTS_NAME, logging
-
-
-logging.set_verbosity_warning()
-
-json_indent = 2
-
-
-# modified from https://github.com/facebookresearch/fairseq/blob/dd74992d0d143155998e9ed4076826bcea80fb06/fairseq/data/dictionary.py#L18
-class Dictionary:
-    """A mapping from symbols to consecutive integers"""
-
-    def __init__(
-        self,
-        *,  # begin keyword-only arguments
-        bos="<s>",
-        pad="<pad>",
-        eos="</s>",
-        unk="<unk>",
-        extra_special_symbols=None,
-    ):
-        self.bos_word, self.unk_word, self.pad_word, self.eos_word = bos, unk, pad, eos
-        self.symbols = []
-        self.count = []
-        self.indices = {}
-        self.bos_index = self.add_symbol(bos)
-        self.pad_index = self.add_symbol(pad)
-        self.eos_index = self.add_symbol(eos)
-        self.unk_index = self.add_symbol(unk)
-        if extra_special_symbols:
-            for s in extra_special_symbols:
-                self.add_symbol(s)
-        self.nspecial = len(self.symbols)
-
-    def __eq__(self, other):
-        return self.indices == other.indices
-
-    def __getitem__(self, idx):
-        if idx < len(self.symbols):
-            return self.symbols[idx]
-        return self.unk_word
-
-    def __len__(self):
-        """Returns the number of symbols in the dictionary"""
-        return len(self.symbols)
-
-    def __contains__(self, sym):
-        return sym in self.indices
-
-    @classmethod
-    def load(cls, f):
-        """Loads the dictionary from a text file with the format:
-
-        ```
-        <symbol0> <count0>
-        <symbol1> <count1>
-        ...
-        ```
-        """
-        d = cls()
-        d.add_from_file(f)
-        return d
-
-    def add_symbol(self, word, n=1, overwrite=False):
-        """Adds a word to the dictionary"""
-        if word in self.indices and not overwrite:
-            idx = self.indices[word]
-            self.count[idx] = self.count[idx] + n
-            return idx
-        else:
-            idx = len(self.symbols)
-            self.indices[word] = idx
-            self.symbols.append(word)
-            self.count.append(n)
-            return idx
-
-    def _load_meta(self, lines):
-        return 0
-
-    def add_from_file(self, f):
-        """
-        Loads a pre-existing dictionary from a text file and adds its symbols to this instance.
-        """
-        if isinstance(f, str):
-            try:
-                with open(f, "r", encoding="utf-8") as fd:
-                    self.add_from_file(fd)
-            except FileNotFoundError as fnfe:
-                raise fnfe
-            except UnicodeError:
-                raise Exception("Incorrect encoding detected in {}, please rebuild the dataset".format(f))
-            return
-
-        lines = f.readlines()
-        indices_start_line = self._load_meta(lines)
-
-        for line in lines[indices_start_line:]:
-            try:
-                line, field = line.rstrip().rsplit(" ", 1)
-                if field == "#fairseq:overwrite":
-                    overwrite = True
-                    line, field = line.rsplit(" ", 1)
-                else:
-                    overwrite = False
-                count = int(field)
-                word = line
-                if word in self and not overwrite:
-                    raise RuntimeError(
-                        "Duplicate word found when loading Dictionary: '{}'. "
-                        "Duplicate words can overwrite earlier ones by adding the "
-                        "#fairseq:overwrite flag at the end of the corresponding row "
-                        "in the dictionary file. If using the Camembert model, please "
-                        "download an updated copy of the model file.".format(word)
-                    )
-                self.add_symbol(word, n=count, overwrite=overwrite)
-            except ValueError:
-                raise ValueError("Incorrect dictionary format, expected '<token> <cnt> [flags]'")
-
-
-def rewrite_dict_keys(d):
-    # (1) remove word breaking symbol, (2) add word ending symbol where the word is not broken up,
-    # e.g.: d = {'le@@': 5, 'tt@@': 6, 'er': 7} => {'le': 5, 'tt': 6, 'er</w>': 7}
-    d2 = dict((re.sub(r"@@$", "", k), v) if k.endswith("@@") else (re.sub(r"$", "</w>", k), v) for k, v in d.items())
-    keep_keys = "<s> <pad> </s> <unk>".split()
-    # restore the special tokens
-    for k in keep_keys:
-        del d2[f"{k}</w>"]
-        d2[k] = d[k]  # restore
-    return d2
-
-
-def convert_biogpt_checkpoint_to_pytorch(biogpt_checkpoint_path, pytorch_dump_folder_path):
-    # prep
-    if not os.path.exists(biogpt_checkpoint_path):
-        raise ValueError(f"path {biogpt_checkpoint_path} does not exist!")
-    os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-    print(f"Writing results to {pytorch_dump_folder_path}")
-
-    # handle various types of models
-
-    checkpoint_file = os.path.join(biogpt_checkpoint_path, "checkpoint.pt")
-    if not os.path.isfile(checkpoint_file):
-        raise ValueError(f"path to the file {checkpoint_file} does not exist!")
-    chkpt = torch.load(checkpoint_file, map_location="cpu")
-
-    args = chkpt["cfg"]["model"]
-
-    # dicts
-    dict_file = os.path.join(biogpt_checkpoint_path, "dict.txt")
-    if not os.path.isfile(dict_file):
-        raise ValueError(f"path to the file {dict_file} does not exist!")
-    src_dict = Dictionary.load(dict_file)
-    src_vocab = rewrite_dict_keys(src_dict.indices)
-    src_vocab_size = len(src_vocab)
-    src_vocab_file = os.path.join(pytorch_dump_folder_path, VOCAB_FILES_NAMES["vocab_file"])
-    print(f"Generating {src_vocab_file} of {src_vocab_size} records")
-    with open(src_vocab_file, "w", encoding="utf-8") as f:
-        f.write(json.dumps(src_vocab, ensure_ascii=False, indent=json_indent))
-
-    # merges_file (bpecodes)
-    bpecodes_file = os.path.join(biogpt_checkpoint_path, "bpecodes")
-    if not os.path.isfile(bpecodes_file):
-        raise ValueError(f"path to the file {bpecodes_file} does not exist!")
-
-    merges_file = os.path.join(pytorch_dump_folder_path, VOCAB_FILES_NAMES["merges_file"])
-    shutil.copyfile(bpecodes_file, merges_file)
-
-    # model config
-    biogpt_model_config_file = os.path.join(pytorch_dump_folder_path, "config.json")
-
-    model_conf = {
-        "activation_dropout": args["activation_dropout"],
-        "architectures": ["BioGptForCausalLM"],
-        "attention_probs_dropout_prob": args["attention_dropout"],
-        "bos_token_id": 0,
-        "eos_token_id": 2,
-        "hidden_act": args["activation_fn"],
-        "hidden_dropout_prob": args["dropout"],
-        "hidden_size": args["decoder_embed_dim"],
-        "initializer_range": 0.02,
-        "intermediate_size": args["decoder_ffn_embed_dim"],
-        "layer_norm_eps": 1e-12,
-        "layerdrop": args["decoder_layerdrop"],
-        "max_position_embeddings": args["max_target_positions"],
-        "model_type": "biogpt",
-        "num_attention_heads": args["decoder_attention_heads"],
-        "num_hidden_layers": args["decoder_layers"],
-        "pad_token_id": 1,
-        "scale_embedding": not args["no_scale_embedding"],
-        "tie_word_embeddings": args["share_decoder_input_output_embed"],
-        "vocab_size": src_vocab_size,
-    }
-
-    # good hparam defaults to start with
-
-    print(f"Generating {biogpt_model_config_file}")
-    with open(biogpt_model_config_file, "w", encoding="utf-8") as f:
-        f.write(json.dumps(model_conf, ensure_ascii=False, indent=json_indent))
-
-    # tokenizer config
-    biogpt_tokenizer_config_file = os.path.join(pytorch_dump_folder_path, TOKENIZER_CONFIG_FILE)
-
-    tokenizer_conf = {
-        "bos_token": "<s>",
-        "eos_token": "</s>",
-        "model_max_length": 1024,
-        "pad_token": "<pad>",
-        "special_tokens_map_file": None,
-        "tokenizer_class": "BioGptTokenizer",
-        "unk_token": "<unk>",
-    }
-
-    print(f"Generating {biogpt_tokenizer_config_file}")
-    with open(biogpt_tokenizer_config_file, "w", encoding="utf-8") as f:
-        f.write(json.dumps(tokenizer_conf, ensure_ascii=False, indent=json_indent))
-
-    # model
-    model_state_dict = chkpt["model"]
-
-    # remove unneeded keys
-    ignore_keys = [
-        "decoder.version",
-    ]
-    for k in ignore_keys:
-        model_state_dict.pop(k, None)
-
-    layer_names = list(model_state_dict.keys())
-    for layer_name in layer_names:
-        if layer_name.endswith("output_projection.weight"):
-            model_state_dict[layer_name.replace("decoder.", "")] = model_state_dict.pop(layer_name)
-        else:
-            model_state_dict[layer_name.replace("decoder", "biogpt")] = model_state_dict.pop(layer_name)
-
-    config = BioGptConfig.from_pretrained(pytorch_dump_folder_path)
-    model_new = BioGptForCausalLM(config)
-
-    # check that it loads ok
-    model_new.load_state_dict(model_state_dict)
-
-    # save
-    pytorch_weights_dump_path = os.path.join(pytorch_dump_folder_path, WEIGHTS_NAME)
-    print(f"Generating {pytorch_weights_dump_path}")
-    torch.save(model_state_dict, pytorch_weights_dump_path)
-
-    print("Conversion is done!")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--biogpt_checkpoint_path",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts,"
-            " bpecodes, etc."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_biogpt_checkpoint_to_pytorch(args.biogpt_checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/bit/convert_bit_to_pytorch.py b/src/transformers/models/bit/convert_bit_to_pytorch.py
deleted file mode 100644
index abc24290ab26..000000000000
--- a/src/transformers/models/bit/convert_bit_to_pytorch.py
+++ /dev/null
@@ -1,177 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert BiT checkpoints from the timm library."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from timm import create_model
-from timm.data import resolve_data_config
-from timm.data.transforms_factory import create_transform
-
-from transformers import BitConfig, BitForImageClassification, BitImageProcessor
-from transformers.image_utils import PILImageResampling
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_config(model_name):
-    repo_id = "huggingface/label-files"
-    filename = "imagenet-1k-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    label2id = {v: k for k, v in id2label.items()}
-
-    conv_layer = "std_conv" if "bit" in model_name else False
-
-    # note that when using BiT as backbone for ViT-hybrid checkpoints,
-    # one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same",
-    # config.conv_layer = "std_conv_same"
-    config = BitConfig(
-        conv_layer=conv_layer,
-        num_labels=1000,
-        id2label=id2label,
-        label2id=label2id,
-    )
-
-    return config
-
-
-def rename_key(name):
-    if "stem.conv" in name:
-        name = name.replace("stem.conv", "bit.embedder.convolution")
-    if "blocks" in name:
-        name = name.replace("blocks", "layers")
-    if "head.fc" in name:
-        name = name.replace("head.fc", "classifier.1")
-    if name.startswith("norm"):
-        name = "bit." + name
-    if "bit" not in name and "classifier" not in name:
-        name = "bit.encoder." + name
-
-    return name
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_bit_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our BiT structure.
-    """
-
-    # define default BiT configuration
-    config = get_config(model_name)
-
-    # load original model from timm
-    timm_model = create_model(model_name, pretrained=True)
-    timm_model.eval()
-
-    # load state_dict of original model
-    state_dict = timm_model.state_dict()
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        state_dict[rename_key(key)] = val.squeeze() if "head" in key else val
-
-    # load HuggingFace model
-    model = BitForImageClassification(config)
-    model.eval()
-    model.load_state_dict(state_dict)
-
-    # create image processor
-    transform = create_transform(**resolve_data_config({}, model=timm_model))
-    timm_transforms = transform.transforms
-
-    pillow_resamplings = {
-        "bilinear": PILImageResampling.BILINEAR,
-        "bicubic": PILImageResampling.BICUBIC,
-        "nearest": PILImageResampling.NEAREST,
-    }
-
-    processor = BitImageProcessor(
-        do_resize=True,
-        size={"shortest_edge": timm_transforms[0].size},
-        resample=pillow_resamplings[timm_transforms[0].interpolation.value],
-        do_center_crop=True,
-        crop_size={"height": timm_transforms[1].size[0], "width": timm_transforms[1].size[1]},
-        do_normalize=True,
-        image_mean=timm_transforms[-1].mean.tolist(),
-        image_std=timm_transforms[-1].std.tolist(),
-    )
-
-    image = prepare_img()
-    timm_pixel_values = transform(image).unsqueeze(0)
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    # verify pixel values
-    assert torch.allclose(timm_pixel_values, pixel_values)
-
-    # verify logits
-    with torch.no_grad():
-        outputs = model(pixel_values)
-        logits = outputs.logits
-
-    print("Logits:", logits[0, :3])
-    print("Predicted class:", model.config.id2label[logits.argmax(-1).item()])
-    timm_logits = timm_model(pixel_values)
-    assert timm_logits.shape == outputs.logits.shape
-    assert torch.allclose(timm_logits, outputs.logits, atol=1e-3)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model {model_name} and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model {model_name} and processor to the hub")
-        model.push_to_hub(f"ybelkada/{model_name}")
-        processor.push_to_hub(f"ybelkada/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="resnetv2_50x1_bitm",
-        type=str,
-        help="Name of the BiT timm model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model to the hub.",
-    )
-
-    args = parser.parse_args()
-    convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/blenderbot/convert_blenderbot_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/blenderbot/convert_blenderbot_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index c5919b94d42f..000000000000
--- a/src/transformers/models/blenderbot/convert_blenderbot_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,114 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Blenderbot checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import BlenderbotConfig, BlenderbotForConditionalGeneration
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-PATTERNS = [
-    ["attention", "attn"],
-    ["encoder_attention", "encoder_attn"],
-    ["q_lin", "q_proj"],
-    ["k_lin", "k_proj"],
-    ["v_lin", "v_proj"],
-    ["out_lin", "out_proj"],
-    ["norm_embeddings", "layernorm_embedding"],
-    ["position_embeddings", "embed_positions"],
-    ["embeddings", "embed_tokens"],
-    ["ffn.lin", "fc"],
-]
-
-
-def rename_state_dict_key(k):
-    if k == "embeddings.weight":
-        return "shared.weight"
-
-    for parlai_name, hf_name in PATTERNS:
-        k = k.replace(parlai_name, hf_name)
-
-    if k.startswith("encoder"):
-        k = k.replace(".attn", ".self_attn")
-        k = k.replace("norm1", "self_attn_layer_norm")
-        k = k.replace("norm2", "final_layer_norm")
-    elif k.startswith("decoder"):
-        k = k.replace("norm1", "self_attn_layer_norm")
-        k = k.replace("norm2", "encoder_attn_layer_norm")
-        k = k.replace("norm3", "final_layer_norm")
-    return k
-
-
-def rename_layernorm_keys(sd):
-    keys = [
-        "model.encoder.layernorm_embedding.weight",
-        "model.encoder.layernorm_embedding.bias",
-        "model.decoder.layernorm_embedding.weight",
-        "model.decoder.layernorm_embedding.bias",
-    ]
-    for k in keys:
-        v = sd.pop(k)
-        new_k = k.replace("layernorm_embedding", "layer_norm")
-        assert new_k not in sd
-        sd[new_k] = v
-
-
-IGNORE_KEYS = ["START"]
-
-
-@torch.no_grad()
-def convert_parlai_checkpoint(checkpoint_path, pytorch_dump_folder_path, config_json_path):
-    """
-    Copy/paste/tweak model's weights to our BERT structure.
-    """
-    model = torch.load(checkpoint_path, map_location="cpu")
-    sd = model["model"]
-    cfg = BlenderbotConfig.from_json_file(config_json_path)
-    m = BlenderbotForConditionalGeneration(cfg)
-    valid_keys = m.model.state_dict().keys()
-    failures = []
-    mapping = {}
-    for k, v in sd.items():
-        if k in IGNORE_KEYS:
-            continue
-
-        new_k = rename_state_dict_key(k)
-        if new_k not in valid_keys:
-            failures.append([k, new_k])
-        else:
-            mapping[new_k] = v
-    if cfg.normalize_before:  # Blenderbot-3B checkpoints. Rename layernorm_embedding -> layer_norm
-        rename_layernorm_keys(sd)
-    m.model.load_state_dict(mapping, strict=True)
-    m.half()
-    m.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("--src_path", type=str, help="like blenderbot-model.bin")
-    parser.add_argument("--save_dir", default="hf_blenderbot", type=str, help="Where to save converted model.")
-    parser.add_argument(
-        "--hf_config_json", default="blenderbot-3b-config.json", type=str, help="Path to config to use"
-    )
-    args = parser.parse_args()
-    convert_parlai_checkpoint(args.src_path, args.save_dir, args.hf_config_json)
diff --git a/src/transformers/models/blip/convert_blip_original_pytorch_to_hf.py b/src/transformers/models/blip/convert_blip_original_pytorch_to_hf.py
deleted file mode 100644
index 3de18c294ae8..000000000000
--- a/src/transformers/models/blip/convert_blip_original_pytorch_to_hf.py
+++ /dev/null
@@ -1,191 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import re
-
-import requests
-import torch
-
-# git clone https://github.com/salesforce/BLIP.git
-from models.blip import blip_decoder
-from models.blip_itm import blip_itm
-from models.blip_vqa import blip_vqa
-from PIL import Image
-from torchvision import transforms
-from torchvision.transforms.functional import InterpolationMode
-
-from transformers import (
-    BertTokenizer,
-    BlipConfig,
-    BlipForConditionalGeneration,
-    BlipForImageTextRetrieval,
-    BlipForQuestionAnswering,
-)
-
-
-def load_demo_image(image_size, device):
-    img_url = "https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg"
-    raw_image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB")
-
-    transform = transforms.Compose(
-        [
-            transforms.Resize((image_size, image_size), interpolation=InterpolationMode.BICUBIC),
-            transforms.ToTensor(),
-            transforms.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),
-        ]
-    )
-    image = transform(raw_image).unsqueeze(0).to(device)
-    return image
-
-
-def rename_key(key):
-    if "visual_encoder" in key:
-        key = re.sub("visual_encoder*", "vision_model.encoder", key)
-    if "blocks" in key:
-        key = re.sub(r"blocks", "layers", key)
-    if "attn" in key:
-        key = re.sub(r"attn", "self_attn", key)
-    if "norm1" in key:
-        key = re.sub(r"norm1", "layer_norm1", key)
-    if "norm2" in key:
-        key = re.sub(r"norm2", "layer_norm2", key)
-    if "encoder.norm" in key:
-        key = re.sub(r"encoder.norm", "post_layernorm", key)
-    if "encoder.patch_embed.proj" in key:
-        key = re.sub(r"encoder.patch_embed.proj", "embeddings.patch_embedding", key)
-
-    if "encoder.pos_embed" in key:
-        key = re.sub(r"encoder.pos_embed", "embeddings.position_embedding", key)
-    if "encoder.cls_token" in key:
-        key = re.sub(r"encoder.cls_token", "embeddings.class_embedding", key)
-
-    if "self_attn" in key:
-        key = re.sub(r"self_attn.proj", "self_attn.projection", key)
-
-    return key
-
-
-@torch.no_grad()
-def convert_blip_checkpoint(pytorch_dump_folder_path, config_path=None):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = BlipConfig.from_pretrained(config_path)
-    else:
-        config = BlipConfig(projection_dim=512, text_config={}, vision_config={})
-
-    hf_model = BlipForConditionalGeneration(config).eval()
-
-    model_url = "https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_capfilt_large.pth"
-
-    pt_model = blip_decoder(pretrained=model_url, image_size=384, vit="base")
-    pt_model = pt_model.eval()
-
-    modified_state_dict = pt_model.state_dict()
-    for key in modified_state_dict.copy():
-        value = modified_state_dict.pop(key)
-        renamed_key = rename_key(key)
-        modified_state_dict[renamed_key] = value
-
-    hf_model.load_state_dict(modified_state_dict)
-
-    image_size = 384
-    image = load_demo_image(image_size=image_size, device="cpu")
-    tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
-    input_ids = tokenizer(["a picture of"]).input_ids
-
-    out = hf_model.generate(image, input_ids)
-
-    assert out[0].tolist() == [30522, 1037, 3861, 1997, 1037, 2450, 3564, 2006, 1996, 3509, 2007, 2014, 3899, 102]
-
-    out = hf_model.generate(image)
-
-    assert out[0].tolist() == [30522, 1037, 2450, 3564, 2006, 1996, 3509, 2007, 2014, 3899, 102]
-
-    if pytorch_dump_folder_path is not None:
-        hf_model.save_pretrained(pytorch_dump_folder_path)
-
-    # model_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_vqa.pth'
-    model_url = (
-        "https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_vqa_capfilt_large.pth"
-    )
-
-    vqa_model = blip_vqa(pretrained=model_url, image_size=image_size, vit="base")
-    vqa_model.eval()
-
-    modified_state_dict = vqa_model.state_dict()
-    for key in modified_state_dict.copy():
-        value = modified_state_dict.pop(key)
-        renamed_key = rename_key(key)
-        modified_state_dict[renamed_key] = value
-
-    hf_vqa_model = BlipForQuestionAnswering(config)
-
-    hf_vqa_model.load_state_dict(modified_state_dict)
-
-    question = ["How many dogs are in this image?"]
-    question_input_ids = tokenizer(question, return_tensors="pt").input_ids
-
-    answer = hf_vqa_model.generate(question_input_ids, image)
-    print(tokenizer.decode(answer[0]))
-
-    assert tokenizer.decode(answer[0]) == "[UNK] 1 [SEP]"
-    if pytorch_dump_folder_path is not None:
-        hf_vqa_model.save_pretrained(pytorch_dump_folder_path + "_vqa")
-
-    model_url = "https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_retrieval_coco.pth"
-
-    itm_model = blip_itm(pretrained=model_url, image_size=image_size, vit="base")
-    itm_model.eval()
-
-    modified_state_dict = itm_model.state_dict()
-    for key in modified_state_dict.copy():
-        value = modified_state_dict.pop(key)
-        renamed_key = rename_key(key)
-        modified_state_dict[renamed_key] = value
-
-    hf_itm_model = BlipForImageTextRetrieval(config)
-
-    question = ["A picture of a woman with a dog sitting in a beach"]
-    question_input_ids = tokenizer(
-        question,
-        return_tensors="pt",
-        padding="max_length",
-        truncation=True,
-        max_length=35,
-    ).input_ids
-
-    hf_itm_model.load_state_dict(modified_state_dict)
-    hf_itm_model.eval()
-
-    out_itm = hf_itm_model(question_input_ids, image, use_itm_head=True)
-    out = hf_itm_model(question_input_ids, image, use_itm_head=False)
-
-    assert out[0].item() == 0.2110687494277954
-    assert torch.nn.functional.softmax(out_itm[0], dim=1)[:, 1].item() == 0.45698845386505127
-
-    if pytorch_dump_folder_path is not None:
-        hf_itm_model.save_pretrained(pytorch_dump_folder_path + "_itm")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    args = parser.parse_args()
-
-    convert_blip_checkpoint(args.pytorch_dump_folder_path, args.config_path)
diff --git a/src/transformers/models/blip_2/convert_blip_2_original_to_pytorch.py b/src/transformers/models/blip_2/convert_blip_2_original_to_pytorch.py
deleted file mode 100644
index d6640045b80c..000000000000
--- a/src/transformers/models/blip_2/convert_blip_2_original_to_pytorch.py
+++ /dev/null
@@ -1,390 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Convert BLIP-2 checkpoints from the original repository.
-
-URL: https://github.com/salesforce/LAVIS/tree/main/projects/blip2
-"""
-
-import argparse
-
-import requests
-import torch
-
-# pip3 install salesforce-lavis
-# I'm actually installing a slightly modified version: pip3 install -U git+https://github.com/nielsrogge/LAVIS.git@blip2_float32
-# to make sure we can compare both original and HF implementation in float32
-from lavis.models import load_model_and_preprocess
-from PIL import Image
-
-from transformers import (
-    AutoTokenizer,
-    BertTokenizer,
-    Blip2Config,
-    Blip2ForConditionalGeneration,
-    Blip2ForImageTextRetrieval,
-    Blip2Processor,
-    Blip2QFormerConfig,
-    Blip2VisionConfig,
-    BlipImageProcessor,
-    OPTConfig,
-    T5Config,
-    set_seed,
-)
-from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
-
-
-def load_demo_image():
-    url = "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-
-    return image
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, model_name):
-    rename_keys = []
-    # fmt: off
-
-    # vision encoder
-    rename_keys.append(("visual_encoder.cls_token", "vision_model.embeddings.class_embedding"))
-    rename_keys.append(("visual_encoder.pos_embed", "vision_model.embeddings.position_embedding"))
-    rename_keys.append(("visual_encoder.patch_embed.proj.weight", "vision_model.embeddings.patch_embedding.weight"))
-    rename_keys.append(("visual_encoder.patch_embed.proj.bias", "vision_model.embeddings.patch_embedding.bias"))
-    rename_keys.append(("ln_vision.weight", "vision_model.post_layernorm.weight"))
-    rename_keys.append(("ln_vision.bias", "vision_model.post_layernorm.bias"))
-
-    for i in range(config.vision_config.num_hidden_layers):
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm1.weight", f"vision_model.encoder.layers.{i}.layer_norm1.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm1.bias", f"vision_model.encoder.layers.{i}.layer_norm1.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm2.weight", f"vision_model.encoder.layers.{i}.layer_norm2.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm2.bias", f"vision_model.encoder.layers.{i}.layer_norm2.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.qkv.weight", f"vision_model.encoder.layers.{i}.self_attn.qkv.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.proj.weight", f"vision_model.encoder.layers.{i}.self_attn.projection.weight",))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.proj.bias", f"vision_model.encoder.layers.{i}.self_attn.projection.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc1.weight", f"vision_model.encoder.layers.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc1.bias", f"vision_model.encoder.layers.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc2.weight", f"vision_model.encoder.layers.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc2.bias", f"vision_model.encoder.layers.{i}.mlp.fc2.bias"))
-
-    # QFormer
-    rename_keys.append(("Qformer.bert.embeddings.LayerNorm.weight", "qformer.layernorm.weight"))
-    rename_keys.append(("Qformer.bert.embeddings.LayerNorm.bias", "qformer.layernorm.bias"))
-    if "itm" in model_name:
-        rename_keys.append(("Qformer.bert.embeddings.word_embeddings.weight", "embeddings.word_embeddings.weight"))
-        rename_keys.append(("Qformer.bert.embeddings.position_embeddings.weight", "embeddings.position_embeddings.weight"))
-        rename_keys.append(("vision_proj.weight", "vision_projection.weight"))
-        rename_keys.append(("vision_proj.bias", "vision_projection.bias"))
-        rename_keys.append(("text_proj.weight", "text_projection.weight"))
-        rename_keys.append(("text_proj.bias", "text_projection.bias"))
-
-    # fmt: on
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def read_in_q_v_bias(state_dict, config):
-    for i in range(config.vision_config.num_hidden_layers):
-        # read in original q and v biases
-        q_bias = state_dict.pop(f"visual_encoder.blocks.{i}.attn.q_bias")
-        v_bias = state_dict.pop(f"visual_encoder.blocks.{i}.attn.v_bias")
-
-        # next, set bias in the state dict
-        qkv_bias = torch.cat((q_bias, torch.zeros_like(v_bias, requires_grad=False), v_bias))
-        state_dict[f"vision_model.encoder.layers.{i}.self_attn.qkv.bias"] = qkv_bias
-
-
-def get_blip2_config(model_name, eos_token_id):
-    image_size = 364 if "coco" in model_name else 224
-    vision_config = Blip2VisionConfig(image_size=image_size).to_dict()
-
-    # make sure the models have proper bos_token_id and eos_token_id set (important for generation)
-    # seems like flan-T5 models don't have bos_token_id properly set?
-    if "opt-2.7b" in model_name:
-        text_config = OPTConfig.from_pretrained("facebook/opt-2.7b", eos_token_id=eos_token_id).to_dict()
-    elif "opt-6.7b" in model_name:
-        text_config = OPTConfig.from_pretrained("facebook/opt-6.7b", eos_token_id=eos_token_id).to_dict()
-    elif "t5-xl" in model_name:
-        text_config = T5Config.from_pretrained("google/flan-t5-xl", dense_act_fn="gelu", bos_token_id=1).to_dict()
-    elif "t5-xxl" in model_name:
-        text_config = T5Config.from_pretrained("google/flan-t5-xxl", dense_act_fn="gelu", bos_token_id=1).to_dict()
-    elif "itm" in model_name:
-        text_config = {}
-    else:
-        raise ValueError("Model name not supported")
-
-    if "itm" in model_name:
-        config = Blip2Config(
-            vision_config=vision_config,
-            qformer_config=Blip2QFormerConfig(vocab_size=30523, use_qformer_text_input=True).to_dict(),
-        )
-    else:
-        config = Blip2Config(vision_config=vision_config, text_config=text_config)
-
-    return config, image_size
-
-
-@torch.no_grad()
-def convert_blip2_checkpoint(
-    model_name, pytorch_dump_folder_path=None, push_to_hub=False, lavis_device="cpu", hf_model_device="cpu"
-):
-    """
-    Copy/paste/tweak model's weights to Transformers design.
-    """
-    if "opt" in model_name:
-        tokenizer = AutoTokenizer.from_pretrained("facebook/opt-2.7b")
-    elif "itm" in model_name:
-        tokenizer = BertTokenizer.from_pretrained("bert-base-uncased", truncation_side="right")
-        tokenizer.add_special_tokens({"bos_token": "[DEC]"})
-    else:
-        tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-xl")
-
-    if "itm" in model_name:
-        eos_token_id = None
-    else:
-        eos_token_id = tokenizer("\n", add_special_tokens=False).input_ids[0]
-    config, image_size = get_blip2_config(model_name, eos_token_id=eos_token_id)
-
-    if "itm" in model_name:
-        hf_model = Blip2ForImageTextRetrieval(config).eval()
-    else:
-        hf_model = Blip2ForConditionalGeneration(config).eval()
-
-    model_name_to_original = {
-        "blip2-opt-2.7b": ("blip2_opt", "pretrain_opt2.7b"),
-        "blip2-opt-6.7b": ("blip2_opt", "pretrain_opt6.7b"),
-        "blip2-opt-2.7b-coco": ("blip2_opt", "caption_coco_opt2.7b"),
-        "blip2-opt-6.7b-coco": ("blip2_opt", "caption_coco_opt6.7b"),
-        "blip2-flan-t5-xl": ("blip2_t5", "pretrain_flant5xl"),
-        "blip2-flan-t5-xl-coco": ("blip2_t5", "caption_coco_flant5xl"),
-        "blip2-flan-t5-xxl": ("blip2_t5", "pretrain_flant5xxl"),
-        "blip2-itm-vit-g": ("blip2_image_text_matching", "pretrain"),
-        "blip2-itm-vit-g-coco": ("blip2_image_text_matching", "coco"),
-    }
-
-    name, type = model_name_to_original[model_name]
-
-    # load original model
-    print("Loading original model...")
-    original_model, vis_processors, _ = load_model_and_preprocess(
-        name=name, model_type=type, is_eval=True, device=lavis_device
-    )
-    original_model.eval()
-    print("Done!")
-
-    # update state dict keys
-    state_dict = original_model.state_dict()
-    rename_keys = create_rename_keys(config, model_name)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-
-    # some keys can be renamed efficiently
-    for key, val in state_dict.copy().items():
-        val = state_dict.pop(key)
-        if key.startswith("Qformer.bert"):
-            key = key.replace("Qformer.bert", "qformer")
-        if "attention.self" in key:
-            key = key.replace("self", "attention")
-        if "opt_proj" in key:
-            key = key.replace("opt_proj", "language_projection")
-        if "t5_proj" in key:
-            key = key.replace("t5_proj", "language_projection")
-        if key.startswith("opt"):
-            key = key.replace("opt", "language")
-        if key.startswith("t5"):
-            key = key.replace("t5", "language")
-        state_dict[key] = val
-
-    # read in qv biases
-    read_in_q_v_bias(state_dict, config)
-
-    missing_keys, unexpected_keys = hf_model.load_state_dict(state_dict, strict=False)
-    assert len(missing_keys) == 0
-
-    if "itm" in model_name:
-        unexpected_keys = list(filter(lambda x: not x.startswith("Qformer.cls"), unexpected_keys))
-        assert unexpected_keys == ["temp", "qformer.embeddings.position_ids"]
-    else:
-        assert unexpected_keys == ["qformer.embeddings.position_ids"]
-
-    image = load_demo_image()
-    original_pixel_values = vis_processors["eval"](image).unsqueeze(0).to(lavis_device)
-
-    # create processor
-    image_processor = BlipImageProcessor(
-        size={"height": image_size, "width": image_size}, image_mean=OPENAI_CLIP_MEAN, image_std=OPENAI_CLIP_STD
-    )
-    processor = Blip2Processor(image_processor=image_processor, tokenizer=tokenizer)
-    pixel_values = processor(images=image, return_tensors="pt").pixel_values.to(hf_model_device)
-
-    # make sure processor creates exact same pixel values
-    assert torch.allclose(pixel_values, original_pixel_values.to(pixel_values.device))
-
-    original_model.to(lavis_device)
-    hf_model.to(hf_model_device)
-
-    if "itm" in model_name:
-        caption = "a large fountain spewing water into the air"
-        input_ids = tokenizer([caption], return_tensors="pt").input_ids.to(hf_model_device)
-        attention_mask = processor(text=caption, return_tensors="pt").attention_mask.to(hf_model_device)
-
-        with torch.no_grad():
-            original_logits = original_model(
-                {"image": original_pixel_values, "text_input": [caption]}, match_head="itm"
-            )
-            logits = hf_model(
-                pixel_values=pixel_values,
-                input_ids=input_ids,
-                attention_mask=attention_mask,
-                use_image_text_matching_head=True,
-            )
-
-        assert original_logits.shape == logits.logits_per_image.shape
-        print("First values of original logits:", original_logits[0, :3])
-        print("First values of HF logits:", logits.logits_per_image[0, :3])
-
-        # assert values
-        # cast to same type
-        target_dtype = logits.logits_per_image.dtype
-        assert torch.allclose(original_logits.to(target_dtype), logits.logits_per_image, atol=1e-4)
-
-        original_itm_scores = torch.nn.functional.softmax(original_logits, dim=1)
-        itm_scores = torch.nn.functional.softmax(logits.logits_per_image, dim=1)
-        assert torch.allclose(original_itm_scores.to(target_dtype), itm_scores, atol=1e-4)
-        print("Looks ok!")
-
-        with torch.no_grad():
-            original_logits = original_model(
-                {"image": original_pixel_values, "text_input": [caption]}, match_head="itc"
-            )
-            logits = hf_model(
-                pixel_values=pixel_values,
-                input_ids=input_ids,
-                attention_mask=attention_mask,
-                use_image_text_matching_head=False,
-            )
-
-        assert original_logits.shape == logits.logits_per_image.shape
-        print("First values of original logits:", original_logits[0, :3])
-        print("First values of HF logits:", logits.logits_per_image[0, :3])
-
-        # assert values
-        # cast to same type
-        target_dtype = logits.logits_per_image.dtype
-        assert torch.allclose(original_logits.to(target_dtype), logits.logits_per_image, atol=1e-4)
-        print("Looks ok!")
-
-    else:
-        input_ids = tokenizer(["\n"], return_tensors="pt").input_ids.to(hf_model_device)
-
-        with torch.no_grad():
-            if "opt" in model_name:
-                original_logits = original_model({"image": original_pixel_values, "text_input": [""]}).logits
-                logits = hf_model(pixel_values, input_ids).logits
-            else:
-                original_logits = original_model(
-                    {"image": original_pixel_values, "text_input": ["\n"], "text_output": ["\n"]}
-                ).logits
-                labels = input_ids.masked_fill(input_ids == tokenizer.pad_token_id, -100)
-                logits = hf_model(pixel_values, input_ids, labels=labels).logits
-
-        assert original_logits.shape == logits.shape
-        print("First values of original logits:", original_logits[0, :3, :3])
-        print("First values of HF logits:", logits[0, :3, :3])
-
-        # assert values
-        assert torch.allclose(original_logits.to(logits.device), logits, atol=1e-4)
-        print("Looks ok!")
-
-        print("Generating a caption...")
-        prompt = "Question: what object is in this image? Answer:"
-        input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(hf_model_device)
-
-        set_seed(42)
-
-        original_outputs = original_model.generate(
-            {"image": original_pixel_values, "prompt": prompt}, use_nucleus_sampling=True, max_length=50
-        )
-        outputs = hf_model.generate(
-            pixel_values,
-            input_ids,
-            do_sample=True,
-            num_beams=5,
-            max_length=30,
-            min_length=1,
-            top_p=0.9,
-            repetition_penalty=1.0,
-            length_penalty=1.0,
-            temperature=1,
-        )
-        output_text = processor.batch_decode(outputs, skip_special_tokens=True)
-        output_text = [text.strip() for text in output_text]
-        print("Original generation:", original_outputs)
-        print("HF generation:", output_text)
-
-    if pytorch_dump_folder_path is not None:
-        processor.save_pretrained(pytorch_dump_folder_path)
-        hf_model.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        processor.push_to_hub(f"nielsr/{model_name}")
-        hf_model.push_to_hub(f"nielsr/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    choices = [
-        "blip2-opt-2.7b",
-        "blip2-opt-6.7b",
-        "blip2-opt-2.7b-coco",
-        "blip2-opt-6.7b-coco",
-        "blip2-flan-t5-xl",
-        "blip2-flan-t5-xl-coco",
-        "blip2-flan-t5-xxl",
-        "blip2-itm-vit-g",
-        "blip2-itm-vit-g-coco",
-    ]
-    parser.add_argument(
-        "--model_name",
-        default="blip2-opt-2.7b",
-        choices=choices,
-        type=str,
-        help="Path to hf config.json of model to convert",
-    )
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model and processor to the hub after converting",
-    )
-    # note: this script is tested on 2 GPUs, as models are compared in float32,
-    # which requires quite some memory. Hence loading both on a
-    # separate device is the easiest to compare
-    parser.add_argument(
-        "--lavis_device", default="cpu", type=str, help="Torch device to run the conversion, either cpu or cuda."
-    )
-    parser.add_argument(
-        "--hf_model_device", default="cpu", type=str, help="Torch device to run the conversion, either cpu or cuda."
-    )
-
-    args = parser.parse_args()
-
-    convert_blip2_checkpoint(
-        args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.lavis_device, args.hf_model_device
-    )
diff --git a/src/transformers/models/bloom/convert_bloom_original_checkpoint_to_pytorch.py b/src/transformers/models/bloom/convert_bloom_original_checkpoint_to_pytorch.py
deleted file mode 100644
index 40ba6240d3e4..000000000000
--- a/src/transformers/models/bloom/convert_bloom_original_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,254 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert BigScience BLOOM checkpoint."""
-
-import argparse
-import json
-import os
-import re
-
-import torch
-
-from transformers import BloomConfig, BloomModel
-from transformers.file_utils import CONFIG_NAME, WEIGHTS_NAME
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-WEIGHTS_TO_AVERAGE_ENDSWITH = [
-    "word_embeddings_layernorm.weight",
-    "word_embeddings_layernorm.bias",
-    "input_layernorm.weight",
-    "input_layernorm.bias",
-    "post_attention_layernorm.weight",
-    "post_attention_layernorm.bias",
-    "self_attention.dense.bias",
-    "mlp.dense_4h_to_h.bias",
-    "ln_f.weight",
-    "ln_f.bias",
-]
-
-WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN = [
-    "mlp.dense_4h_to_h.weight",
-    "self_attention.dense.weight",
-]
-
-
-def layer_name_mapping(key, file):
-    """Convert Megatron-DeepSpeed TP/PP weights mapping in transformers PP only"""
-    # Handle first and last layers
-    layer_rename_map = {
-        "word_embeddings.weight": "word_embeddings.weight",
-        "word_embeddings.norm.weight": "word_embeddings_layernorm.weight",
-        "word_embeddings.norm.bias": "word_embeddings_layernorm.bias",
-        "weight": "ln_f.weight",
-        "bias": "ln_f.bias",
-    }
-
-    if key in layer_rename_map:
-        return layer_rename_map[key]
-
-    # Handle transformer blocks
-    layer_number = int(re.match(r".*layer_(\d*).*", file)[1])
-    layer_number -= 3
-    return f"h.{layer_number}." + key
-
-
-def get_dtype_size(dtype):
-    if dtype == torch.bool:
-        return 1 / 8
-    bit_search = re.search(r"[^\d](\d+)$", str(dtype))
-    if bit_search is None:
-        raise ValueError(f"`dtype` is not a valid dtype: {dtype}.")
-    bit_size = int(bit_search.groups()[0])
-    return bit_size // 8
-
-
-def convert_bloom_checkpoint_to_pytorch(
-    bloom_checkpoint_path, bloom_config_file, pytorch_dump_folder_path, shard_model, pretraining_tp
-):
-    # Construct model
-    if bloom_config_file == "":
-        config = BloomConfig()
-    else:
-        config = BloomConfig.from_json_file(bloom_config_file)
-
-    if shard_model:
-        file_names = os.listdir(bloom_checkpoint_path)
-        file_names = sorted(filter(lambda s: s.startswith("layer") and "model_00" in s, file_names))
-
-        index_dict = {"weight_map": {}, "metadata": {}}
-        total_size = 0
-
-        missing_keys = None
-
-        config = BloomConfig()
-
-        for j, file in enumerate(file_names):
-            print("Processing file: {}".format(file))
-            tensors = None
-
-            for i in range(pretraining_tp):
-                # load all TP files
-                f_name = file.replace("model_00", f"model_0{i}")
-                temp = torch.load(os.path.join(bloom_checkpoint_path, f_name), map_location="cpu")
-
-                # Rename keys in the transformers names
-                keys = list(temp.keys())
-                for key in keys:
-                    temp[layer_name_mapping(key, file)] = temp.pop(key)
-
-                if tensors is None:
-                    tensors = temp
-                else:
-                    for key in tensors.keys():
-                        if any(key.endswith(end) for end in WEIGHTS_TO_AVERAGE_ENDSWITH):
-                            # We average (sum and then divide) some weights accross TP ranks (see https://github.com/bigscience-workshop/Megatron-DeepSpeed/blob/olruwase/sync_layer_norms/megatron/training.py#L425)
-                            tensors[key] += temp[key]
-                        else:
-                            # Some weights are RowParallelLinear in Megatron-Deepspeed, others are ColumnParallel
-                            cat_dim = 1 if any(text in key for text in WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN) else 0
-                            # We concatenate these weights accross TP ranks
-                            tensors[key] = torch.cat([tensors[key], temp[key]], dim=cat_dim)
-
-            # Divide by the number of TP the weights we want to average
-            for key in tensors.keys():
-                if any(key.endswith(end) for end in WEIGHTS_TO_AVERAGE_ENDSWITH):
-                    tensors[key] = tensors[key] / pretraining_tp
-            torch.save(
-                tensors,
-                os.path.join(
-                    pytorch_dump_folder_path,
-                    "pytorch_model_{}-of-{}.bin".format(str(j + 1).zfill(5), str(len(file_names)).zfill(5)),
-                ),
-            )
-
-            for key in tensors.keys():
-                value = tensors[key]
-                total_size += value.numel() * get_dtype_size(value.dtype)
-                if key not in index_dict["weight_map"]:
-                    index_dict["weight_map"][key] = "pytorch_model_{}-of-{}.bin".format(
-                        str(j + 1).zfill(5), str(len(file_names)).zfill(5)
-                    )
-
-        config = BloomConfig()
-        pytorch_config_dump_path = pytorch_dump_folder_path + "/" + CONFIG_NAME
-        index_dict["metadata"]["total_size"] = total_size
-        with open(pytorch_config_dump_path, "w", encoding="utf-8") as f:
-            f.write(config.to_json_string())
-        with open(os.path.join(pytorch_dump_folder_path, WEIGHTS_NAME + ".index.json"), "w", encoding="utf-8") as f:
-            json_config = json.dumps(index_dict, indent=2, sort_keys=True) + "\n"
-            f.write(json_config)
-    else:
-        model = BloomModel(config)
-
-        file_names = os.listdir(bloom_checkpoint_path)
-        file_names = sorted(filter(lambda s: s.startswith("layer") and "model_00" in s, file_names))
-
-        missing_keys = None
-        for i, file in enumerate(file_names):
-            tensors = None
-            for i in range(pretraining_tp):
-                # load all TP files
-                f_name = file.replace("model_00", f"model_0{i}")
-                temp = torch.load(os.path.join(bloom_checkpoint_path, f_name), map_location="cpu")
-
-                # Rename keys in the transformers names
-                keys = list(temp.keys())
-                for key in keys:
-                    temp[layer_name_mapping(key, file)] = temp.pop(key)
-
-                if tensors is None:
-                    tensors = temp
-                else:
-                    for key in tensors.keys():
-                        # We average (sum and then divide) some weights accross TP ranks (see https://github.com/bigscience-workshop/Megatron-DeepSpeed/blob/olruwase/sync_layer_norms/megatron/training.py#L425)
-                        if any(key.endswith(end) for end in WEIGHTS_TO_AVERAGE_ENDSWITH):
-                            tensors[key] += temp[key]
-                        else:
-                            # Some weights are RowParallelLinear in Megatron-Deepspeed, others are ColumnParallel
-                            cat_dim = 1 if any(text in key for text in WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN) else 0
-                            # We concatenate these weights accross TP ranks
-                            tensors[key] = torch.cat([tensors[key], temp[key]], dim=cat_dim)
-
-            # Divide by the number of TP the weights we want to average
-            for key in tensors.keys():
-                if any(key.endswith(end) for end in WEIGHTS_TO_AVERAGE_ENDSWITH):
-                    tensors[key] = tensors[key] / pretraining_tp
-
-            other_keys = model.load_state_dict(tensors, strict=False)
-            assert not other_keys.unexpected_keys, f"The keys {other_keys.unexpected_keys} are unexpected"
-            if missing_keys is None:
-                missing_keys = set(other_keys.missing_keys)
-            else:
-                missing_keys = missing_keys.intersection(set(other_keys.missing_keys))
-
-        assert not missing_keys, f"The keys {missing_keys} are missing"
-
-        # Save pytorch-model
-        os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-        pytorch_weights_dump_path = pytorch_dump_folder_path + "/" + WEIGHTS_NAME
-        pytorch_config_dump_path = pytorch_dump_folder_path + "/" + CONFIG_NAME
-        print(f"Save PyTorch model to {pytorch_weights_dump_path} with dtype {config.torch_dtype}")
-        if config.torch_dtype is not None:
-            model = model.to(config.torch_dtype)
-        torch.save(model.state_dict(), pytorch_weights_dump_path)
-        print(f"Save configuration file to {pytorch_config_dump_path}")
-        with open(pytorch_config_dump_path, "w", encoding="utf-8") as f:
-            f.write(config.to_json_string())
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--bloom_checkpoint_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the Megatron-LM checkpoint path.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--bloom_config_file",
-        default="",
-        type=str,
-        help=(
-            "An optional config json file corresponding to the pre-trained model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--shard_model",
-        action="store_true",
-        help="An optional setting to shard the output model \nThis enables sharding the converted checkpoint",
-    )
-    parser.add_argument(
-        "--pretraining_tp",
-        default=4,
-        type=int,
-        help="Pretraining TP rank that has been used when training the model in Megatron-LM \n",
-    )
-    args = parser.parse_args()
-    convert_bloom_checkpoint_to_pytorch(
-        args.bloom_checkpoint_path,
-        args.bloom_config_file,
-        args.pytorch_dump_folder_path,
-        args.shard_model,
-        args.pretraining_tp,
-    )
diff --git a/src/transformers/models/bros/convert_bros_to_pytorch.py b/src/transformers/models/bros/convert_bros_to_pytorch.py
deleted file mode 100644
index c0984f2c74b2..000000000000
--- a/src/transformers/models/bros/convert_bros_to_pytorch.py
+++ /dev/null
@@ -1,145 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Bros checkpoints."""
-
-import argparse
-
-import bros  # original repo
-import torch
-
-from transformers import BrosConfig, BrosModel, BrosProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_configs(model_name):
-    bros_config = BrosConfig.from_pretrained(model_name)
-    return bros_config
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = [
-        "embeddings.bbox_sinusoid_emb.inv_freq",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(name):
-    if name == "embeddings.bbox_projection.weight":
-        name = "bbox_embeddings.bbox_projection.weight"
-
-    if name == "embeddings.bbox_sinusoid_emb.x_pos_emb.inv_freq":
-        name = "bbox_embeddings.bbox_sinusoid_emb.x_pos_emb.inv_freq"
-
-    if name == "embeddings.bbox_sinusoid_emb.y_pos_emb.inv_freq":
-        name = "bbox_embeddings.bbox_sinusoid_emb.y_pos_emb.inv_freq"
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, model):
-    # rename keys
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-        orig_state_dict[rename_key(key)] = val
-
-    # remove ignore keys
-    remove_ignore_keys_(orig_state_dict)
-
-    return orig_state_dict
-
-
-def convert_bros_checkpoint(model_name, pytorch_dump_folder_path=None, push_to_hub=False):
-    # load original model
-    original_model = bros.BrosModel.from_pretrained(model_name).eval()
-
-    # load HuggingFace Model
-    bros_config = get_configs(model_name)
-    model = BrosModel.from_pretrained(model_name, config=bros_config)
-    model.eval()
-
-    state_dict = original_model.state_dict()
-    new_state_dict = convert_state_dict(state_dict, model)
-    model.load_state_dict(new_state_dict)
-
-    # verify results
-
-    # original BROS model require 4 points (8 float values) for each bbox, prepare bbox with [batch_size, seq_len, 8] shape
-    bbox = torch.tensor(
-        [
-            [
-                [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
-                [0.4396, 0.6720, 0.4659, 0.6720, 0.4659, 0.6850, 0.4396, 0.6850],
-                [0.4698, 0.6720, 0.4843, 0.6720, 0.4843, 0.6850, 0.4698, 0.6850],
-                [0.4698, 0.6720, 0.4843, 0.6720, 0.4843, 0.6850, 0.4698, 0.6850],
-                [0.2047, 0.6870, 0.2730, 0.6870, 0.2730, 0.7000, 0.2047, 0.7000],
-                [0.2047, 0.6870, 0.2730, 0.6870, 0.2730, 0.7000, 0.2047, 0.7000],
-                [1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],
-            ]
-        ]
-    )
-
-    processor = BrosProcessor.from_pretrained(model_name)
-
-    encoding = processor("His name is Rocco.", return_tensors="pt")
-    encoding["bbox"] = bbox
-
-    original_hidden_states = original_model(**encoding).last_hidden_state
-    # pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    last_hidden_states = model(**encoding).last_hidden_state
-
-    assert torch.allclose(original_hidden_states, last_hidden_states, atol=1e-4)
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub("jinho8345/" + model_name.split("/")[-1], commit_message="Update model")
-        processor.push_to_hub("jinho8345/" + model_name.split("/")[-1], commit_message="Update model")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="jinho8345/bros-base-uncased",
-        required=False,
-        type=str,
-        help="Name of the original model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        required=False,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether or not to push the converted model and processor to the 🤗 hub.",
-    )
-
-    args = parser.parse_args()
-    convert_bros_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/byt5/convert_byt5_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/byt5/convert_byt5_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index 9b1b15857cea..000000000000
--- a/src/transformers/models/byt5/convert_byt5_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The T5 authors and HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert T5 checkpoint."""
-
-import argparse
-
-from transformers import T5Config, T5ForConditionalGeneration, load_tf_weights_in_t5
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = T5Config.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = T5ForConditionalGeneration(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_t5(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/canine/convert_canine_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/canine/convert_canine_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index 45dcdb290333..000000000000
--- a/src/transformers/models/canine/convert_canine_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert CANINE checkpoint."""
-
-import argparse
-
-from transformers import CanineConfig, CanineModel, CanineTokenizer, load_tf_weights_in_canine
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, pytorch_dump_path):
-    # Initialize PyTorch model
-    config = CanineConfig()
-    model = CanineModel(config)
-    model.eval()
-
-    print(f"Building PyTorch model from configuration: {config}")
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_canine(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model (weights and configuration)
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-    # Save tokenizer files
-    tokenizer = CanineTokenizer()
-    print(f"Save tokenizer files to {pytorch_dump_path}")
-    tokenizer.save_pretrained(pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the TensorFlow checkpoint. Should end with model.ckpt",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to a folder where the PyTorch model will be placed.",
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.pytorch_dump_path)
diff --git a/src/transformers/models/chameleon/convert_chameleon_weights_to_hf.py b/src/transformers/models/chameleon/convert_chameleon_weights_to_hf.py
deleted file mode 100644
index ff45c9b597e0..000000000000
--- a/src/transformers/models/chameleon/convert_chameleon_weights_to_hf.py
+++ /dev/null
@@ -1,476 +0,0 @@
-# Copyright 2024 Meta Inc. and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import gc
-import json
-import os
-
-import requests
-import torch
-import yaml
-from accelerate import init_empty_weights
-from PIL import Image
-
-from transformers import (
-    ChameleonConfig,
-    ChameleonForConditionalGeneration,
-    ChameleonImageProcessor,
-    ChameleonProcessor,
-)
-
-
-try:
-    from transformers import LlamaTokenizerFast
-except ImportError:
-    raise ValueError(
-        "Chameleon conversion supports only FastTokenizer and LlamaTokenizerFast can't be imported! "
-        "Update your `tokenizers` library and re-run the tokenizer conversion."
-    )
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/chameleon/convert_chameleon_weights_to_hf.py \
-    --input_dir /path/to/downloaded/chameleon/weights --model_size 7B --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import ChameleonForConditionalGeneration, LlamaTokenizerFast
-
-model = ChameleonForConditionalGeneration.from_pretrained("/output/path")
-tokenizer = LlamaTokenizerFast.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-NUM_SHARDS = {
-    "7B": 1,
-    "30B": 4,
-}
-
-VOCAB_SIZE = 65536
-
-
-def compute_intermediate_size(n, ffn_dim_multiplier=1, multiple_of=256):
-    return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3)) + multiple_of - 1) // multiple_of)
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def write_json(text, path):
-    with open(path, "w") as f:
-        json.dump(text, f)
-
-
-def write_model(model_path, input_base_path, model_size, chameleon_version=1):
-    os.makedirs(model_path, exist_ok=True)
-    input_model_path = os.path.join(input_base_path, "models", model_size.lower())
-    params_path = os.path.join(input_model_path, "params.json")
-    consolidate_params_path = os.path.join(input_model_path, "consolidate_params.json")
-
-    params = read_json(params_path)
-    if os.path.isfile(consolidate_params_path):
-        params = {**params, **read_json(consolidate_params_path)}
-    num_shards = NUM_SHARDS[model_size]
-    model_parallel_size = params["model_parallel_size"]
-    params = params.get("model", params)
-    n_layers = params["n_layers"]
-    n_heads = params["n_heads"]
-    n_heads_per_shard = n_heads // num_shards
-    dim = params["dim"]
-    dims_per_head = dim // n_heads
-    base = params.get("rope_theta", 10000.0)
-    swin_norm = params["swin_norm"]
-    if base > 10000.0:
-        max_position_embeddings = 16384
-    else:
-        # Depending on the Chameleon version, the default max_position_embeddings has different values.
-        if chameleon_version == 1:
-            max_position_embeddings = 4096
-        else:
-            raise NotImplementedError(
-                f"Version {chameleon_version} of chameleon is not supported yet. "
-                "Current supported versions of chameleon are [1]."
-            )
-
-    if params.get("n_kv_heads", None) is not None:
-        num_key_value_heads = params["n_kv_heads"]  # for GQA / MQA
-        num_local_key_value_heads = n_heads_per_shard // num_key_value_heads
-        key_value_dim = dim // num_key_value_heads
-    else:  # compatibility with other checkpoints
-        num_key_value_heads = n_heads
-        num_local_key_value_heads = n_heads_per_shard
-        key_value_dim = dim
-
-    print(f"Fetching all parameters from the checkpoint at {input_model_path}.")
-    # Load weights
-    if num_shards == 1:
-        # Not sharded
-        # (The sharded implementation would also work, but this is simpler.)
-        loaded = None
-        for possible_name in ["consolidated.pth", "consolidated.00.pth"]:
-            possible_path = os.path.join(input_model_path, possible_name)
-            if os.path.exists(possible_path):
-                loaded = torch.load(possible_path, map_location="cpu")
-                break
-        assert loaded is not None
-    else:
-        # Sharded
-        loaded = [
-            torch.load(os.path.join(input_model_path, f"consolidated.{i:02d}.pth"), map_location="cpu")
-            for i in range(num_shards)
-        ]
-
-    # permute for sliced rotary
-    def permute(w, n_heads, dim1=dim, dim2=dim):
-        return w.view(n_heads, dim1 // n_heads // 2, 2, dim2).transpose(1, 2).reshape(dim1, dim2)
-
-    # Load weights to the state dict
-    state_dict = {}
-    for layer_i in range(n_layers):
-        if num_shards == 1:
-            # Unsharded
-            state_dict.update(
-                {
-                    f"model.layers.{layer_i}.self_attn.q_proj.weight": permute(
-                        loaded[f"layers.{layer_i}.attention.wq.weight"], n_heads=n_heads
-                    ),
-                    f"model.layers.{layer_i}.self_attn.k_proj.weight": permute(
-                        loaded[f"layers.{layer_i}.attention.wk.weight"],
-                        n_heads=num_key_value_heads,
-                        dim1=key_value_dim,
-                    ),
-                    f"model.layers.{layer_i}.self_attn.v_proj.weight": loaded[f"layers.{layer_i}.attention.wv.weight"],
-                    f"model.layers.{layer_i}.self_attn.o_proj.weight": loaded[f"layers.{layer_i}.attention.wo.weight"],
-                    f"model.layers.{layer_i}.mlp.gate_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w1.weight"],
-                    f"model.layers.{layer_i}.mlp.down_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w2.weight"],
-                    f"model.layers.{layer_i}.mlp.up_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w3.weight"],
-                    f"model.layers.{layer_i}.input_layernorm.weight": loaded[
-                        f"layers.{layer_i}.attention_norm.weight"
-                    ],
-                    f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[
-                        f"layers.{layer_i}.ffn_norm.weight"
-                    ],
-                }
-            )
-            # qk_layernorm (see https://github.com/huggingface/transformers/pull/31534#issuecomment-2207354677)
-            state_dict[f"model.layers.{layer_i}.self_attn.q_norm.weight"] = (
-                loaded[f"layers.{layer_i}.attention.q_normalization.weight"]
-                .view(dims_per_head // 2, 2)
-                .t()
-                .reshape(1, -1)
-                .repeat_interleave(n_heads, 0)
-            )
-            state_dict[f"model.layers.{layer_i}.self_attn.q_norm.bias"] = (
-                loaded[f"layers.{layer_i}.attention.q_normalization.bias"]
-                .view(dims_per_head // 2, 2)
-                .t()
-                .reshape(1, -1)
-                .repeat_interleave(n_heads, 0)
-            )
-            state_dict[f"model.layers.{layer_i}.self_attn.k_norm.weight"] = (
-                loaded[f"layers.{layer_i}.attention.k_normalization.weight"]
-                .view(dims_per_head // 2, 2)
-                .t()
-                .reshape(1, -1)
-                .repeat_interleave(num_key_value_heads, 0)
-            )
-            state_dict[f"model.layers.{layer_i}.self_attn.k_norm.bias"] = (
-                loaded[f"layers.{layer_i}.attention.k_normalization.bias"]
-                .view(dims_per_head // 2, 2)
-                .t()
-                .reshape(1, -1)
-                .repeat_interleave(num_key_value_heads, 0)
-            )
-
-        else:
-            # Sharded
-            state_dict.update(
-                {
-                    f"model.layers.{layer_i}.input_layernorm.weight": torch.stack(
-                        [l[f"layers.{layer_i}.attention_norm.weight"] for l in loaded]
-                    ).mean(dim=0),
-                    f"model.layers.{layer_i}.post_attention_layernorm.weight": torch.stack(
-                        [l[f"layers.{layer_i}.ffn_norm.weight"] for l in loaded]
-                    ).mean(dim=0),
-                }
-            )
-            state_dict[f"model.layers.{layer_i}.self_attn.q_proj.weight"] = permute(
-                torch.cat(
-                    [
-                        loaded[i][f"layers.{layer_i}.attention.wq.weight"].view(n_heads_per_shard, dims_per_head, dim)
-                        for i in range(num_shards)
-                    ],
-                    dim=0,
-                ).reshape(dim, dim),
-                n_heads=n_heads,
-            )
-
-            state_dict[f"model.layers.{layer_i}.self_attn.k_proj.weight"] = permute(
-                torch.cat(
-                    [
-                        loaded[i][f"layers.{layer_i}.attention.wk.weight"].view(
-                            num_local_key_value_heads, dims_per_head, dim
-                        )
-                        for i in range(num_shards)
-                    ],
-                    dim=0,
-                ).reshape(key_value_dim, dim),
-                n_heads=num_key_value_heads,
-                dim1=key_value_dim,
-            )
-
-            # qk_layernorm (see https://github.com/huggingface/transformers/pull/31534#issuecomment-2207354677)
-            state_dict[f"model.layers.{layer_i}.self_attn.q_norm.weight"] = (
-                torch.cat([l[f"layers.{layer_i}.attention.q_normalization.weight"].unsqueeze(0) for l in loaded])
-                .view(num_shards, dims_per_head // 2, 2)
-                .transpose(1, 2)
-                .reshape(num_shards, -1)
-                .repeat_interleave(n_heads // num_shards, 0)
-            )
-            state_dict[f"model.layers.{layer_i}.self_attn.q_norm.bias"] = (
-                torch.cat([l[f"layers.{layer_i}.attention.q_normalization.bias"].unsqueeze(0) for l in loaded])
-                .view(num_shards, dims_per_head // 2, 2)
-                .transpose(1, 2)
-                .reshape(num_shards, -1)
-                .repeat_interleave(n_heads // num_shards, 0)
-            )
-            state_dict[f"model.layers.{layer_i}.self_attn.k_norm.weight"] = (
-                torch.cat([l[f"layers.{layer_i}.attention.k_normalization.weight"].unsqueeze(0) for l in loaded])
-                .view(num_shards, dims_per_head // 2, 2)
-                .transpose(1, 2)
-                .reshape(num_shards, -1)
-                .repeat_interleave(num_key_value_heads // num_shards, 0)
-            )
-            state_dict[f"model.layers.{layer_i}.self_attn.k_norm.bias"] = (
-                torch.cat([l[f"layers.{layer_i}.attention.k_normalization.bias"].unsqueeze(0) for l in loaded])
-                .view(num_shards, dims_per_head // 2, 2)
-                .transpose(1, 2)
-                .reshape(num_shards, -1)
-                .repeat_interleave(num_key_value_heads // num_shards, 0)
-            )
-
-            state_dict[f"model.layers.{layer_i}.self_attn.v_proj.weight"] = torch.cat(
-                [
-                    loaded[i][f"layers.{layer_i}.attention.wv.weight"].view(
-                        num_local_key_value_heads, dims_per_head, dim
-                    )
-                    for i in range(num_shards)
-                ],
-                dim=0,
-            ).reshape(key_value_dim, dim)
-
-            state_dict[f"model.layers.{layer_i}.self_attn.o_proj.weight"] = torch.cat(
-                [loaded[i][f"layers.{layer_i}.attention.wo.weight"] for i in range(num_shards)], dim=1
-            )
-            state_dict[f"model.layers.{layer_i}.mlp.gate_proj.weight"] = torch.cat(
-                [loaded[i][f"layers.{layer_i}.feed_forward.w1.weight"] for i in range(num_shards)], dim=0
-            )
-            state_dict[f"model.layers.{layer_i}.mlp.down_proj.weight"] = torch.cat(
-                [loaded[i][f"layers.{layer_i}.feed_forward.w2.weight"] for i in range(num_shards)], dim=1
-            )
-            state_dict[f"model.layers.{layer_i}.mlp.up_proj.weight"] = torch.cat(
-                [loaded[i][f"layers.{layer_i}.feed_forward.w3.weight"] for i in range(num_shards)], dim=0
-            )
-
-    if num_shards == 1:
-        # Unsharded
-        state_dict.update(
-            {
-                "model.embed_tokens.weight": loaded["tok_embeddings.weight"],
-                "model.norm.weight": loaded["norm.weight"],
-                "lm_head.weight": loaded["output.weight"],
-            }
-        )
-    else:
-        state_dict.update(
-            {
-                "model.embed_tokens.weight": torch.cat(
-                    [loaded[i]["tok_embeddings.weight"] for i in range(num_shards)], dim=1
-                ),
-                "model.norm.weight": torch.stack([loaded[i]["norm.weight"] for i in range(num_shards)]).mean(dim=0),
-                "lm_head.weight": torch.cat([loaded[i]["output.weight"] for i in range(num_shards)], dim=0),
-            }
-        )
-
-    # Load VQGAN weights
-    vqgan_path = os.path.join(input_base_path, "tokenizer/vqgan.ckpt")
-    vqgan_state_dict = torch.load(vqgan_path, map_location="cpu")["state_dict"]
-    for k, v in vqgan_state_dict.items():
-        if "decoder" in k:
-            continue  # we dont do image generation yet
-        state_dict[f"model.vqmodel.{k}"] = v
-
-    # Write configs
-    ffn_dim_multiplier = params["ffn_dim_multiplier"] if "ffn_dim_multiplier" in params else 1
-    multiple_of = params["multiple_of"] if "multiple_of" in params else 256
-
-    with open(os.path.join(input_base_path, "tokenizer/text_tokenizer.json")) as tokenizer_file:
-        tokenizer_config = json.load(tokenizer_file)
-        vocabulary_map = tokenizer_config["model"]["vocab"]
-        vocabulary_map["<image>"] = vocabulary_map[
-            "<reserved08707>"
-        ]  # use a reserved token instead of adding a new one
-        del vocabulary_map["<reserved08707>"]
-
-        for token in tokenizer_config["added_tokens"]:
-            if token["content"] == "<reserved08707>":
-                token["content"] = "<image>"
-
-    with open(os.path.join(input_base_path, "tokenizer/text_tokenizer_modified.json"), "w") as f:
-        json.dump(tokenizer_config, f)  # save the new file to init tokenizer later
-
-    vq_keys_to_replace = [
-        ("ch", "base_channels"),
-        ("out_ch", "out_channels"),
-        ("n_embed", "num_embeddings"),
-        ("ch_mult", "channel_multiplier"),
-        ("double_z", "double_latent"),
-        ("z_channels", "latent_channels"),
-    ]
-    with open(os.path.join(input_base_path, "tokenizer/vqgan.yaml")) as vqgan_cfg_file:
-        vq_config = yaml.safe_load(vqgan_cfg_file)["model"]["params"]
-        vq_config.update(**vq_config["ddconfig"])
-        for old, new in vq_keys_to_replace:
-            vq_config[new] = vq_config[old]
-        del vq_config["ddconfig"]
-        del vq_config["ckpt_path"]
-        del vq_config["lossconfig"]
-
-    config = ChameleonConfig(
-        hidden_size=dim,
-        intermediate_size=compute_intermediate_size(dim, ffn_dim_multiplier, multiple_of),
-        num_attention_heads=params["n_heads"],
-        num_hidden_layers=params["n_layers"],
-        rms_norm_eps=params["norm_eps"],
-        num_key_value_heads=num_key_value_heads,
-        vocab_size=VOCAB_SIZE,
-        rope_theta=base,
-        max_position_embeddings=max_position_embeddings,
-        model_parallel_size=model_parallel_size,
-        swin_norm=swin_norm,
-        vq_config=vq_config,
-        vocabulary_map=vocabulary_map,
-    )
-    with init_empty_weights():
-        model = ChameleonForConditionalGeneration(config)
-
-    model.load_state_dict(state_dict, assign=True, strict=False)
-    model.save_pretrained(model_path, safe_serialization=True)
-
-    # Load and save the processor
-    tokenizer = LlamaTokenizerFast(
-        tokenizer_file=os.path.join(input_base_path, "tokenizer/text_tokenizer_modified.json"), legacy=False
-    )
-    tokenizer.sep_token_id = 8710  # assign <reserved08706> to sep so that we can append it after input text
-    tokenizer.pad_token_id = 1  # assing <pad> to special pad_token
-    image_processor = ChameleonImageProcessor()
-    processor = ChameleonProcessor(image_processor=image_processor, tokenizer=tokenizer)
-    processor.save_pretrained(model_path)
-
-    # Make space so we can load the model properly now.
-    del state_dict
-    del loaded
-    del vqgan_state_dict
-    gc.collect()
-
-    # Short inference on a few examples to check if generation makes sense
-    # taken from https://github.com/facebookresearch/chameleon/blob/7a72f40aa5f462965c8374f25257f55b65b25ff4/data/prompts_for_human_evaluations.jsonl
-    print("Loading the checkpoint in a Chameleon model...")
-    print("*" * 100)
-    model = ChameleonForConditionalGeneration.from_pretrained(
-        model_path, attn_implementation="eager", torch_dtype=torch.bfloat16, device_map="auto"
-    )
-    processor = ChameleonProcessor.from_pretrained(model_path)
-
-    prompt = "I'm very intrigued by this work of art:<image>Please tell me about the artist."
-    image = Image.open(
-        requests.get(
-            "https://uploads4.wikiart.org/images/paul-klee/death-for-the-idea-1915.jpg!Large.jpg", stream=True
-        ).raw
-    )
-    inputs = processor(prompt, images=image, return_tensors="pt").to(model.device, torch.bfloat16)
-    length = inputs.input_ids.shape[1]
-
-    out = model.generate(**inputs, max_new_tokens=40, do_sample=False)
-    generated_text = processor.batch_decode(out[:, length:], skip_special_tokens=True)[0]
-
-    print(f"Generation for single-image: {generated_text}")
-    print("*" * 100)
-
-    # Multi-image example
-    prompt = "I used to know a lot about constellations when I was younger, but as I grew older, I forgot most of what I knew. These are the only two constellations that I really remember now.<image><image>I would like for you to tell me about 3 more constellations and give me a little bit of history about the constellation."
-    image = Image.open(
-        requests.get("https://nineplanets.org/wp-content/uploads/2020/12/the-big-dipper-1.jpg", stream=True).raw
-    )
-    image_2 = Image.open(
-        requests.get("https://www.kxan.com/wp-content/uploads/sites/40/2020/10/ORION.jpg", stream=True).raw
-    )
-
-    inputs = processor(prompt, images=[image, image_2], return_tensors="pt").to(model.device, dtype=torch.bfloat16)
-    length = inputs.input_ids.shape[1]
-    out = model.generate(**inputs, max_new_tokens=50, do_sample=False)
-    generated_text = processor.batch_decode(out[:, length:], skip_special_tokens=True)[0]
-
-    print(f"Generation for multi-image: {generated_text}")
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        help="Location of Chameleon weights",
-    )
-    parser.add_argument(
-        "--model_size",
-        choices=["7B", "30B"],
-        help=""
-        " models correspond to the finetuned versions, and are specific to the Chameleon official release. For more details on Chameleon, checkout the original repo: https://github.com/facebookresearch/chameleon",
-    )
-    parser.add_argument(
-        "--output_dir",
-        help="Location to write HF model",
-    )
-    parser.add_argument(
-        "--test_inference",
-        action="store_true",
-        help="Whether to load the model for generation to test it's converted correctly.",
-    )
-    # Different Chameleon versions used different default values for max_position_embeddings, hence the need to be able to specify which version is being used.
-    parser.add_argument(
-        "--chameleon_version",
-        choices=[1],
-        default=1,
-        type=int,
-        help="Version of the Chameleon model to convert",
-    )
-    args = parser.parse_args()
-    write_model(
-        model_path=args.output_dir,
-        input_base_path=args.input_dir,
-        model_size=args.model_size,
-        chameleon_version=args.chameleon_version,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/chinese_clip/convert_chinese_clip_original_pytorch_to_hf.py b/src/transformers/models/chinese_clip/convert_chinese_clip_original_pytorch_to_hf.py
deleted file mode 100644
index 02c4b7b754b2..000000000000
--- a/src/transformers/models/chinese_clip/convert_chinese_clip_original_pytorch_to_hf.py
+++ /dev/null
@@ -1,134 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The OFA-Sys Team Authors and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import torch
-
-from transformers import ChineseCLIPConfig, ChineseCLIPModel
-
-
-def copy_attn_layer(hf_attn_layer, pt_weights, prefix):
-    q_proj, k_proj, v_proj = pt_weights[f"{prefix}.in_proj_weight"].chunk(3, dim=0)
-    q_proj_bias, k_proj_bias, v_proj_bias = pt_weights[f"{prefix}.in_proj_bias"].chunk(3, dim=0)
-
-    out_proj_weights = pt_weights[f"{prefix}.out_proj.weight"]
-    out_proj_bias = pt_weights[f"{prefix}.out_proj.bias"]
-
-    hf_attn_layer.q_proj.weight.data = q_proj
-    hf_attn_layer.q_proj.bias.data = q_proj_bias
-
-    hf_attn_layer.k_proj.weight.data = k_proj
-    hf_attn_layer.k_proj.bias.data = k_proj_bias
-
-    hf_attn_layer.v_proj.weight.data = v_proj
-    hf_attn_layer.v_proj.bias.data = v_proj_bias
-
-    hf_attn_layer.out_proj.weight.data = out_proj_weights
-    hf_attn_layer.out_proj.bias.data = out_proj_bias
-
-
-def copy_mlp(hf_mlp, pt_weights, prefix):
-    copy_linear(hf_mlp.fc1, pt_weights, f"{prefix}.c_fc")
-    copy_linear(hf_mlp.fc2, pt_weights, f"{prefix}.c_proj")
-
-
-def copy_linear(hf_linear, pt_weights, prefix):
-    hf_linear.weight.data = pt_weights[f"{prefix}.weight"].data
-    hf_linear.bias.data = pt_weights[f"{prefix}.bias"].data
-
-
-def copy_layer(hf_layer, pt_weights, prefix):
-    # copy layer norms
-    copy_linear(hf_layer.layer_norm1, pt_weights, f"{prefix}.ln_1")
-    copy_linear(hf_layer.layer_norm2, pt_weights, f"{prefix}.ln_2")
-
-    # copy MLP
-    copy_mlp(hf_layer.mlp, pt_weights, f"{prefix}.mlp")
-
-    # copy attn
-    copy_attn_layer(hf_layer.self_attn, pt_weights, f"{prefix}.attn")
-
-
-def copy_layers(hf_layers, pt_weights, prefix):
-    for layer_id, hf_layer in enumerate(hf_layers):
-        copy_layer(hf_layer, pt_weights, f"{prefix}.{layer_id}")
-
-
-def copy_text_model_and_projection(hf_model, pt_weights):
-    # copy projection
-    hf_model.text_projection.weight.data = pt_weights["text_projection"].data.T
-
-    # copy text encoder
-    for name, param in hf_model.text_model.named_parameters():
-        param.data = pt_weights[f"bert.{name}"].data
-
-
-def copy_vision_model_and_projection(hf_model, pt_weights):
-    # copy projection
-    hf_model.visual_projection.weight.data = pt_weights["visual.proj"].data.T
-
-    # copy layer norms
-    copy_linear(hf_model.vision_model.pre_layrnorm, pt_weights, "visual.ln_pre")
-    copy_linear(hf_model.vision_model.post_layernorm, pt_weights, "visual.ln_post")
-
-    # copy embeddings
-    hf_model.vision_model.embeddings.patch_embedding.weight.data = pt_weights["visual.conv1.weight"].data
-    hf_model.vision_model.embeddings.class_embedding.data = pt_weights["visual.class_embedding"].data
-    hf_model.vision_model.embeddings.position_embedding.weight.data = pt_weights["visual.positional_embedding"].data
-
-    # copy encoder
-    copy_layers(hf_model.vision_model.encoder.layers, pt_weights, "visual.transformer.resblocks")
-
-
-@torch.no_grad()
-def convert_chinese_clip_checkpoint(checkpoint_path, pytorch_dump_folder_path, config_path=None):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-
-    assert config_path is not None, "Please specify the ChineseCLIP model config of the corresponding model size."
-    config = ChineseCLIPConfig.from_pretrained(config_path)
-
-    hf_model = ChineseCLIPModel(config).eval()
-
-    pt_weights = torch.load(checkpoint_path, map_location="cpu")["state_dict"]
-    pt_weights = {(name[7:] if name.startswith("module.") else name): value for name, value in pt_weights.items()}
-
-    copy_text_model_and_projection(hf_model, pt_weights)
-    copy_vision_model_and_projection(hf_model, pt_weights)
-    hf_model.logit_scale.data = pt_weights["logit_scale"].data
-
-    hf_model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output folder storing converted hf PyTorch model.",
-    )
-    parser.add_argument(
-        "--checkpoint_path", default=None, type=str, help="Path to original github format ChineseCLIP checkpoint."
-    )
-    parser.add_argument(
-        "--config_path", default=None, required=True, type=str, help="Path to hf config.json of model to convert."
-    )
-    args = parser.parse_args()
-
-    convert_chinese_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
-    print("The conversion is finished!")
diff --git a/src/transformers/models/clap/convert_clap_original_pytorch_to_hf.py b/src/transformers/models/clap/convert_clap_original_pytorch_to_hf.py
deleted file mode 100644
index 66488e401a1a..000000000000
--- a/src/transformers/models/clap/convert_clap_original_pytorch_to_hf.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import re
-
-from laion_clap import CLAP_Module
-
-from transformers import AutoFeatureExtractor, ClapConfig, ClapModel
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "text_branch": "text_model",
-    "audio_branch": "audio_model.audio_encoder",
-    "attn": "attention.self",
-    "self.proj": "output.dense",
-    "attention.self_mask": "attn_mask",
-    "mlp.fc1": "intermediate.dense",
-    "mlp.fc2": "output.dense",
-    "norm1": "layernorm_before",
-    "norm2": "layernorm_after",
-    "bn0": "batch_norm",
-}
-
-processor = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused", truncation="rand_trunc")
-
-
-def init_clap(checkpoint_path, model_type, enable_fusion=False):
-    model = CLAP_Module(
-        amodel=model_type,
-        enable_fusion=enable_fusion,
-    )
-    model.load_ckpt(checkpoint_path)
-    return model
-
-
-def get_config_from_original(clap_model):
-    audio_config = {
-        "patch_embeds_hidden_size": clap_model.model.audio_branch.embed_dim,
-        "depths": clap_model.model.audio_branch.depths,
-        "hidden_size": clap_model.model.audio_projection[0].in_features,
-    }
-
-    text_config = {"hidden_size": clap_model.model.text_branch.pooler.dense.in_features}
-
-    return ClapConfig(audio_config=audio_config, text_config=text_config)
-
-
-def rename_state_dict(state_dict):
-    model_state_dict = {}
-
-    sequential_layers_pattern = r".*sequential.(\d+).*"
-    text_projection_pattern = r".*_projection.(\d+).*"
-
-    for key, value in state_dict.items():
-        # check if any key needs to be modified
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        if re.match(sequential_layers_pattern, key):
-            # replace sequential layers with list
-            sequential_layer = re.match(sequential_layers_pattern, key).group(1)
-
-            key = key.replace(f"sequential.{sequential_layer}.", f"layers.{int(sequential_layer) // 3}.linear.")
-        elif re.match(text_projection_pattern, key):
-            projecton_layer = int(re.match(text_projection_pattern, key).group(1))
-
-            # Because in CLAP they use `nn.Sequential`...
-            transformers_projection_layer = 1 if projecton_layer == 0 else 2
-
-            key = key.replace(f"_projection.{projecton_layer}.", f"_projection.linear{transformers_projection_layer}.")
-
-        if "audio" and "qkv" in key:
-            # split qkv into query key and value
-            mixed_qkv = value
-            qkv_dim = mixed_qkv.size(0) // 3
-
-            query_layer = mixed_qkv[:qkv_dim]
-            key_layer = mixed_qkv[qkv_dim : qkv_dim * 2]
-            value_layer = mixed_qkv[qkv_dim * 2 :]
-
-            model_state_dict[key.replace("qkv", "query")] = query_layer
-            model_state_dict[key.replace("qkv", "key")] = key_layer
-            model_state_dict[key.replace("qkv", "value")] = value_layer
-        else:
-            model_state_dict[key] = value
-
-    return model_state_dict
-
-
-def convert_clap_checkpoint(checkpoint_path, pytorch_dump_folder_path, config_path, model_type, enable_fusion=False):
-    clap_model = init_clap(checkpoint_path, model_type, enable_fusion=enable_fusion)
-
-    clap_model.eval()
-    state_dict = clap_model.model.state_dict()
-    state_dict = rename_state_dict(state_dict)
-
-    transformers_config = get_config_from_original(clap_model)
-    transformers_config.audio_config.enable_fusion = enable_fusion
-    model = ClapModel(transformers_config)
-
-    # ignore the spectrogram embedding layer
-    model.load_state_dict(state_dict, strict=False)
-
-    model.save_pretrained(pytorch_dump_folder_path)
-    transformers_config.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument("--enable_fusion", action="store_true", help="Whether to enable fusion or not")
-    parser.add_argument("--model_type", default="HTSAT-tiny", type=str, help="Whether to enable fusion or not")
-    args = parser.parse_args()
-
-    convert_clap_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.model_type, args.enable_fusion
-    )
diff --git a/src/transformers/models/clip/convert_clip_original_pytorch_to_hf.py b/src/transformers/models/clip/convert_clip_original_pytorch_to_hf.py
deleted file mode 100644
index 3d88fc1929c3..000000000000
--- a/src/transformers/models/clip/convert_clip_original_pytorch_to_hf.py
+++ /dev/null
@@ -1,156 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import torch
-from clip import load
-
-from transformers import CLIPConfig, CLIPModel
-
-
-def copy_attn_layer(hf_attn_layer, pt_attn_layer):
-    q_proj, k_proj, v_proj = pt_attn_layer.in_proj_weight.chunk(3, dim=0)
-    q_proj_bias, k_proj_bias, v_proj_bias = pt_attn_layer.in_proj_bias.chunk(3, dim=0)
-
-    out_proj_weights = pt_attn_layer.out_proj.weight
-    out_proj_bias = pt_attn_layer.out_proj.bias
-
-    hf_attn_layer.q_proj.weight.data = q_proj
-    hf_attn_layer.q_proj.bias.data = q_proj_bias
-
-    hf_attn_layer.k_proj.weight.data = k_proj
-    hf_attn_layer.k_proj.bias.data = k_proj_bias
-
-    hf_attn_layer.v_proj.weight.data = v_proj
-    hf_attn_layer.v_proj.bias.data = v_proj_bias
-
-    hf_attn_layer.out_proj.weight = out_proj_weights
-    hf_attn_layer.out_proj.bias = out_proj_bias
-
-
-def copy_mlp(hf_mlp, pt_mlp):
-    copy_linear(hf_mlp.fc1, pt_mlp.c_fc)
-    copy_linear(hf_mlp.fc2, pt_mlp.c_proj)
-
-
-def copy_linear(hf_linear, pt_linear):
-    hf_linear.weight = pt_linear.weight
-    hf_linear.bias = pt_linear.bias
-
-
-def copy_layer(hf_layer, pt_layer):
-    # copy layer norms
-    copy_linear(hf_layer.layer_norm1, pt_layer.ln_1)
-    copy_linear(hf_layer.layer_norm2, pt_layer.ln_2)
-
-    # copy MLP
-    copy_mlp(hf_layer.mlp, pt_layer.mlp)
-
-    # copy attn
-    copy_attn_layer(hf_layer.self_attn, pt_layer.attn)
-
-
-def copy_layers(hf_layers, pt_layers):
-    for hf_layer, pt_layer in zip(hf_layers, pt_layers):
-        copy_layer(hf_layer, pt_layer)
-
-
-def copy_encoder(hf_encoder, pt_model):
-    # copy  embeds
-    hf_encoder.embeddings.token_embedding.weight = pt_model.token_embedding.weight
-    hf_encoder.embeddings.position_embedding.weight.data = pt_model.positional_embedding
-
-    # copy layer norm
-    copy_linear(hf_encoder.final_layer_norm, pt_model.ln_final)
-
-    # copy hidden layers
-    copy_layers(hf_encoder.encoder.layers, pt_model.transformer.resblocks)
-
-
-def copy_text_model_and_projection(hf_model, pt_model):
-    # copy projection
-    hf_model.text_projection.weight.data = pt_model.text_projection.data.T.contiguous()
-
-    # copy text encoder
-    copy_encoder(hf_model.text_model, pt_model)
-
-
-def copy_vison_model_and_projection(hf_model, pt_model):
-    # copy projection
-    hf_model.visual_projection.weight.data = pt_model.visual.proj.data.T.contiguous()
-
-    # copy layer norms
-    copy_linear(hf_model.vision_model.pre_layrnorm, pt_model.visual.ln_pre)
-    copy_linear(hf_model.vision_model.post_layernorm, pt_model.visual.ln_post)
-
-    # copy embeds
-    hf_model.vision_model.embeddings.patch_embedding.weight.data = pt_model.visual.conv1.weight.data
-    hf_model.vision_model.embeddings.class_embedding = pt_model.visual.class_embedding
-    hf_model.vision_model.embeddings.position_embedding.weight.data = pt_model.visual.positional_embedding.data
-
-    # copy encoder
-    copy_layers(hf_model.vision_model.encoder.layers, pt_model.visual.transformer.resblocks)
-
-
-@torch.no_grad()
-def convert_clip_checkpoint(checkpoint_path, pytorch_dump_folder_path, config_path=None):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = CLIPConfig.from_pretrained(config_path)
-    else:
-        config = CLIPConfig(projection_dim=512, text_config={}, vision_config={})
-
-    hf_model = CLIPModel(config).eval()
-
-    pt_model, _ = load(checkpoint_path, device="cpu", jit=False)
-    pt_model = pt_model.eval()
-
-    copy_text_model_and_projection(hf_model, pt_model)
-    copy_vison_model_and_projection(hf_model, pt_model)
-    hf_model.logit_scale = pt_model.logit_scale
-
-    # Use `eos_token` so the example is more meaningful
-    input_ids = torch.tensor(
-        [
-            [config.text_config.bos_token_id]
-            + list(range(3, 77))
-            + [config.text_config.eos_token_id]
-            + [config.text_config.pad_token_id]
-        ]
-    )
-    pixel_values = torch.randn(1, 3, 224, 224)
-
-    hf_outputs = hf_model(input_ids=input_ids, pixel_values=pixel_values, return_dict=True)
-    hf_logits_per_image = hf_outputs.logits_per_image
-    hf_logits_per_text = hf_outputs.logits_per_text
-    pt_logits_per_image, pt_logits_per_text = pt_model(pixel_values, input_ids)
-
-    assert torch.allclose(hf_logits_per_image, pt_logits_per_image, atol=1e-3)
-    assert torch.allclose(hf_logits_per_text, pt_logits_per_text, atol=1e-3)
-
-    hf_model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to OpenAI checkpoint")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    args = parser.parse_args()
-
-    convert_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
diff --git a/src/transformers/models/clipseg/convert_clipseg_original_pytorch_to_hf.py b/src/transformers/models/clipseg/convert_clipseg_original_pytorch_to_hf.py
deleted file mode 100644
index c614d61e5b3d..000000000000
--- a/src/transformers/models/clipseg/convert_clipseg_original_pytorch_to_hf.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert CLIPSeg checkpoints from the original repository. URL: https://github.com/timojl/clipseg."""
-
-import argparse
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import (
-    CLIPSegConfig,
-    CLIPSegForImageSegmentation,
-    CLIPSegProcessor,
-    CLIPSegTextConfig,
-    CLIPSegVisionConfig,
-    CLIPTokenizer,
-    ViTImageProcessor,
-)
-
-
-def get_clipseg_config(model_name):
-    text_config = CLIPSegTextConfig()
-    vision_config = CLIPSegVisionConfig(patch_size=16)
-
-    use_complex_transposed_convolution = True if "refined" in model_name else False
-    reduce_dim = 16 if "rd16" in model_name else 64
-
-    config = CLIPSegConfig.from_text_vision_configs(
-        text_config,
-        vision_config,
-        use_complex_transposed_convolution=use_complex_transposed_convolution,
-        reduce_dim=reduce_dim,
-    )
-    return config
-
-
-def rename_key(name):
-    # update prefixes
-    if "clip_model" in name:
-        name = name.replace("clip_model", "clip")
-    if "transformer" in name:
-        if "visual" in name:
-            name = name.replace("visual.transformer", "vision_model")
-        else:
-            name = name.replace("transformer", "text_model")
-    if "resblocks" in name:
-        name = name.replace("resblocks", "encoder.layers")
-    if "ln_1" in name:
-        name = name.replace("ln_1", "layer_norm1")
-    if "ln_2" in name:
-        name = name.replace("ln_2", "layer_norm2")
-    if "c_fc" in name:
-        name = name.replace("c_fc", "fc1")
-    if "c_proj" in name:
-        name = name.replace("c_proj", "fc2")
-    if "attn" in name and "self" not in name:
-        name = name.replace("attn", "self_attn")
-    # text encoder
-    if "token_embedding" in name:
-        name = name.replace("token_embedding", "text_model.embeddings.token_embedding")
-    if "positional_embedding" in name and "visual" not in name:
-        name = name.replace("positional_embedding", "text_model.embeddings.position_embedding.weight")
-    if "ln_final" in name:
-        name = name.replace("ln_final", "text_model.final_layer_norm")
-    # vision encoder
-    if "visual.class_embedding" in name:
-        name = name.replace("visual.class_embedding", "vision_model.embeddings.class_embedding")
-    if "visual.conv1" in name:
-        name = name.replace("visual.conv1", "vision_model.embeddings.patch_embedding")
-    if "visual.positional_embedding" in name:
-        name = name.replace("visual.positional_embedding", "vision_model.embeddings.position_embedding.weight")
-    if "visual.ln_pre" in name:
-        name = name.replace("visual.ln_pre", "vision_model.pre_layrnorm")
-    if "visual.ln_post" in name:
-        name = name.replace("visual.ln_post", "vision_model.post_layernorm")
-    # projection layers
-    if "visual.proj" in name:
-        name = name.replace("visual.proj", "visual_projection.weight")
-    if "text_projection" in name:
-        name = name.replace("text_projection", "text_projection.weight")
-    # decoder
-    if "trans_conv" in name:
-        name = name.replace("trans_conv", "transposed_convolution")
-    if "film_mul" in name or "film_add" in name or "reduce" in name or "transposed_convolution" in name:
-        name = "decoder." + name
-    if "blocks" in name:
-        name = name.replace("blocks", "decoder.layers")
-    if "linear1" in name:
-        name = name.replace("linear1", "mlp.fc1")
-    if "linear2" in name:
-        name = name.replace("linear2", "mlp.fc2")
-    if "norm1" in name and "layer_" not in name:
-        name = name.replace("norm1", "layer_norm1")
-    if "norm2" in name and "layer_" not in name:
-        name = name.replace("norm2", "layer_norm2")
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, config):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if key.startswith("clip_model") and "attn.in_proj" in key:
-            key_split = key.split(".")
-            if "visual" in key:
-                layer_num = int(key_split[4])
-                dim = config.vision_config.hidden_size
-                prefix = "vision_model"
-            else:
-                layer_num = int(key_split[3])
-                dim = config.text_config.hidden_size
-                prefix = "text_model"
-
-            if "weight" in key:
-                orig_state_dict[f"clip.{prefix}.encoder.layers.{layer_num}.self_attn.q_proj.weight"] = val[:dim, :]
-                orig_state_dict[f"clip.{prefix}.encoder.layers.{layer_num}.self_attn.k_proj.weight"] = val[
-                    dim : dim * 2, :
-                ]
-                orig_state_dict[f"clip.{prefix}.encoder.layers.{layer_num}.self_attn.v_proj.weight"] = val[-dim:, :]
-            else:
-                orig_state_dict[f"clip.{prefix}.encoder.layers.{layer_num}.self_attn.q_proj.bias"] = val[:dim]
-                orig_state_dict[f"clip.{prefix}.encoder.layers.{layer_num}.self_attn.k_proj.bias"] = val[dim : dim * 2]
-                orig_state_dict[f"clip.{prefix}.encoder.layers.{layer_num}.self_attn.v_proj.bias"] = val[-dim:]
-        elif "self_attn" in key and "out_proj" not in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[1])
-            dim = config.reduce_dim
-            if "weight" in key:
-                orig_state_dict[f"decoder.layers.{layer_num}.self_attn.q_proj.weight"] = val[:dim, :]
-                orig_state_dict[f"decoder.layers.{layer_num}.self_attn.k_proj.weight"] = val[dim : dim * 2, :]
-                orig_state_dict[f"decoder.layers.{layer_num}.self_attn.v_proj.weight"] = val[-dim:, :]
-            else:
-                orig_state_dict[f"decoder.layers.{layer_num}.self_attn.q_proj.bias"] = val[:dim]
-                orig_state_dict[f"decoder.layers.{layer_num}.self_attn.k_proj.bias"] = val[dim : dim * 2]
-                orig_state_dict[f"decoder.layers.{layer_num}.self_attn.v_proj.bias"] = val[-dim:]
-        else:
-            new_name = rename_key(key)
-            if "visual_projection" in new_name or "text_projection" in new_name:
-                val = val.T
-            orig_state_dict[new_name] = val
-
-    return orig_state_dict
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-    return image
-
-
-def convert_clipseg_checkpoint(model_name, checkpoint_path, pytorch_dump_folder_path, push_to_hub):
-    config = get_clipseg_config(model_name)
-    model = CLIPSegForImageSegmentation(config)
-    model.eval()
-
-    state_dict = torch.load(checkpoint_path, map_location="cpu")
-
-    # remove some keys
-    for key in state_dict.copy().keys():
-        if key.startswith("model"):
-            state_dict.pop(key, None)
-
-    # rename some keys
-    state_dict = convert_state_dict(state_dict, config)
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-
-    if missing_keys != ["clip.text_model.embeddings.position_ids", "clip.vision_model.embeddings.position_ids"]:
-        raise ValueError("Missing keys that are not expected: {}".format(missing_keys))
-    if unexpected_keys != ["decoder.reduce.weight", "decoder.reduce.bias"]:
-        raise ValueError(f"Unexpected keys: {unexpected_keys}")
-
-    image_processor = ViTImageProcessor(size=352)
-    tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32")
-    processor = CLIPSegProcessor(image_processor=image_processor, tokenizer=tokenizer)
-
-    image = prepare_img()
-    text = ["a glass", "something to fill", "wood", "a jar"]
-
-    inputs = processor(text=text, images=[image] * len(text), padding="max_length", return_tensors="pt")
-
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    # verify values
-    expected_conditional = torch.tensor([0.1110, -0.1882, 0.1645])
-    expected_pooled_output = torch.tensor([0.2692, -0.7197, -0.1328])
-    if model_name == "clipseg-rd64-refined":
-        expected_masks_slice = torch.tensor(
-            [[-10.0407, -9.9431, -10.2646], [-9.9751, -9.7064, -9.9586], [-9.6891, -9.5645, -9.9618]]
-        )
-    elif model_name == "clipseg-rd64":
-        expected_masks_slice = torch.tensor(
-            [[-7.2877, -7.2711, -7.2463], [-7.2652, -7.2780, -7.2520], [-7.2239, -7.2204, -7.2001]]
-        )
-    elif model_name == "clipseg-rd16":
-        expected_masks_slice = torch.tensor(
-            [[-6.3955, -6.4055, -6.4151], [-6.3911, -6.4033, -6.4100], [-6.3474, -6.3702, -6.3762]]
-        )
-    else:
-        raise ValueError(f"Model name {model_name} not supported.")
-
-    assert torch.allclose(outputs.logits[0, :3, :3], expected_masks_slice, atol=1e-3)
-    assert torch.allclose(outputs.conditional_embeddings[0, :3], expected_conditional, atol=1e-3)
-    assert torch.allclose(outputs.pooled_output[0, :3], expected_pooled_output, atol=1e-3)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and processor for {model_name} to the hub")
-        model.push_to_hub(f"CIDAS/{model_name}")
-        processor.push_to_hub(f"CIDAS/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="clipseg-rd64",
-        type=str,
-        choices=["clipseg-rd16", "clipseg-rd64", "clipseg-rd64-refined"],
-        help=(
-            "Name of the model. Supported models are: clipseg-rd64, clipseg-rd16 and clipseg-rd64-refined (rd meaning"
-            " reduce dimension)"
-        ),
-    )
-    parser.add_argument(
-        "--checkpoint_path",
-        default="/Users/nielsrogge/Documents/CLIPSeg/clip_plus_rd64-uni.pth",
-        type=str,
-        help=(
-            "Path to the original checkpoint. Note that the script assumes that the checkpoint includes both CLIP and"
-            " the decoder weights."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_clipseg_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/clvp/convert_clvp_to_hf.py b/src/transformers/models/clvp/convert_clvp_to_hf.py
deleted file mode 100644
index 4ae6fd425497..000000000000
--- a/src/transformers/models/clvp/convert_clvp_to_hf.py
+++ /dev/null
@@ -1,234 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Weights conversion script for CLVP
-"""
-
-import argparse
-import os
-
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import ClvpConfig, ClvpModelForConditionalGeneration
-
-
-_MODELS = {
-    "clvp": "https://huggingface.co/jbetker/tortoise-tts-v2/blob/main/.models/clvp2.pth",
-    "decoder": "https://huggingface.co/jbetker/tortoise-tts-v2/blob/main/.models/autoregressive.pth",
-}
-
-dim = 1024
-sub_dim = dim // 16
-
-CLVP_ENCODERS_MAPPING = {
-    "text_transformer.transformer.attn_layers": "text_encoder_model",
-    "speech_transformer.transformer.attn_layers": "speech_encoder_model",
-    "text_transformer.transformer.norm": "text_encoder_model.final_layer_norm",
-    "speech_transformer.transformer.norm": "speech_encoder_model.final_layer_norm",
-    "to_text_latent": "text_encoder_model.projection",
-    "to_speech_latent": "speech_encoder_model.projection",
-    "text_emb": "text_encoder_model.token_embedding",
-    "speech_emb": "speech_encoder_model.token_embedding",
-    "1.wrap.net.0": "mlp.fc1",
-    "1.wrap.net.3": "mlp.fc2",
-    "1.wrap": "self_attn",
-    "to_out": "out_proj",
-    "to_q": "q_proj",
-    "to_k": "k_proj",
-    "to_v": "v_proj",
-    "temperature": "logit_scale",
-}
-
-CLVP_DECODER_MAPPING = {
-    "conditioning_encoder.init": "conditioning_encoder.mel_conv",
-    "conditioning_encoder.attn": "conditioning_encoder.mel_attn_blocks",
-    "mel_attn_blocks": "group_norms",
-    ".norm.weight": ".weight",
-    ".norm.bias": ".bias",
-    "text_embedding": "conditioning_encoder.text_token_embedding",
-    "text_pos_embedding.emb": "conditioning_encoder.text_position_embedding",
-    "final_norm": "speech_decoder_model.final_norm",
-    "mel_head": "speech_decoder_model.lm_head",
-    "gpt.ln_f": "speech_decoder_model.model.decoder.layer_norm",
-    "mel_embedding": "speech_decoder_model.model.decoder.input_embeds_layer",
-    "mel_pos_embedding.emb": "speech_decoder_model.model.decoder.position_embeds_layer",
-    "gpt.h": "speech_decoder_model.model.decoder.layers",
-    "ln_1": "input_layernorm",
-    "ln_2": "post_attention_layernorm",
-}
-
-
-def update_index(present_index):
-    if present_index % 2 == 0:
-        return int(present_index / 2)
-    else:
-        return int((present_index - 1) / 2)
-
-
-def convert_encoder_weights(original_weights):
-    converted_weights = {}
-    original_weights_keys = sorted(original_weights.keys())
-    for original_key in original_weights_keys:
-        updated_key = original_key
-        # for input_rmsnorm.weight and post_attention_rmsnorm.weight
-        if "0.0.g" in updated_key:
-            present_index = updated_key.split(".")[4]
-            if int(present_index) % 2 == 0:
-                updated_key = updated_key.replace("0.0.g", "input_rmsnorm.weight")
-            else:
-                updated_key = updated_key.replace("0.0.g", "post_attention_rmsnorm.weight")
-
-        if "transformer.attn_layers.layers" in updated_key:
-            present_index = updated_key.split(".")[4]
-            updated_index = update_index(int(present_index))
-            updated_key = updated_key.replace(
-                f"transformer.attn_layers.layers.{present_index}", f"transformer.attn_layers.layers.{updated_index}"
-            )
-
-        for k, v in CLVP_ENCODERS_MAPPING.items():
-            if k in updated_key:
-                updated_key = updated_key.replace(k, v)
-
-        converted_weights[updated_key] = original_weights.pop(original_key)
-
-    return converted_weights
-
-
-def convert_decoder_weights(original_weights):
-    converted_weights = {}
-    original_weights_keys = sorted(original_weights.keys())
-    for original_key in original_weights_keys:
-        updated_key = original_key
-        if len(updated_key.split(".")) > 3:
-            index, attr = updated_key.split(".")[2], updated_key.split(".")[-1]
-
-        # for decoder attention
-        if "attn.c_attn" in updated_key:
-            if attr == "weight":
-                slice1, slice2, slice3 = original_weights[updated_key].squeeze(-1).T.split(split_size=dim, dim=0)
-            else:
-                slice1, slice2, slice3 = original_weights[updated_key].split(split_size=dim, dim=0)
-            converted_weights[f"speech_decoder_model.model.decoder.layers.{index}.attn.q_proj.{attr}"] = slice1
-            converted_weights[f"speech_decoder_model.model.decoder.layers.{index}.attn.k_proj.{attr}"] = slice2
-            converted_weights[f"speech_decoder_model.model.decoder.layers.{index}.attn.v_proj.{attr}"] = slice3
-            continue
-
-        if "attn.c_proj" in updated_key:
-            converted_weights[f"speech_decoder_model.model.decoder.layers.{index}.attn.out_proj.{attr}"] = (
-                original_weights[updated_key].squeeze(-1).T
-            )
-            continue
-
-        if "attn.bias" in updated_key or "attn.masked_bias" in updated_key or "text_head" in updated_key:
-            original_weights.pop(updated_key)
-            continue
-
-        # conditional encoder attention
-        if "qkv" in updated_key:
-            if attr == "weight":
-                slice1, slice2, slice3 = original_weights[updated_key].squeeze(-1).split(split_size=dim, dim=0)
-            else:
-                slice1, slice2, slice3 = original_weights[updated_key].split(split_size=dim, dim=0)
-
-            indices = torch.arange(dim)
-            index1, index2, index3 = (
-                indices.unfold(0, sub_dim, sub_dim * 3).flatten(),
-                indices[sub_dim:].unfold(0, sub_dim, sub_dim * 3).flatten(),
-                indices[2 * sub_dim :].unfold(0, sub_dim, sub_dim * 3).flatten(),
-            )
-
-            converted_weights[f"conditioning_encoder.mel_attn_blocks.{index}.q_proj.{attr}"] = torch.concatenate(
-                [slice1[index1], slice2[index3], slice3[index2]],
-                axis=0,
-            )
-            converted_weights[f"conditioning_encoder.mel_attn_blocks.{index}.k_proj.{attr}"] = torch.concatenate(
-                [slice1[index2], slice2[index1], slice3[index3]],
-                axis=0,
-            )
-            converted_weights[f"conditioning_encoder.mel_attn_blocks.{index}.v_proj.{attr}"] = torch.concatenate(
-                [slice1[index3], slice2[index2], slice3[index1]],
-                axis=0,
-            )
-            continue
-
-        if "proj_out" in updated_key:
-            converted_weights[f"conditioning_encoder.mel_attn_blocks.{index}.out_proj.{attr}"] = original_weights[
-                updated_key
-            ].squeeze(-1)
-            continue
-
-        for k, v in CLVP_DECODER_MAPPING.items():
-            if k in updated_key:
-                updated_key = updated_key.replace(k, v)
-
-        converted_weights[updated_key] = original_weights.pop(original_key)
-
-    return converted_weights
-
-
-def _download(url: str, root: str):
-    repo_id = f"{url.split('/')[3]}/{url.split('/')[4]}"
-    filename = f"{url.split('/')[-2]}/{url.split('/')[-1]}"
-    hf_hub_download(
-        repo_id=repo_id,
-        filename=filename,
-        force_filename=root,
-        local_dir_use_symlinks=False,
-    )
-
-
-def convert_clvp_weights(checkpoint_path, pytorch_dump_folder_path):
-    converted_checkpoint = {}
-
-    for each_model_name, each_model_url in _MODELS.items():
-        each_model_path = os.path.join(checkpoint_path, each_model_url.split("/")[-1])
-        if not os.path.exists(each_model_path):
-            print(f"\n{each_model_name} was not found! Downloading it to {each_model_path}")
-            _download(url=each_model_url, root=each_model_path)
-
-        if each_model_name == "clvp":
-            clvp_checkpoint = torch.load(each_model_path, map_location="cpu")
-        else:
-            decoder_checkpoint = torch.load(each_model_path, map_location="cpu")
-
-    # Converting the weights
-    converted_checkpoint.update(**convert_encoder_weights(clvp_checkpoint))
-    converted_checkpoint.update(**convert_decoder_weights(decoder_checkpoint))
-
-    config = ClvpConfig.from_pretrained("susnato/clvp_dev")
-    model = ClvpModelForConditionalGeneration(config)
-
-    model.load_state_dict(converted_checkpoint, strict=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Model saved at {pytorch_dump_folder_path}!")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # # Required parameters
-    parser.add_argument(
-        "--checkpoint_path", type=str, help="Path to the folder of downloaded checkpoints. (Please enter full path)"
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model. (Please enter full path)",
-    )
-    args = parser.parse_args()
-
-    convert_clvp_weights(args.checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/colpali/convert_colpali_weights_to_hf.py b/src/transformers/models/colpali/convert_colpali_weights_to_hf.py
deleted file mode 100644
index 1b30f3f97acd..000000000000
--- a/src/transformers/models/colpali/convert_colpali_weights_to_hf.py
+++ /dev/null
@@ -1,214 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Convert ColPali weights from the original repository to the HF model format.
-
-Original repository: https://github.com/illuin-tech/colpali.
-
-NOTE: This script was originally run using `torch==2.5.1` and with:
-
-```bash
-python src/transformers/models/colpali/convert_colpali_weights_to_hf.py \
-    --model_id vidore/colpali-v1.2-merged \
-    --revision 89fd9736194236a1ecb7a9ec9b04f537f6f896af \
-    --original_vlm_name_or_path google/paligemma-3b-mix-448 \
-    --output_dir vidore/colpali-v1.2-hf-internal \
-    --push_to_hub
-
-python src/transformers/models/colpali/convert_colpali_weights_to_hf.py \
-    --model_id vidore/colpali-v1.3-merged \
-    --revision 5b955e3415a7c5468ab33119d98d6d45c3a5b2c3 \
-    --original_vlm_name_or_path google/paligemma-3b-mix-448 \
-    --output_dir vidore/colpali-v1.3-hf \
-    --push_to_hub
-```
-"""
-
-import argparse
-import glob
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-import torch
-from huggingface_hub import snapshot_download
-from safetensors import safe_open
-
-from transformers import AutoConfig
-from transformers.models.colpali import ColPaliForRetrieval
-from transformers.models.colpali.configuration_colpali import ColPaliConfig
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-ORIGINAL_DTYPE = torch.bfloat16
-
-
-def rename_state_dict_keys(state_dict: Dict[str, Any]) -> Dict[str, Any]:
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        new_key = key
-        if key.startswith("custom_text_proj"):
-            new_key = key.replace("custom_text_proj", "embedding_proj_layer")
-        if key.startswith("model."):
-            new_key = key.replace("model.", "vlm.", 1)
-        new_state_dict[new_key] = value
-    return new_state_dict
-
-
-def load_original_state_dict(model_id: str, revision: Optional[str] = None) -> Dict[str, torch.Tensor]:
-    directory_path = snapshot_download(
-        repo_id=model_id,
-        revision=revision,
-        allow_patterns=["*.safetensors"],
-    )
-
-    original_state_dict = {}
-    for path in glob.glob(f"{directory_path}/*"):
-        if path.endswith(".safetensors"):
-            with safe_open(path, framework="pt", device="cpu") as f:
-                for key in f.keys():
-                    original_state_dict[key] = f.get_tensor(key)
-
-    # Some weights are tied, so `lm.head`` is not saved. Let's clone to load state dict.
-    if "lm_head.weight" not in original_state_dict:
-        original_state_dict["vlm.language_model.lm_head.weight"] = original_state_dict[
-            "model.language_model.model.embed_tokens.weight"
-        ].clone()
-
-    return original_state_dict
-
-
-@torch.no_grad()
-def convert_colpali_weights_to_hf(
-    model_id: str,
-    output_dir: str,
-    push_to_hub: bool,
-    revision: Optional[str] = None,
-    original_vlm_name_or_path: Optional[str] = None,
-):
-    # Load the original model data
-    original_config = AutoConfig.from_pretrained(
-        model_id,
-        revision=revision,
-    )
-    if original_vlm_name_or_path is not None:
-        original_config._name_or_path = original_vlm_name_or_path
-    if hasattr(original_config, "architectures"):
-        delattr(original_config, "architectures")
-
-    original_state_dict = load_original_state_dict(model_id, revision=revision)
-
-    # Format the state_dict keys
-    original_state_dict = rename_state_dict_keys(original_state_dict)
-
-    # Create the new config
-    config = ColPaliConfig(
-        vlm_config=original_config,
-        embedding_dim=128,  # hardcoded in the original model
-    )
-    config.model_type = "colpali"
-    config.is_composition = False
-
-    # Load the untrained model
-    model = ColPaliForRetrieval(config=config).to("cpu").eval()
-    print("Created model with new config and randomly initialized weights")
-
-    # NOTE: The model was initialized with float32 weights. We need to convert it to the desired precision.
-    # There are two ways to set the model's dtype:
-    # - Using `model.from_pretrained(..., torch_dtype=dtype_precision)` doesn't convert the hyperparameters to the desired precision.
-    # - Using `model.to(dtype_precision)` converts all values - including the hyperparameters - to the desired precision.
-    # The following snippet allows a fine-grained control over the model's dtype, making sure that all
-    # the new weights' dtypes match the original model.
-    for param in model.parameters():
-        param.data = param.data.to(ORIGINAL_DTYPE)
-    print(f"Converted the new model weights to `{ORIGINAL_DTYPE}`")
-
-    # Load the original weights
-    model.load_state_dict(original_state_dict)
-    print("Loaded original model weights")
-
-    # Tie the weights (following ColPali's `__init__`` step)
-    if model.vlm.language_model._tied_weights_keys is not None:
-        model._tied_weights_keys = [f"vlm.language_model.{k}" for k in model.vlm.language_model._tied_weights_keys]
-
-    # Sanity check: ensure all keys are the same
-    state_dict_keys_old = set(original_state_dict.keys())
-    state_dict_keys_new = set(model.state_dict().keys())
-    disjoint_keys = state_dict_keys_old.symmetric_difference(state_dict_keys_new)
-    if disjoint_keys:
-        raise ValueError(f"Incompatible keys: {disjoint_keys}")
-
-    # Save the model
-    if push_to_hub:
-        model.push_to_hub(output_dir, private=True)
-        print(f"Model pushed to the hub at `{output_dir}`")
-    else:
-        Path(output_dir).mkdir(exist_ok=True, parents=True)
-        model.save_pretrained(output_dir)
-        print(f"Model saved to `{output_dir}`")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="""
-        This script converts the original ColPali model to the HF model format.
-
-        Example usage:
-        ```bash
-        python src/transformers/models/colpali/convert_colpali_weights_to_hf.py \
-            --model_id vidore/colpali-v1.2-merged \
-            --revision 89fd9736194236a1ecb7a9ec9b04f537f6f896af \
-            --original_vlm_name_or_path google/paligemma-3b-mix-448 \
-            --output_dir vidore/colpali-v1.2-hf \
-            --push_to_hub
-        ```
-        """
-    )
-    parser.add_argument(
-        "--model_id",
-        help="Model ID of the original model to convert",
-    )
-    parser.add_argument(
-        "--output_dir",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        help="Whether or not to push the model to the hub at `output_dir` instead of saving it locally",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--revision",
-        help="Revision of the model to download",
-        default=None,
-    )
-    parser.add_argument(
-        "--original_vlm_name_or_path",
-        help="Name or path of the original VLM backbone model",
-        default=None,
-    )
-    args = parser.parse_args()
-
-    convert_colpali_weights_to_hf(
-        model_id=args.model_id,
-        output_dir=args.output_dir,
-        push_to_hub=args.push_to_hub,
-        revision=args.revision,
-        original_vlm_name_or_path=args.original_vlm_name_or_path,
-    )
diff --git a/src/transformers/models/conditional_detr/convert_conditional_detr_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/conditional_detr/convert_conditional_detr_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 91f00668be69..000000000000
--- a/src/transformers/models/conditional_detr/convert_conditional_detr_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,324 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Conditional DETR checkpoints."""
-
-import argparse
-import json
-from collections import OrderedDict
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    ConditionalDetrConfig,
-    ConditionalDetrForObjectDetection,
-    ConditionalDetrForSegmentation,
-    ConditionalDetrImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-rename_keys = []
-for i in range(6):
-    # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.self_attn.out_proj.weight", f"encoder.layers.{i}.self_attn.out_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.self_attn.out_proj.bias", f"encoder.layers.{i}.self_attn.out_proj.bias")
-    )
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear1.weight", f"encoder.layers.{i}.fc1.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear1.bias", f"encoder.layers.{i}.fc1.bias"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear2.weight", f"encoder.layers.{i}.fc2.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear2.bias", f"encoder.layers.{i}.fc2.bias"))
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.norm1.weight", f"encoder.layers.{i}.self_attn_layer_norm.weight")
-    )
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm1.bias", f"encoder.layers.{i}.self_attn_layer_norm.bias"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm2.weight", f"encoder.layers.{i}.final_layer_norm.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm2.bias", f"encoder.layers.{i}.final_layer_norm.bias"))
-    # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.self_attn.out_proj.weight", f"decoder.layers.{i}.self_attn.out_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.self_attn.out_proj.bias", f"decoder.layers.{i}.self_attn.out_proj.bias")
-    )
-    rename_keys.append(
-        (
-            f"transformer.decoder.layers.{i}.cross_attn.out_proj.weight",
-            f"decoder.layers.{i}.encoder_attn.out_proj.weight",
-        )
-    )
-    rename_keys.append(
-        (
-            f"transformer.decoder.layers.{i}.cross_attn.out_proj.bias",
-            f"decoder.layers.{i}.encoder_attn.out_proj.bias",
-        )
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear1.weight", f"decoder.layers.{i}.fc1.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear1.bias", f"decoder.layers.{i}.fc1.bias"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear2.weight", f"decoder.layers.{i}.fc2.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear2.bias", f"decoder.layers.{i}.fc2.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm1.weight", f"decoder.layers.{i}.self_attn_layer_norm.weight")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm1.bias", f"decoder.layers.{i}.self_attn_layer_norm.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm2.weight", f"decoder.layers.{i}.encoder_attn_layer_norm.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm2.bias", f"decoder.layers.{i}.encoder_attn_layer_norm.bias")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm3.weight", f"decoder.layers.{i}.final_layer_norm.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm3.bias", f"decoder.layers.{i}.final_layer_norm.bias"))
-
-    # q, k, v projections in self/cross-attention in decoder for conditional DETR
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.sa_qcontent_proj.weight", f"decoder.layers.{i}.sa_qcontent_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.sa_kcontent_proj.weight", f"decoder.layers.{i}.sa_kcontent_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.sa_qpos_proj.weight", f"decoder.layers.{i}.sa_qpos_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.sa_kpos_proj.weight", f"decoder.layers.{i}.sa_kpos_proj.weight")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.sa_v_proj.weight", f"decoder.layers.{i}.sa_v_proj.weight"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.ca_qcontent_proj.weight", f"decoder.layers.{i}.ca_qcontent_proj.weight")
-    )
-    # rename_keys.append((f"transformer.decoder.layers.{i}.ca_qpos_proj.weight", f"decoder.layers.{i}.ca_qpos_proj.weight"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.ca_kcontent_proj.weight", f"decoder.layers.{i}.ca_kcontent_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.ca_kpos_proj.weight", f"decoder.layers.{i}.ca_kpos_proj.weight")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.ca_v_proj.weight", f"decoder.layers.{i}.ca_v_proj.weight"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.ca_qpos_sine_proj.weight", f"decoder.layers.{i}.ca_qpos_sine_proj.weight")
-    )
-
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.sa_qcontent_proj.bias", f"decoder.layers.{i}.sa_qcontent_proj.bias")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.sa_kcontent_proj.bias", f"decoder.layers.{i}.sa_kcontent_proj.bias")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.sa_qpos_proj.bias", f"decoder.layers.{i}.sa_qpos_proj.bias"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.sa_kpos_proj.bias", f"decoder.layers.{i}.sa_kpos_proj.bias"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.sa_v_proj.bias", f"decoder.layers.{i}.sa_v_proj.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.ca_qcontent_proj.bias", f"decoder.layers.{i}.ca_qcontent_proj.bias")
-    )
-    # rename_keys.append((f"transformer.decoder.layers.{i}.ca_qpos_proj.bias", f"decoder.layers.{i}.ca_qpos_proj.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.ca_kcontent_proj.bias", f"decoder.layers.{i}.ca_kcontent_proj.bias")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.ca_kpos_proj.bias", f"decoder.layers.{i}.ca_kpos_proj.bias"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.ca_v_proj.bias", f"decoder.layers.{i}.ca_v_proj.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.ca_qpos_sine_proj.bias", f"decoder.layers.{i}.ca_qpos_sine_proj.bias")
-    )
-
-# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
-# for conditional DETR, also convert reference point head and query scale MLP
-rename_keys.extend(
-    [
-        ("input_proj.weight", "input_projection.weight"),
-        ("input_proj.bias", "input_projection.bias"),
-        ("query_embed.weight", "query_position_embeddings.weight"),
-        ("transformer.decoder.norm.weight", "decoder.layernorm.weight"),
-        ("transformer.decoder.norm.bias", "decoder.layernorm.bias"),
-        ("class_embed.weight", "class_labels_classifier.weight"),
-        ("class_embed.bias", "class_labels_classifier.bias"),
-        ("bbox_embed.layers.0.weight", "bbox_predictor.layers.0.weight"),
-        ("bbox_embed.layers.0.bias", "bbox_predictor.layers.0.bias"),
-        ("bbox_embed.layers.1.weight", "bbox_predictor.layers.1.weight"),
-        ("bbox_embed.layers.1.bias", "bbox_predictor.layers.1.bias"),
-        ("bbox_embed.layers.2.weight", "bbox_predictor.layers.2.weight"),
-        ("bbox_embed.layers.2.bias", "bbox_predictor.layers.2.bias"),
-        ("transformer.decoder.ref_point_head.layers.0.weight", "decoder.ref_point_head.layers.0.weight"),
-        ("transformer.decoder.ref_point_head.layers.0.bias", "decoder.ref_point_head.layers.0.bias"),
-        ("transformer.decoder.ref_point_head.layers.1.weight", "decoder.ref_point_head.layers.1.weight"),
-        ("transformer.decoder.ref_point_head.layers.1.bias", "decoder.ref_point_head.layers.1.bias"),
-        ("transformer.decoder.query_scale.layers.0.weight", "decoder.query_scale.layers.0.weight"),
-        ("transformer.decoder.query_scale.layers.0.bias", "decoder.query_scale.layers.0.bias"),
-        ("transformer.decoder.query_scale.layers.1.weight", "decoder.query_scale.layers.1.weight"),
-        ("transformer.decoder.query_scale.layers.1.bias", "decoder.query_scale.layers.1.bias"),
-        ("transformer.decoder.layers.0.ca_qpos_proj.weight", "decoder.layers.0.ca_qpos_proj.weight"),
-        ("transformer.decoder.layers.0.ca_qpos_proj.bias", "decoder.layers.0.ca_qpos_proj.bias"),
-    ]
-)
-
-
-def rename_key(state_dict, old, new):
-    val = state_dict.pop(old)
-    state_dict[new] = val
-
-
-def rename_backbone_keys(state_dict):
-    new_state_dict = OrderedDict()
-    for key, value in state_dict.items():
-        if "backbone.0.body" in key:
-            new_key = key.replace("backbone.0.body", "backbone.conv_encoder.model")
-            new_state_dict[new_key] = value
-        else:
-            new_state_dict[key] = value
-
-    return new_state_dict
-
-
-def read_in_q_k_v(state_dict, is_panoptic=False):
-    prefix = ""
-    if is_panoptic:
-        prefix = "conditional_detr."
-
-    # first: transformer encoder
-    for i in range(6):
-        # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-
-    return im
-
-
-@torch.no_grad()
-def convert_conditional_detr_checkpoint(model_name, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our CONDITIONAL_DETR structure.
-    """
-
-    # load default config
-    config = ConditionalDetrConfig()
-    # set backbone and dilation attributes
-    if "resnet101" in model_name:
-        config.backbone = "resnet101"
-    if "dc5" in model_name:
-        config.dilation = True
-    is_panoptic = "panoptic" in model_name
-    if is_panoptic:
-        config.num_labels = 250
-    else:
-        config.num_labels = 91
-        repo_id = "huggingface/label-files"
-        filename = "coco-detection-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    # load image processor
-    format = "coco_panoptic" if is_panoptic else "coco_detection"
-    image_processor = ConditionalDetrImageProcessor(format=format)
-
-    # prepare image
-    img = prepare_img()
-    encoding = image_processor(images=img, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    logger.info(f"Converting model {model_name}...")
-
-    # load original model from torch hub
-    conditional_detr = torch.hub.load("DeppMeng/ConditionalDETR", model_name, pretrained=True).eval()
-    state_dict = conditional_detr.state_dict()
-    # rename keys
-    for src, dest in rename_keys:
-        if is_panoptic:
-            src = "conditional_detr." + src
-        rename_key(state_dict, src, dest)
-    state_dict = rename_backbone_keys(state_dict)
-    # query, key and value matrices need special treatment
-    read_in_q_k_v(state_dict, is_panoptic=is_panoptic)
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    prefix = "conditional_detr.model." if is_panoptic else "model."
-    for key in state_dict.copy().keys():
-        if is_panoptic:
-            if (
-                key.startswith("conditional_detr")
-                and not key.startswith("class_labels_classifier")
-                and not key.startswith("bbox_predictor")
-            ):
-                val = state_dict.pop(key)
-                state_dict["conditional_detr.model" + key[4:]] = val
-            elif "class_labels_classifier" in key or "bbox_predictor" in key:
-                val = state_dict.pop(key)
-                state_dict["conditional_detr." + key] = val
-            elif key.startswith("bbox_attention") or key.startswith("mask_head"):
-                continue
-            else:
-                val = state_dict.pop(key)
-                state_dict[prefix + key] = val
-        else:
-            if not key.startswith("class_labels_classifier") and not key.startswith("bbox_predictor"):
-                val = state_dict.pop(key)
-                state_dict[prefix + key] = val
-    # finally, create HuggingFace model and load state dict
-    model = ConditionalDetrForSegmentation(config) if is_panoptic else ConditionalDetrForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-    model.push_to_hub(repo_id=model_name, organization="DepuMeng", commit_message="Add model")
-    # verify our conversion
-    original_outputs = conditional_detr(pixel_values)
-    outputs = model(pixel_values)
-    assert torch.allclose(outputs.logits, original_outputs["pred_logits"], atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes, original_outputs["pred_boxes"], atol=1e-4)
-    if is_panoptic:
-        assert torch.allclose(outputs.pred_masks, original_outputs["pred_masks"], atol=1e-4)
-
-    # Save model and image processor
-    logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--model_name",
-        default="conditional_detr_resnet50",
-        type=str,
-        help="Name of the CONDITIONAL_DETR model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_conditional_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/convbert/convert_convbert_original_tf1_checkpoint_to_pytorch_and_tf2.py b/src/transformers/models/convbert/convert_convbert_original_tf1_checkpoint_to_pytorch_and_tf2.py
deleted file mode 100644
index 3d4ff779874b..000000000000
--- a/src/transformers/models/convbert/convert_convbert_original_tf1_checkpoint_to_pytorch_and_tf2.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ConvBERT checkpoint."""
-
-import argparse
-
-from transformers import ConvBertConfig, ConvBertModel, TFConvBertModel, load_tf_weights_in_convbert
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_orig_tf1_checkpoint_to_pytorch(tf_checkpoint_path, convbert_config_file, pytorch_dump_path):
-    conf = ConvBertConfig.from_json_file(convbert_config_file)
-    model = ConvBertModel(conf)
-
-    model = load_tf_weights_in_convbert(model, conf, tf_checkpoint_path)
-    model.save_pretrained(pytorch_dump_path)
-
-    tf_model = TFConvBertModel.from_pretrained(pytorch_dump_path, from_pt=True)
-    tf_model.save_pretrained(pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--convbert_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained ConvBERT model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_orig_tf1_checkpoint_to_pytorch(args.tf_checkpoint_path, args.convbert_config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/convnext/convert_convnext_to_pytorch.py b/src/transformers/models/convnext/convert_convnext_to_pytorch.py
deleted file mode 100644
index 27315ed73f91..000000000000
--- a/src/transformers/models/convnext/convert_convnext_to_pytorch.py
+++ /dev/null
@@ -1,242 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ConvNext checkpoints from the original repository.
-
-URL: https://github.com/facebookresearch/ConvNeXt"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import ConvNextConfig, ConvNextForImageClassification, ConvNextImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_convnext_config(checkpoint_url):
-    config = ConvNextConfig()
-
-    if "tiny" in checkpoint_url:
-        depths = [3, 3, 9, 3]
-        hidden_sizes = [96, 192, 384, 768]
-    if "small" in checkpoint_url:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [96, 192, 384, 768]
-    if "base" in checkpoint_url:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [128, 256, 512, 1024]
-    if "large" in checkpoint_url:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [192, 384, 768, 1536]
-    if "xlarge" in checkpoint_url:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [256, 512, 1024, 2048]
-
-    if "1k" in checkpoint_url:
-        num_labels = 1000
-        filename = "imagenet-1k-id2label.json"
-        expected_shape = (1, 1000)
-    else:
-        num_labels = 21841
-        filename = "imagenet-22k-id2label.json"
-        expected_shape = (1, 21841)
-
-    repo_id = "huggingface/label-files"
-    config.num_labels = num_labels
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    if "1k" not in checkpoint_url:
-        # this dataset contains 21843 labels but the model only has 21841
-        # we delete the classes as mentioned in https://github.com/google-research/big_transfer/issues/18
-        del id2label[9205]
-        del id2label[15027]
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-    config.hidden_sizes = hidden_sizes
-    config.depths = depths
-
-    return config, expected_shape
-
-
-def rename_key(name):
-    if "downsample_layers.0.0" in name:
-        name = name.replace("downsample_layers.0.0", "embeddings.patch_embeddings")
-    if "downsample_layers.0.1" in name:
-        name = name.replace("downsample_layers.0.1", "embeddings.norm")  # we rename to layernorm later on
-    if "downsample_layers.1.0" in name:
-        name = name.replace("downsample_layers.1.0", "stages.1.downsampling_layer.0")
-    if "downsample_layers.1.1" in name:
-        name = name.replace("downsample_layers.1.1", "stages.1.downsampling_layer.1")
-    if "downsample_layers.2.0" in name:
-        name = name.replace("downsample_layers.2.0", "stages.2.downsampling_layer.0")
-    if "downsample_layers.2.1" in name:
-        name = name.replace("downsample_layers.2.1", "stages.2.downsampling_layer.1")
-    if "downsample_layers.3.0" in name:
-        name = name.replace("downsample_layers.3.0", "stages.3.downsampling_layer.0")
-    if "downsample_layers.3.1" in name:
-        name = name.replace("downsample_layers.3.1", "stages.3.downsampling_layer.1")
-    if "stages" in name and "downsampling_layer" not in name:
-        # stages.0.0. for instance should be renamed to stages.0.layers.0.
-        name = name[: len("stages.0")] + ".layers" + name[len("stages.0") :]
-    if "stages" in name:
-        name = name.replace("stages", "encoder.stages")
-    if "norm" in name:
-        name = name.replace("norm", "layernorm")
-    if "gamma" in name:
-        name = name.replace("gamma", "layer_scale_parameter")
-    if "head" in name:
-        name = name.replace("head", "classifier")
-
-    return name
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_convnext_checkpoint(checkpoint_url, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our ConvNext structure.
-    """
-
-    # define ConvNext configuration based on URL
-    config, expected_shape = get_convnext_config(checkpoint_url)
-    # load original state_dict from URL
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url)["model"]
-    # rename keys
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        state_dict[rename_key(key)] = val
-    # add prefix to all keys expect classifier head
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        if not key.startswith("classifier"):
-            key = "convnext." + key
-        state_dict[key] = val
-
-    # load HuggingFace model
-    model = ConvNextForImageClassification(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # Check outputs on an image, prepared by ConvNextImageProcessor
-    size = 224 if "224" in checkpoint_url else 384
-    image_processor = ConvNextImageProcessor(size=size)
-    pixel_values = image_processor(images=prepare_img(), return_tensors="pt").pixel_values
-
-    logits = model(pixel_values).logits
-
-    # note: the logits below were obtained without center cropping
-    if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth":
-        expected_logits = torch.tensor([-0.1210, -0.6605, 0.1918])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_small_1k_224_ema.pth":
-        expected_logits = torch.tensor([-0.4473, -0.1847, -0.6365])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_224_ema.pth":
-        expected_logits = torch.tensor([0.4525, 0.7539, 0.0308])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_384.pth":
-        expected_logits = torch.tensor([0.3561, 0.6350, -0.0384])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_224_ema.pth":
-        expected_logits = torch.tensor([0.4174, -0.0989, 0.1489])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_384.pth":
-        expected_logits = torch.tensor([0.2513, -0.1349, -0.1613])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_224.pth":
-        expected_logits = torch.tensor([1.2980, 0.3631, -0.1198])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_224.pth":
-        expected_logits = torch.tensor([1.2963, 0.1227, 0.1723])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_224.pth":
-        expected_logits = torch.tensor([1.7956, 0.8390, 0.2820])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_224.pth":
-        expected_logits = torch.tensor([-0.2822, -0.0502, -0.0878])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_384.pth":
-        expected_logits = torch.tensor([-0.5672, -0.0730, -0.4348])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_224.pth":
-        expected_logits = torch.tensor([0.2681, 0.2365, 0.6246])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_384.pth":
-        expected_logits = torch.tensor([-0.2642, 0.3931, 0.5116])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_224_ema.pth":
-        expected_logits = torch.tensor([-0.6677, -0.1873, -0.8379])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_384_ema.pth":
-        expected_logits = torch.tensor([-0.7749, -0.2967, -0.6444])
-    else:
-        raise ValueError(f"Unknown URL: {checkpoint_url}")
-
-    assert torch.allclose(logits[0, :3], expected_logits, atol=1e-3)
-    assert logits.shape == expected_shape
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    print("Pushing model to the hub...")
-    model_name = "convnext"
-    if "tiny" in checkpoint_url:
-        model_name += "-tiny"
-    elif "small" in checkpoint_url:
-        model_name += "-small"
-    elif "base" in checkpoint_url:
-        model_name += "-base"
-    elif "xlarge" in checkpoint_url:
-        model_name += "-xlarge"
-    elif "large" in checkpoint_url:
-        model_name += "-large"
-    if "224" in checkpoint_url:
-        model_name += "-224"
-    elif "384" in checkpoint_url:
-        model_name += "-384"
-    if "22k" in checkpoint_url and "1k" not in checkpoint_url:
-        model_name += "-22k"
-    if "22k" in checkpoint_url and "1k" in checkpoint_url:
-        model_name += "-22k-1k"
-
-    model.push_to_hub(
-        repo_path_or_name=Path(pytorch_dump_folder_path, model_name),
-        organization="nielsr",
-        commit_message="Add model",
-    )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth",
-        type=str,
-        help="URL of the original ConvNeXT checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the output PyTorch model directory.",
-    )
-
-    args = parser.parse_args()
-    convert_convnext_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/convnextv2/convert_convnextv2_to_pytorch.py b/src/transformers/models/convnextv2/convert_convnextv2_to_pytorch.py
deleted file mode 100644
index 8094ecf0d615..000000000000
--- a/src/transformers/models/convnextv2/convert_convnextv2_to_pytorch.py
+++ /dev/null
@@ -1,286 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ConvNeXTV2 checkpoints from the original repository.
-
-URL: https://github.com/facebookresearch/ConvNeXt"""
-
-import argparse
-import json
-import os
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import ConvNextImageProcessor, ConvNextV2Config, ConvNextV2ForImageClassification
-from transformers.image_utils import PILImageResampling
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_convnextv2_config(checkpoint_url):
-    config = ConvNextV2Config()
-
-    if "atto" in checkpoint_url:
-        depths = [2, 2, 6, 2]
-        hidden_sizes = [40, 80, 160, 320]
-    if "femto" in checkpoint_url:
-        depths = [2, 2, 6, 2]
-        hidden_sizes = [48, 96, 192, 384]
-    if "pico" in checkpoint_url:
-        depths = [2, 2, 6, 2]
-        hidden_sizes = [64, 128, 256, 512]
-    if "nano" in checkpoint_url:
-        depths = [2, 2, 8, 2]
-        hidden_sizes = [80, 160, 320, 640]
-    if "tiny" in checkpoint_url:
-        depths = [3, 3, 9, 3]
-        hidden_sizes = [96, 192, 384, 768]
-    if "base" in checkpoint_url:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [128, 256, 512, 1024]
-    if "large" in checkpoint_url:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [192, 384, 768, 1536]
-    if "huge" in checkpoint_url:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [352, 704, 1408, 2816]
-
-    num_labels = 1000
-    filename = "imagenet-1k-id2label.json"
-    expected_shape = (1, 1000)
-
-    repo_id = "huggingface/label-files"
-    config.num_labels = num_labels
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-    config.hidden_sizes = hidden_sizes
-    config.depths = depths
-
-    return config, expected_shape
-
-
-def rename_key(name):
-    if "downsample_layers.0.0" in name:
-        name = name.replace("downsample_layers.0.0", "embeddings.patch_embeddings")
-    if "downsample_layers.0.1" in name:
-        name = name.replace("downsample_layers.0.1", "embeddings.norm")  # we rename to layernorm later on
-    if "downsample_layers.1.0" in name:
-        name = name.replace("downsample_layers.1.0", "stages.1.downsampling_layer.0")
-    if "downsample_layers.1.1" in name:
-        name = name.replace("downsample_layers.1.1", "stages.1.downsampling_layer.1")
-    if "downsample_layers.2.0" in name:
-        name = name.replace("downsample_layers.2.0", "stages.2.downsampling_layer.0")
-    if "downsample_layers.2.1" in name:
-        name = name.replace("downsample_layers.2.1", "stages.2.downsampling_layer.1")
-    if "downsample_layers.3.0" in name:
-        name = name.replace("downsample_layers.3.0", "stages.3.downsampling_layer.0")
-    if "downsample_layers.3.1" in name:
-        name = name.replace("downsample_layers.3.1", "stages.3.downsampling_layer.1")
-    if "stages" in name and "downsampling_layer" not in name:
-        # stages.0.0. for instance should be renamed to stages.0.layers.0.
-        name = name[: len("stages.0")] + ".layers" + name[len("stages.0") :]
-    if "gamma" in name:
-        name = name.replace("gamma", "weight")
-    if "beta" in name:
-        name = name.replace("beta", "bias")
-    if "stages" in name:
-        name = name.replace("stages", "encoder.stages")
-    if "norm" in name:
-        name = name.replace("norm", "layernorm")
-    if "head" in name:
-        name = name.replace("head", "classifier")
-
-    return name
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-def convert_preprocessor(checkpoint_url):
-    if "224" in checkpoint_url:
-        size = 224
-        crop_pct = 224 / 256
-    elif "384" in checkpoint_url:
-        size = 384
-        crop_pct = None
-    else:
-        size = 512
-        crop_pct = None
-
-    return ConvNextImageProcessor(
-        size=size,
-        crop_pct=crop_pct,
-        image_mean=[0.485, 0.456, 0.406],
-        image_std=[0.229, 0.224, 0.225],
-        resample=PILImageResampling.BICUBIC,
-    )
-
-
-@torch.no_grad()
-def convert_convnextv2_checkpoint(checkpoint_url, pytorch_dump_folder_path, save_model, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our ConvNeXTV2 structure.
-    """
-    print("Downloading original model from checkpoint...")
-    # define ConvNeXTV2 configuration based on URL
-    config, expected_shape = get_convnextv2_config(checkpoint_url)
-    # load original state_dict from URL
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url)["model"]
-
-    print("Converting model parameters...")
-    # rename keys
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        state_dict[rename_key(key)] = val
-    # add prefix to all keys expect classifier head
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        if not key.startswith("classifier"):
-            key = "convnextv2." + key
-        state_dict[key] = val
-
-    # load HuggingFace model
-    model = ConvNextV2ForImageClassification(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # Check outputs on an image, prepared by ConvNextImageProcessor
-    preprocessor = convert_preprocessor(checkpoint_url)
-    inputs = preprocessor(images=prepare_img(), return_tensors="pt")
-    logits = model(**inputs).logits
-
-    # note: the logits below were obtained without center cropping
-    if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt":
-        expected_logits = torch.tensor([-0.3930, 0.1747, -0.5246, 0.4177, 0.4295])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_femto_1k_224_ema.pt":
-        expected_logits = torch.tensor([-0.1727, -0.5341, -0.7818, -0.4745, -0.6566])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_pico_1k_224_ema.pt":
-        expected_logits = torch.tensor([-0.0333, 0.1563, -0.9137, 0.1054, 0.0381])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_nano_1k_224_ema.pt":
-        expected_logits = torch.tensor([-0.1744, -0.1555, -0.0713, 0.0950, -0.1431])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_tiny_1k_224_ema.pt":
-        expected_logits = torch.tensor([0.9996, 0.1966, -0.4386, -0.3472, 0.6661])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_base_1k_224_ema.pt":
-        expected_logits = torch.tensor([-0.2553, -0.6708, -0.1359, 0.2518, -0.2488])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_large_1k_224_ema.pt":
-        expected_logits = torch.tensor([-0.0673, -0.5627, -0.3753, -0.2722, 0.0178])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_huge_1k_224_ema.pt":
-        expected_logits = torch.tensor([-0.6377, -0.7458, -0.2150, 0.1184, -0.0597])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_224_ema.pt":
-        expected_logits = torch.tensor([1.0799, 0.2322, -0.8860, 1.0219, 0.6231])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_384_ema.pt":
-        expected_logits = torch.tensor([0.3766, 0.4917, -1.1426, 0.9942, 0.6024])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_224_ema.pt":
-        expected_logits = torch.tensor([0.4220, -0.6919, -0.4317, -0.2881, -0.6609])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_384_ema.pt":
-        expected_logits = torch.tensor([0.1082, -0.8286, -0.5095, 0.4681, -0.8085])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_224_ema.pt":
-        expected_logits = torch.tensor([-0.2419, -0.6221, 0.2176, -0.0980, -0.7527])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_384_ema.pt":
-        expected_logits = torch.tensor([0.0391, -0.4371, 0.3786, 0.1251, -0.2784])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_224_ema.pt":
-        expected_logits = torch.tensor([-0.0504, 0.5636, -0.1729, -0.6507, -0.3949])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_384_ema.pt":
-        expected_logits = torch.tensor([0.3560, 0.9486, 0.3149, -0.2667, -0.5138])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_384_ema.pt":
-        expected_logits = torch.tensor([-0.2469, -0.4550, -0.5853, -0.0810, 0.0309])
-    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_512_ema.pt":
-        expected_logits = torch.tensor([-0.3090, 0.0802, -0.0682, -0.1979, -0.2826])
-    else:
-        raise ValueError(f"Unknown URL: {checkpoint_url}")
-
-    assert torch.allclose(logits[0, :5], expected_logits, atol=1e-3)
-    assert logits.shape == expected_shape
-    print("Model outputs match the original results!")
-
-    if save_model:
-        print("Saving model to local...")
-        # Create folder to save model
-        if not os.path.isdir(pytorch_dump_folder_path):
-            os.mkdir(pytorch_dump_folder_path)
-
-        model.save_pretrained(pytorch_dump_folder_path)
-        preprocessor.save_pretrained(pytorch_dump_folder_path)
-
-    model_name = "convnextv2"
-    if "atto" in checkpoint_url:
-        model_name += "-atto"
-    if "femto" in checkpoint_url:
-        model_name += "-femto"
-    if "pico" in checkpoint_url:
-        model_name += "-pico"
-    if "nano" in checkpoint_url:
-        model_name += "-nano"
-    elif "tiny" in checkpoint_url:
-        model_name += "-tiny"
-    elif "base" in checkpoint_url:
-        model_name += "-base"
-    elif "large" in checkpoint_url:
-        model_name += "-large"
-    elif "huge" in checkpoint_url:
-        model_name += "-huge"
-    if "22k" in checkpoint_url and "1k" not in checkpoint_url:
-        model_name += "-22k"
-    elif "22k" in checkpoint_url and "1k" in checkpoint_url:
-        model_name += "-22k-1k"
-    elif "1k" in checkpoint_url:
-        model_name += "-1k"
-    if "224" in checkpoint_url:
-        model_name += "-224"
-    elif "384" in checkpoint_url:
-        model_name += "-384"
-    elif "512" in checkpoint_url:
-        model_name += "-512"
-
-    if push_to_hub:
-        print(f"Pushing {model_name} to the hub...")
-        model.push_to_hub(model_name)
-        preprocessor.push_to_hub(model_name)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt",
-        type=str,
-        help="URL of the original ConvNeXTV2 checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="model",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--save_model", action="store_true", help="Save model to local")
-    parser.add_argument("--push_to_hub", action="store_true", help="Push model and image preprocessor to the hub")
-
-    args = parser.parse_args()
-    convert_convnextv2_checkpoint(
-        args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
-    )
diff --git a/src/transformers/models/cvt/convert_cvt_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/cvt/convert_cvt_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 9f76c92887f4..000000000000
--- a/src/transformers/models/cvt/convert_cvt_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,362 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert CvT checkpoints from the original repository.
-
-URL: https://github.com/microsoft/CvT"""
-
-import argparse
-import json
-from collections import OrderedDict
-from pathlib import Path
-
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import AutoImageProcessor, CvtConfig, CvtForImageClassification
-
-
-def embeddings(idx):
-    """
-    The function helps in renaming embedding layer weights.
-
-    Args:
-        idx: stage number in original model
-    """
-    embed = []
-    embed.append(
-        (
-            f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight",
-            f"stage{idx}.patch_embed.proj.weight",
-        )
-    )
-    embed.append(
-        (
-            f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias",
-            f"stage{idx}.patch_embed.proj.bias",
-        )
-    )
-    embed.append(
-        (
-            f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight",
-            f"stage{idx}.patch_embed.norm.weight",
-        )
-    )
-    embed.append(
-        (
-            f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias",
-            f"stage{idx}.patch_embed.norm.bias",
-        )
-    )
-    return embed
-
-
-def attention(idx, cnt):
-    """
-    The function helps in renaming attention block layers weights.
-
-    Args:
-        idx: stage number in original model
-        cnt: count of blocks in each stage
-    """
-    attention_weights = []
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.convolution.weight",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_q.conv.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.weight",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.bias",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.bias",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_mean",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_mean",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_var",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_var",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.num_batches_tracked",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.num_batches_tracked",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.convolution.weight",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_k.conv.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.weight",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.bias",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.bias",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_mean",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_mean",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_var",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_var",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.num_batches_tracked",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.num_batches_tracked",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.convolution.weight",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_v.conv.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.weight",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.bias",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.bias",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_mean",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_mean",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_var",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_var",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.num_batches_tracked",
-            f"stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.num_batches_tracked",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.weight",
-            f"stage{idx}.blocks.{cnt}.attn.proj_q.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.bias",
-            f"stage{idx}.blocks.{cnt}.attn.proj_q.bias",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.weight",
-            f"stage{idx}.blocks.{cnt}.attn.proj_k.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.bias",
-            f"stage{idx}.blocks.{cnt}.attn.proj_k.bias",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.weight",
-            f"stage{idx}.blocks.{cnt}.attn.proj_v.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.bias",
-            f"stage{idx}.blocks.{cnt}.attn.proj_v.bias",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.weight",
-            f"stage{idx}.blocks.{cnt}.attn.proj.weight",
-        )
-    )
-    attention_weights.append(
-        (
-            f"cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.bias",
-            f"stage{idx}.blocks.{cnt}.attn.proj.bias",
-        )
-    )
-    attention_weights.append(
-        (f"cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.weight", f"stage{idx}.blocks.{cnt}.mlp.fc1.weight")
-    )
-    attention_weights.append(
-        (f"cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.bias", f"stage{idx}.blocks.{cnt}.mlp.fc1.bias")
-    )
-    attention_weights.append(
-        (f"cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.weight", f"stage{idx}.blocks.{cnt}.mlp.fc2.weight")
-    )
-    attention_weights.append(
-        (f"cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.bias", f"stage{idx}.blocks.{cnt}.mlp.fc2.bias")
-    )
-    attention_weights.append(
-        (f"cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.weight", f"stage{idx}.blocks.{cnt}.norm1.weight")
-    )
-    attention_weights.append(
-        (f"cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.bias", f"stage{idx}.blocks.{cnt}.norm1.bias")
-    )
-    attention_weights.append(
-        (f"cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.weight", f"stage{idx}.blocks.{cnt}.norm2.weight")
-    )
-    attention_weights.append(
-        (f"cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.bias", f"stage{idx}.blocks.{cnt}.norm2.bias")
-    )
-    return attention_weights
-
-
-def cls_token(idx):
-    """
-    Function helps in renaming cls_token weights
-    """
-    token = []
-    token.append((f"cvt.encoder.stages.{idx}.cls_token", "stage2.cls_token"))
-    return token
-
-
-def final():
-    """
-    Function helps in renaming final classification layer
-    """
-    head = []
-    head.append(("layernorm.weight", "norm.weight"))
-    head.append(("layernorm.bias", "norm.bias"))
-    head.append(("classifier.weight", "head.weight"))
-    head.append(("classifier.bias", "head.bias"))
-    return head
-
-
-def convert_cvt_checkpoint(cvt_model, image_size, cvt_file_name, pytorch_dump_folder):
-    """
-    Fucntion to convert the microsoft cvt checkpoint to huggingface checkpoint
-    """
-    img_labels_file = "imagenet-1k-id2label.json"
-    num_labels = 1000
-
-    repo_id = "huggingface/label-files"
-    num_labels = num_labels
-    id2label = json.loads(Path(hf_hub_download(repo_id, img_labels_file, repo_type="dataset")).read_text())
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    id2label = id2label
-    label2id = {v: k for k, v in id2label.items()}
-
-    config = config = CvtConfig(num_labels=num_labels, id2label=id2label, label2id=label2id)
-
-    # For depth size 13 (13 = 1+2+10)
-    if cvt_model.rsplit("/", 1)[-1][4:6] == "13":
-        config.depth = [1, 2, 10]
-
-    # For depth size 21 (21 = 1+4+16)
-    elif cvt_model.rsplit("/", 1)[-1][4:6] == "21":
-        config.depth = [1, 4, 16]
-
-    # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20)
-    else:
-        config.depth = [2, 2, 20]
-        config.num_heads = [3, 12, 16]
-        config.embed_dim = [192, 768, 1024]
-
-    model = CvtForImageClassification(config)
-    image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k")
-    image_processor.size["shortest_edge"] = image_size
-    original_weights = torch.load(cvt_file_name, map_location=torch.device("cpu"))
-
-    huggingface_weights = OrderedDict()
-    list_of_state_dict = []
-
-    for idx in range(len(config.depth)):
-        if config.cls_token[idx]:
-            list_of_state_dict = list_of_state_dict + cls_token(idx)
-        list_of_state_dict = list_of_state_dict + embeddings(idx)
-        for cnt in range(config.depth[idx]):
-            list_of_state_dict = list_of_state_dict + attention(idx, cnt)
-
-    list_of_state_dict = list_of_state_dict + final()
-    for gg in list_of_state_dict:
-        print(gg)
-    for i in range(len(list_of_state_dict)):
-        huggingface_weights[list_of_state_dict[i][0]] = original_weights[list_of_state_dict[i][1]]
-
-    model.load_state_dict(huggingface_weights)
-    model.save_pretrained(pytorch_dump_folder)
-    image_processor.save_pretrained(pytorch_dump_folder)
-
-
-# Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--cvt_model",
-        default="cvt-w24",
-        type=str,
-        help="Name of the cvt model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--image_size",
-        default=384,
-        type=int,
-        help="Input Image Size",
-    )
-    parser.add_argument(
-        "--cvt_file_name",
-        default=r"cvtmodels\CvT-w24-384x384-IN-22k.pth",
-        type=str,
-        help="Input Image Size",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/dab_detr/convert_dab_detr_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/dab_detr/convert_dab_detr_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index a6e5081b484c..000000000000
--- a/src/transformers/models/dab_detr/convert_dab_detr_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,233 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DAB-DETR checkpoints."""
-
-import argparse
-import gc
-import json
-import re
-from pathlib import Path
-
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import ConditionalDetrImageProcessor, DabDetrConfig, DabDetrForObjectDetection
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    # convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
-    # for dab-DETR, also convert reference point head and query scale MLP
-    r"input_proj\.(bias|weight)": r"input_projection.\1",
-    r"refpoint_embed\.weight": r"query_refpoint_embeddings.weight",
-    r"class_embed\.(bias|weight)": r"class_embed.\1",
-    # negative lookbehind because of the overlap
-    r"(?<!transformer\.decoder\.)bbox_embed\.layers\.(\d+)\.(bias|weight)": r"bbox_predictor.layers.\1.\2",
-    r"transformer\.encoder\.query_scale\.layers\.(\d+)\.(bias|weight)": r"encoder.query_scale.layers.\1.\2",
-    r"transformer\.decoder\.bbox_embed\.layers\.(\d+)\.(bias|weight)": r"decoder.bbox_embed.layers.\1.\2",
-    r"transformer\.decoder\.norm\.(bias|weight)": r"decoder.layernorm.\1",
-    r"transformer\.decoder\.ref_point_head\.layers\.(\d+)\.(bias|weight)": r"decoder.ref_point_head.layers.\1.\2",
-    r"transformer\.decoder\.ref_anchor_head\.layers\.(\d+)\.(bias|weight)": r"decoder.ref_anchor_head.layers.\1.\2",
-    r"transformer\.decoder\.query_scale\.layers\.(\d+)\.(bias|weight)": r"decoder.query_scale.layers.\1.\2",
-    r"transformer\.decoder\.layers\.0\.ca_qpos_proj\.(bias|weight)": r"decoder.layers.0.cross_attn.cross_attn_query_pos_proj.\1",
-    # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms + activation function
-    # output projection
-    r"transformer\.encoder\.layers\.(\d+)\.self_attn\.out_proj\.(bias|weight)": r"encoder.layers.\1.self_attn.out_proj.\2",
-    # FFN layers
-    r"transformer\.encoder\.layers\.(\d+)\.linear(\d)\.(bias|weight)": r"encoder.layers.\1.fc\2.\3",
-    # normalization layers
-    # nm1
-    r"transformer\.encoder\.layers\.(\d+)\.norm1\.(bias|weight)": r"encoder.layers.\1.self_attn_layer_norm.\2",
-    # nm2
-    r"transformer\.encoder\.layers\.(\d+)\.norm2\.(bias|weight)": r"encoder.layers.\1.final_layer_norm.\2",
-    # activation function weight
-    r"transformer\.encoder\.layers\.(\d+)\.activation\.weight": r"encoder.layers.\1.activation_fn.weight",
-    #########################################################################################################################################
-    # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms + activiation function weight
-    r"transformer\.decoder\.layers\.(\d+)\.self_attn\.out_proj\.(bias|weight)": r"decoder.layers.\1.self_attn.self_attn.output_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.cross_attn\.out_proj\.(bias|weight)": r"decoder.layers.\1.cross_attn.cross_attn.output_proj.\2",
-    # FFNs
-    r"transformer\.decoder\.layers\.(\d+)\.linear(\d)\.(bias|weight)": r"decoder.layers.\1.mlp.fc\2.\3",
-    # nm1
-    r"transformer\.decoder\.layers\.(\d+)\.norm1\.(bias|weight)": r"decoder.layers.\1.self_attn.self_attn_layer_norm.\2",
-    # nm2
-    r"transformer\.decoder\.layers\.(\d+)\.norm2\.(bias|weight)": r"decoder.layers.\1.cross_attn.cross_attn_layer_norm.\2",
-    # nm3
-    r"transformer\.decoder\.layers\.(\d+)\.norm3\.(bias|weight)": r"decoder.layers.\1.mlp.final_layer_norm.\2",
-    # activation function weight
-    r"transformer\.decoder\.layers\.(\d+)\.activation\.weight": r"decoder.layers.\1.mlp.activation_fn.weight",
-    # q, k, v projections and biases in self-attention in decoder
-    r"transformer\.decoder\.layers\.(\d+)\.sa_qcontent_proj\.(bias|weight)": r"decoder.layers.\1.self_attn.self_attn_query_content_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.sa_kcontent_proj\.(bias|weight)": r"decoder.layers.\1.self_attn.self_attn_key_content_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.sa_qpos_proj\.(bias|weight)": r"decoder.layers.\1.self_attn.self_attn_query_pos_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.sa_kpos_proj\.(bias|weight)": r"decoder.layers.\1.self_attn.self_attn_key_pos_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.sa_v_proj\.(bias|weight)": r"decoder.layers.\1.self_attn.self_attn_value_proj.\2",
-    # q, k, v projections in cross-attention in decoder
-    r"transformer\.decoder\.layers\.(\d+)\.ca_qcontent_proj\.(bias|weight)": r"decoder.layers.\1.cross_attn.cross_attn_query_content_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.ca_kcontent_proj\.(bias|weight)": r"decoder.layers.\1.cross_attn.cross_attn_key_content_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.ca_kpos_proj\.(bias|weight)": r"decoder.layers.\1.cross_attn.cross_attn_key_pos_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.ca_v_proj\.(bias|weight)": r"decoder.layers.\1.cross_attn.cross_attn_value_proj.\2",
-    r"transformer\.decoder\.layers\.(\d+)\.ca_qpos_sine_proj\.(bias|weight)": r"decoder.layers.\1.cross_attn.cross_attn_query_pos_sine_proj.\2",
-}
-
-
-# Copied from transformers.models.mllama.convert_mllama_weights_to_hf.convert_old_keys_to_new_keys
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    """
-    This function should be applied only once, on the concatenated keys to efficiently rename using
-    the key mappings.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-        for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-            if replacement is None:
-                new_text = re.sub(pattern, "", new_text)  # an empty line
-                continue
-            new_text = re.sub(pattern, replacement, new_text)
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-    return output_dict
-
-
-def write_image_processor(model_name, pytorch_dump_folder_path, push_to_hub):
-    logger.info("Converting image processor...")
-    format = "coco_detection"
-    image_processor = ConditionalDetrImageProcessor(format=format)
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        image_processor.push_to_hub(repo_id=model_name, commit_message="Add new image processor")
-
-
-@torch.no_grad()
-def write_model(model_name, pretrained_model_weights_path, pytorch_dump_folder_path, push_to_hub):
-    # load modified config. Why? After loading the default config, the backbone kwargs are already set.
-    if "dc5" in model_name:
-        config = DabDetrConfig(dilation=True)
-    else:
-        # load default config
-        config = DabDetrConfig()
-    # set other attributes
-    if "dab-detr-resnet-50-dc5" == model_name:
-        config.temperature_height = 10
-        config.temperature_width = 10
-    if "fixxy" in model_name:
-        config.random_refpoints_xy = True
-    if "pat3" in model_name:
-        config.num_patterns = 3
-        # only when the number of patterns (num_patterns parameter in config) are more than 0 like r50-pat3 or r50dc5-pat3
-        ORIGINAL_TO_CONVERTED_KEY_MAPPING.update({r"transformer.patterns.weight": r"patterns.weight"})
-
-    config.num_labels = 91
-    repo_id = "huggingface/label-files"
-    filename = "coco-detection-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-    # load original model from local path
-    loaded = torch.load(pretrained_model_weights_path, map_location=torch.device("cpu"))["model"]
-    # Renaming the original model state dictionary to HF compatibile
-    all_keys = list(loaded.keys())
-    new_keys = convert_old_keys_to_new_keys(all_keys)
-    state_dict = {}
-    for key in all_keys:
-        if "backbone.0.body" in key:
-            new_key = key.replace("backbone.0.body", "backbone.conv_encoder.model._backbone")
-            state_dict[new_key] = loaded[key]
-        # Q, K, V encoder values mapping
-        elif re.search("self_attn.in_proj_(weight|bias)", key):
-            # Dynamically find the layer number
-            pattern = r"layers\.(\d+)\.self_attn\.in_proj_(weight|bias)"
-            match = re.search(pattern, key)
-            if match:
-                layer_num = match.group(1)
-            else:
-                raise ValueError(f"Pattern not found in key: {key}")
-
-            in_proj_value = loaded.pop(key)
-            if "weight" in key:
-                state_dict[f"encoder.layers.{layer_num}.self_attn.q_proj.weight"] = in_proj_value[:256, :]
-                state_dict[f"encoder.layers.{layer_num}.self_attn.k_proj.weight"] = in_proj_value[256:512, :]
-                state_dict[f"encoder.layers.{layer_num}.self_attn.v_proj.weight"] = in_proj_value[-256:, :]
-            elif "bias" in key:
-                state_dict[f"encoder.layers.{layer_num}.self_attn.q_proj.bias"] = in_proj_value[:256]
-                state_dict[f"encoder.layers.{layer_num}.self_attn.k_proj.bias"] = in_proj_value[256:512]
-                state_dict[f"encoder.layers.{layer_num}.self_attn.v_proj.bias"] = in_proj_value[-256:]
-        else:
-            new_key = new_keys[key]
-            state_dict[new_key] = loaded[key]
-
-    del loaded
-    gc.collect()
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    prefix = "model."
-    for key in state_dict.copy().keys():
-        if not key.startswith("class_embed") and not key.startswith("bbox_predictor"):
-            val = state_dict.pop(key)
-            state_dict[prefix + key] = val
-    # finally, create HuggingFace model and load state dict
-    model = DabDetrForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-    logger.info(f"Saving PyTorch model to {pytorch_dump_folder_path}...")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub(repo_id=model_name, commit_message="Add new model")
-
-
-def convert_dab_detr_checkpoint(model_name, pretrained_model_weights_path, pytorch_dump_folder_path, push_to_hub):
-    logger.info("Converting image processor...")
-    write_image_processor(model_name, pytorch_dump_folder_path, push_to_hub)
-
-    logger.info(f"Converting model {model_name}...")
-    write_model(model_name, pretrained_model_weights_path, pytorch_dump_folder_path, push_to_hub)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--model_name",
-        default="dab-detr-resnet-50",
-        type=str,
-        help="Name of the DAB_DETR model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pretrained_model_weights_path",
-        default="modelzoo/R50/checkpoint.pth",
-        type=str,
-        help="The path of the original model weights like: modelzoo/checkpoint.pth",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default="DAB_DETR", type=str, help="Path to the folder to output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        default=True,
-        type=bool,
-        help="Whether to upload the converted weights and image processor config to the HuggingFace model profile. Default is set to false.",
-    )
-    args = parser.parse_args()
-    convert_dab_detr_checkpoint(
-        args.model_name, args.pretrained_model_weights_path, args.pytorch_dump_folder_path, args.push_to_hub
-    )
diff --git a/src/transformers/models/dac/convert_dac_checkpoint.py b/src/transformers/models/dac/convert_dac_checkpoint.py
deleted file mode 100644
index bfeb96fbdd4e..000000000000
--- a/src/transformers/models/dac/convert_dac_checkpoint.py
+++ /dev/null
@@ -1,261 +0,0 @@
-# coding=utf-8
-# Copyright 2024 Descript and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import fnmatch
-import re
-
-import torch
-
-from transformers import (
-    DacConfig,
-    DacFeatureExtractor,
-    DacModel,
-    logging,
-)
-
-
-# checkpoints downloaded using:
-# pip install descript-audio-codec
-# python3 -m dac download # downloads the default 44kHz variant
-# python3 -m dac download --model_type 44khz # downloads the 44kHz variant
-# python3 -m dac download --model_type 24khz # downloads the 24kHz variant
-# python3 -m dac download --model_type 16khz # downloads the 16kHz variant
-# More informations: https://github.com/descriptinc/descript-audio-codec/tree/main
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.dac")
-
-
-def match_pattern(string, pattern):
-    # Split the pattern into parts
-    pattern_parts = pattern.split(".")
-    string_parts = string.split(".")
-
-    pattern_block_count = string_block_count = 0
-
-    for part in pattern_parts:
-        if part.startswith("block"):
-            pattern_block_count += 1
-
-    for part in string_parts:
-        if part.startswith("block"):
-            string_block_count += 1
-
-    return fnmatch.fnmatch(string, pattern) and string_block_count == pattern_block_count
-
-
-TOP_LEVEL_KEYS = []
-IGNORE_KEYS = []
-
-
-MAPPING_ENCODER = {
-    "encoder.block.0": ["encoder.conv1"],
-    "encoder.block.5": ["encoder.snake1"],
-    "encoder.block.6": ["encoder.conv2"],
-    "encoder.block.*.block.*.block.0".replace("*", r"\d+"): ["encoder.block", "res_unit", "snake1"],
-    "encoder.block.*.block.*.block.1".replace("*", r"\d+"): ["encoder.block", "res_unit", "conv1"],
-    "encoder.block.*.block.*.block.2".replace("*", r"\d+"): ["encoder.block", "res_unit", "snake2"],
-    "encoder.block.*.block.*.block.3".replace("*", r"\d+"): ["encoder.block", "res_unit", "conv2"],
-    "encoder.block.*.block.3".replace("*", r"\d+"): ["encoder.block", "snake1"],
-    "encoder.block.*.block.4".replace("*", r"\d+"): ["encoder.block", "conv1"],
-}
-
-MAPPING_QUANTIZER = {
-    "quantizer.quantizers.*": ["quantizer.quantizers.*"],
-}
-
-MAPPING_DECODER = {
-    "decoder.model.0": ["decoder.conv1"],
-    "decoder.model.5": ["decoder.snake1"],
-    "decoder.model.6": ["decoder.conv2"],
-    "decoder.model.*.block.0".replace("*", r"\d+"): ["decoder.block", "snake1"],
-    "decoder.model.*.block.1".replace("*", r"\d+"): ["decoder.block", "conv_t1"],
-    "decoder.model.*.block.*.block.0".replace("*", r"\d+"): ["decoder.block", "res_unit", "snake1"],
-    "decoder.model.*.block.*.block.1".replace("*", r"\d+"): ["decoder.block", "res_unit", "conv1"],
-    "decoder.model.*.block.*.block.2".replace("*", r"\d+"): ["decoder.block", "res_unit", "snake2"],
-    "decoder.model.*.block.*.block.3".replace("*", r"\d+"): ["decoder.block", "res_unit", "conv2"],
-}
-
-
-MAPPING = {
-    **MAPPING_ENCODER,
-    **MAPPING_QUANTIZER,
-    **MAPPING_DECODER,
-}
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    if hf_shape != value.shape:
-        raise ValueError(
-            f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-            f" {value.shape} for {full_name}"
-        )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    elif weight_type == "alpha":
-        hf_pointer.alpha.data = value
-    logger.info(f"{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}.")
-
-
-def should_ignore(name, ignore_keys):
-    for key in ignore_keys:
-        if key.endswith(".*"):
-            if name.startswith(key[:-1]):
-                return True
-        elif ".*." in key:
-            prefix, suffix = key.split(".*.")
-            if prefix in name and suffix in name:
-                return True
-        elif key in name:
-            return True
-    return False
-
-
-def recursively_load_weights(orig_dict, hf_model, model_name):
-    unused_weights = []
-
-    if model_name not in ["dac_16khz", "dac_24khz", "dac_44khz"]:
-        raise ValueError(f"Unsupported model: {model_name}")
-
-    for name, value in orig_dict.items():
-        is_used = False
-        for key, mapped_key in MAPPING.items():
-            regex = re.compile(key)
-            if regex.search(name):
-                if len(mapped_key) == 1:
-                    if mapped_key[0][0] == "q":
-                        mapped_key = ".".join(name.split(".")[:-1])
-                    else:
-                        mapped_key = mapped_key[0]
-                elif len(mapped_key) == 3:
-                    integers = re.findall(r"\b\d+\b", name)
-                    if mapped_key[0][0] == "d":
-                        mapped_key = "{}.{}.{}{}.{}".format(
-                            mapped_key[0],
-                            str(int(integers[0]) - 1),
-                            mapped_key[1],
-                            str(int(integers[1]) - 1),
-                            mapped_key[2],
-                        )
-                    else:
-                        mapped_key = "{}.{}.{}{}.{}".format(
-                            mapped_key[0],
-                            str(int(integers[0]) - 1),
-                            mapped_key[1],
-                            str(int(integers[1]) + 1),
-                            mapped_key[2],
-                        )
-                elif len(mapped_key) == 2:
-                    integers = re.findall(r"\b\d+\b", name)
-                    mapped_key = "{}.{}.{}".format(mapped_key[0], str(int(integers[0]) - 1), mapped_key[1])
-
-                is_used = True
-                if "weight_g" in name:
-                    weight_type = "weight_g"
-                elif "weight_v" in name:
-                    weight_type = "weight_v"
-                elif "bias" in name:
-                    weight_type = "bias"
-                elif "alpha" in name:
-                    weight_type = "alpha"
-                elif "weight" in name:
-                    weight_type = "weight"
-                set_recursively(hf_model, mapped_key, value, name, weight_type)
-
-        if not is_used:
-            unused_weights.append(name)
-
-    print(list(set(unused_weights)))
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-@torch.no_grad()
-def convert_checkpoint(
-    model_name,
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    sample_rate=16000,
-    repo_id=None,
-):
-    model_dict = torch.load(checkpoint_path, "cpu")
-
-    config = DacConfig()
-
-    metadata = model_dict["metadata"]["kwargs"]
-    config.encoder_hidden_size = metadata["encoder_dim"]
-    config.downsampling_ratios = metadata["encoder_rates"]
-    config.codebook_size = metadata["codebook_size"]
-    config.n_codebooks = metadata["n_codebooks"]
-    config.codebook_dim = metadata["codebook_dim"]
-    config.decoder_hidden_size = metadata["decoder_dim"]
-    config.upsampling_ratios = metadata["decoder_rates"]
-    config.quantizer_dropout = float(metadata["quantizer_dropout"])
-    config.sampling_rate = sample_rate
-
-    model = DacModel(config)
-    feature_extractor = DacFeatureExtractor()
-    feature_extractor.sampling_rate = sample_rate
-
-    original_checkpoint = model_dict["state_dict"]
-
-    model.apply_weight_norm()
-    recursively_load_weights(original_checkpoint, model, model_name)
-    model.remove_weight_norm()
-
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        feature_extractor.push_to_hub(repo_id)
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model",
-        default="dac_44khz",
-        type=str,
-        help="The model to convert. Should be one of 'dac_16khz', 'dac_24khz', 'dac_44khz'.",
-    )
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-    parser.add_argument("--sample_rate", default=None, type=str, help="Sample rate used by DacFeatureExtractor")
-    args = parser.parse_args()
-
-    convert_checkpoint(
-        args.model, args.checkpoint_path, args.pytorch_dump_folder_path, args.sample_rate, args.push_to_hub
-    )
diff --git a/src/transformers/models/data2vec/convert_data2vec_audio_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/data2vec/convert_data2vec_audio_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 4ecc33355145..000000000000
--- a/src/transformers/models/data2vec/convert_data2vec_audio_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,285 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Wav2Vec2 checkpoint."""
-
-import argparse
-import os
-from functools import reduce
-
-import fairseq
-import torch
-from datasets import load_dataset
-
-from transformers import Wav2Vec2Processor, logging
-from transformers.models.data2vec.configuration_data2vec_audio import Data2VecAudioConfig
-
-# Copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_audio.py
-from transformers.models.data2vec.data2vec_audio import Data2VecAudioModel as Dummy  # noqa: F401
-from transformers.models.data2vec.modeling_data2vec_audio import Data2VecAudioForCTC, Data2VecAudioModel
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "models.0.layer_norm": "feature_projection.layer_norm",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "w2v_encoder.proj": "lm_head",
-    "mask_emb": "masked_spec_embed",
-}
-TOP_LEVEL_KEYS = [
-    "lm_head",
-]
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    if hf_shape != value.shape:
-        raise ValueError(
-            f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-            f" {value.shape} for {full_name}"
-        )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model, is_headless):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    if not is_headless:
-        feature_extractor = hf_model.data2vec_audio.feature_extractor
-        pos_conv_embedding = hf_model.data2vec_audio.encoder.pos_conv_embed
-
-    else:
-        feature_extractor = hf_model.feature_extractor
-        pos_conv_embedding = hf_model.encoder.pos_conv_embed
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-            )
-            is_used = True
-        elif "pos_conv" in name:
-            load_pos_conv_layer(
-                name,
-                value,
-                pos_conv_embedding,
-                unused_weights,
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                if not is_headless:
-                    mapped_key = "data2vec_audio." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    elif "weight" in name:
-                        # TODO: don't match quantizer.weight_proj
-                        weight_type = "weight"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def access_by_string(module, path):
-    names = path.split(".")
-    return reduce(getattr, names, module)
-
-
-def set_weights(full_name, module, fsq_value, hf_weight_path):
-    hf_weight = access_by_string(module, hf_weight_path)
-    hf_value = hf_weight.data
-
-    if fsq_value.shape != hf_value.shape:
-        raise ValueError(f"{full_name} has size {fsq_value.shape}, but {hf_value.shape} was found.")
-    hf_weight.data = fsq_value
-    logger.info(f"{full_name} was correctly initialized from {hf_weight_path}.")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    weight_type = name.split(".")[-1]
-    if type_id == 0:
-        layer_type = "conv"
-    elif type_id == 2:
-        layer_type = "layer_norm"
-    else:
-        unused_weights.append(full_name)
-        return
-
-    set_weights(full_name, feature_extractor, value, f"conv_layers.{layer_id}.{layer_type}.{weight_type}")
-
-
-def load_pos_conv_layer(full_name, value, pos_conv_embeddings, unused_weights):
-    name = full_name.split("pos_conv.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    weight_type = name.split(".")[-1]
-    if type_id != 0:
-        unused_weights.append(full_name)
-        return
-    else:
-        layer_type = "conv"
-
-    set_weights(full_name, pos_conv_embeddings, value, f"layers.{layer_id}.{layer_type}.{weight_type}")
-
-
-@torch.no_grad()
-def convert_wav2vec2_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, config_path=None, dict_path=None, is_finetuned=True
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = Data2VecAudioConfig.from_pretrained(config_path)
-    else:
-        config = Data2VecAudioConfig()
-
-    if not is_finetuned:
-        # Modify final_proj layer name
-        hf_wav2vec = Data2VecAudioModel(config)
-        data2vec_checkpoint_dir = os.path.dirname(checkpoint_path)
-
-        state_dict = torch.load(checkpoint_path, weights_only=True)
-        state_dict["model"]["final_proj.weight"] = state_dict["model"].pop("final_proj.0.weight")
-        state_dict["model"]["final_proj.bias"] = state_dict["model"].pop("final_proj.0.bias")
-        converted_ckpt = os.path.join(data2vec_checkpoint_dir, "converted.pt")
-        torch.save(state_dict, converted_ckpt)
-    else:
-        hf_wav2vec = Data2VecAudioForCTC(config)
-        converted_ckpt = checkpoint_path
-
-    def load_data2vec(path):
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([path])
-        return model[0].eval()
-
-    model = load_data2vec(converted_ckpt)
-
-    recursively_load_weights(model, hf_wav2vec, not is_finetuned)
-
-    processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-large-lv60")
-
-    ds = load_dataset("patrickvonplaten/librispeech_asr_dummy", "clean", split="validation", trust_remote_code=True)
-    input_audio = [x["array"] for x in ds[:4]["audio"]]
-
-    inputs = processor(input_audio, return_tensors="pt", padding=True)
-
-    input_values = inputs.input_values
-    attention_mask = inputs.attention_mask
-    #    input_values = inputs.input_values[:, :-1]
-    #    attention_mask = inputs.attention_mask[:, :-1]
-
-    hf_wav2vec.eval()
-    model.eval()
-    if is_finetuned:
-        their_output = model(source=input_values, padding_mask=(1 - attention_mask), mask=False, features_only=True)[
-            "encoder_out"
-        ].transpose(0, 1)
-        our_output = hf_wav2vec(input_values, attention_mask=attention_mask)["logits"]
-
-        pred_ids = torch.argmax(our_output, dim=-1)
-        output_string = processor.batch_decode(pred_ids)
-
-        print(f"Expected Output: {ds[:4]['text']}, Pred: {output_string}")
-    else:
-        their_output = model(source=input_values, padding_mask=(1 - attention_mask), mask=False, features_only=True)[
-            "layer_results"
-        ][-1][0].transpose(0, 1)
-        our_output = hf_wav2vec(input_values, attention_mask=attention_mask)["last_hidden_state"]
-
-    print(our_output.shape, their_output.shape)
-    max_absolute_diff = torch.max(torch.abs(our_output - their_output)).item()
-    print(f"max_absolute_diff = {max_absolute_diff}")  # ~ 1e-7
-    success = torch.allclose(our_output, their_output, atol=1e-3)
-    print("Do both models output the same tensors?", "🔥" if success else "💩")
-    if not success:
-        raise Exception("Something went wRoNg")
-
-    hf_wav2vec.save_pretrained(pytorch_dump_folder_path)
-
-    if is_finetuned:
-        processor.save_pretrained(pytorch_dump_folder_path)
-    else:
-        processor.feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
-    )
-    args = parser.parse_args()
-    convert_wav2vec2_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
-    )
diff --git a/src/transformers/models/data2vec/convert_data2vec_text_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/data2vec/convert_data2vec_text_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 93c9afe9f65b..000000000000
--- a/src/transformers/models/data2vec/convert_data2vec_text_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,207 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert data2vec checkpoint."""
-
-import argparse
-import os
-import pathlib
-
-import fairseq
-import torch
-from fairseq.modules import TransformerSentenceEncoderLayer
-from packaging import version
-
-from transformers import (
-    Data2VecTextConfig,
-    Data2VecTextForMaskedLM,
-    Data2VecTextForSequenceClassification,
-    Data2VecTextModel,
-)
-from transformers.models.bert.modeling_bert import (
-    BertIntermediate,
-    BertLayer,
-    BertOutput,
-    BertSelfAttention,
-    BertSelfOutput,
-)
-
-# IMPORTANT: In order for this script to run, please make sure to download the dictionary: `dict.txt` from wget https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.tar.gz
-# File copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_text.py
-from transformers.utils import logging
-
-
-if version.parse(fairseq.__version__) < version.parse("0.9.0"):
-    raise Exception("requires fairseq >= 0.9.0")
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-SAMPLE_TEXT = "Hello world! cécé herlolip"
-
-
-def convert_data2vec_checkpoint_to_pytorch(
-    data2vec_checkpoint_path: str, pytorch_dump_folder_path: str, classification_head: bool
-):
-    """
-    Copy/paste/tweak data2vec's weights to our BERT structure.
-    """
-    data2vec_checkpoint_dir, data2vec_checkpoint_file_name = os.path.split(data2vec_checkpoint_path)
-    data2vec = Data2VecTextModel.from_pretrained(
-        data2vec_checkpoint_dir, checkpoint_file=data2vec_checkpoint_file_name
-    )
-    data2vec.eval()  # disable dropout
-    data2vec_model = data2vec.models[0]
-    data2vec_sent_encoder = data2vec_model.encoder.sentence_encoder
-    config = Data2VecTextConfig(
-        vocab_size=data2vec_sent_encoder.embed_tokens.num_embeddings,
-        hidden_size=data2vec_model.args.encoder_embed_dim,
-        num_hidden_layers=data2vec_model.args.encoder_layers,
-        num_attention_heads=data2vec_model.args.encoder_attention_heads,
-        intermediate_size=data2vec_model.args.encoder_ffn_embed_dim,
-        max_position_embeddings=514,
-        type_vocab_size=1,
-        layer_norm_eps=1e-5,  # PyTorch default used in fairseq
-    )
-    if classification_head:
-        config.num_labels = data2vec.model.classification_heads["mnli"].out_proj.weight.shape[0]
-    print("Our BERT config:", config)
-
-    model = Data2VecTextForSequenceClassification(config) if classification_head else Data2VecTextForMaskedLM(config)
-    model.eval()
-
-    # Now let's copy all the weights.
-    # Embeddings
-    model.data2vec_text.embeddings.word_embeddings.weight = data2vec_sent_encoder.embed_tokens.weight
-    model.data2vec_text.embeddings.position_embeddings.weight = data2vec_sent_encoder.embed_positions.weight
-    model.data2vec_text.embeddings.token_type_embeddings.weight.data = torch.zeros_like(
-        model.data2vec_text.embeddings.token_type_embeddings.weight
-    )  # just zero them out b/c data2vec doesn't use them.
-    model.data2vec_text.embeddings.LayerNorm.weight = data2vec_sent_encoder.layernorm_embedding.weight
-    model.data2vec_text.embeddings.LayerNorm.bias = data2vec_sent_encoder.layernorm_embedding.bias
-
-    for i in range(config.num_hidden_layers):
-        # Encoder: start of layer
-        layer: BertLayer = model.data2vec_text.encoder.layer[i]
-        data2vec_layer: TransformerSentenceEncoderLayer = data2vec_sent_encoder.layers[i]
-
-        # self attention
-        self_attn: BertSelfAttention = layer.attention.self
-        assert data2vec_layer.self_attn.k_proj.weight.data.shape == torch.Size(
-            (config.hidden_size, config.hidden_size)
-        ), (
-            "Shape for data2vec_layer.self_attn.k_proj.weight.data should be"
-            f" {torch.Size((config.hidden_size, config.hidden_size))}"
-        )
-        assert data2vec_layer.self_attn.q_proj.weight.data.shape == torch.Size(
-            (config.hidden_size, config.hidden_size)
-        ), (
-            "Shape for data2vec_layer.self_attn.q_proj.weight.data should be"
-            f" {torch.Size((config.hidden_size, config.hidden_size))}"
-        )
-        assert data2vec_layer.self_attn.v_proj.weight.data.shape == torch.Size(
-            (config.hidden_size, config.hidden_size)
-        ), (
-            "Shape for data2vec_layer.self_attn.v_proj.weight.data should be"
-            f" {torch.Size((config.hidden_size, config.hidden_size))}"
-        )
-
-        self_attn.query.weight.data = data2vec_layer.self_attn.q_proj.weight
-        self_attn.query.bias.data = data2vec_layer.self_attn.q_proj.bias
-        self_attn.key.weight.data = data2vec_layer.self_attn.k_proj.weight
-        self_attn.key.bias.data = data2vec_layer.self_attn.k_proj.bias
-        self_attn.value.weight.data = data2vec_layer.self_attn.v_proj.weight
-        self_attn.value.bias.data = data2vec_layer.self_attn.v_proj.bias
-
-        # self-attention output
-        self_output: BertSelfOutput = layer.attention.output
-        assert self_output.dense.weight.shape == data2vec_layer.self_attn.out_proj.weight.shape, (
-            f"Shape for self_output.dense.weight should be {data2vec_layer.self_attn.out_proj.weight.shape}"
-        )
-        self_output.dense.weight = data2vec_layer.self_attn.out_proj.weight
-        self_output.dense.bias = data2vec_layer.self_attn.out_proj.bias
-        self_output.LayerNorm.weight = data2vec_layer.self_attn_layer_norm.weight
-        self_output.LayerNorm.bias = data2vec_layer.self_attn_layer_norm.bias
-
-        # intermediate
-        intermediate: BertIntermediate = layer.intermediate
-        assert intermediate.dense.weight.shape == data2vec_layer.fc1.weight.shape, (
-            f"Shape for intermediate.dense.weight should be {data2vec_layer.fc1.weight.shape}"
-        )
-        intermediate.dense.weight = data2vec_layer.fc1.weight
-        intermediate.dense.bias = data2vec_layer.fc1.bias
-
-        # output
-        bert_output: BertOutput = layer.output
-        assert bert_output.dense.weight.shape == data2vec_layer.fc2.weight.shape, (
-            f"Shape for bert_output.dense.weight should be {data2vec_layer.fc2.weight.shape}"
-        )
-        bert_output.dense.weight = data2vec_layer.fc2.weight
-        bert_output.dense.bias = data2vec_layer.fc2.bias
-        bert_output.LayerNorm.weight = data2vec_layer.final_layer_norm.weight
-        bert_output.LayerNorm.bias = data2vec_layer.final_layer_norm.bias
-        # end of layer
-
-    if classification_head:
-        model.classifier.dense.weight = data2vec.model.classification_heads["mnli"].dense.weight
-        model.classifier.dense.bias = data2vec.model.classification_heads["mnli"].dense.bias
-        model.classifier.out_proj.weight = data2vec.model.classification_heads["mnli"].out_proj.weight
-        model.classifier.out_proj.bias = data2vec.model.classification_heads["mnli"].out_proj.bias
-    else:
-        # LM Head
-        model.lm_head.dense.weight = data2vec_model.encoder.lm_head.dense.weight
-        model.lm_head.dense.bias = data2vec_model.encoder.lm_head.dense.bias
-        model.lm_head.layer_norm.weight = data2vec_model.encoder.lm_head.layer_norm.weight
-        model.lm_head.layer_norm.bias = data2vec_model.encoder.lm_head.layer_norm.bias
-        model.lm_head.decoder.weight = data2vec_model.encoder.lm_head.weight
-        model.lm_head.decoder.bias = data2vec_model.encoder.lm_head.bias
-
-    # Let's check that we get the same results.
-    input_ids: torch.Tensor = data2vec.encode(SAMPLE_TEXT).unsqueeze(0)  # batch of size 1
-
-    our_output = model(input_ids)[0]
-    if classification_head:
-        their_output = data2vec.model.classification_heads["mnli"](data2vec.extract_features(input_ids))
-    else:
-        their_output = data2vec_model(input_ids)[0]
-    print(our_output.shape, their_output.shape)
-    max_absolute_diff = torch.max(torch.abs(our_output - their_output)).item()
-    print(f"max_absolute_diff = {max_absolute_diff}")  # ~ 1e-7
-    success = torch.allclose(our_output, their_output, atol=1e-3)
-    print("Do both models output the same tensors?", "🔥" if success else "💩")
-    if not success:
-        raise Exception("Something went wRoNg")
-
-    pathlib.Path(pytorch_dump_folder_path).mkdir(parents=True, exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--classification_head", action="store_true", help="Whether to convert a final classification head."
-    )
-    args = parser.parse_args()
-    convert_data2vec_checkpoint_to_pytorch(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
-    )
diff --git a/src/transformers/models/data2vec/convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/data2vec/convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100755
index 0c6f42f4ba7f..000000000000
--- a/src/transformers/models/data2vec/convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,374 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import json
-
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from timm.models import create_model
-
-from transformers import (
-    BeitImageProcessor,
-    Data2VecVisionConfig,
-    Data2VecVisionForImageClassification,
-    Data2VecVisionModel,
-)
-
-
-def create_rename_keys(config, has_lm_head=False, is_semantic=False, hf_prefix="data2vec."):
-    prefix = "backbone." if is_semantic else ""
-
-    rename_keys = []
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.norm1.weight", f"{hf_prefix}encoder.layer.{i}.layernorm_before.weight")
-        )
-        rename_keys.append((f"{prefix}blocks.{i}.norm1.bias", f"{hf_prefix}encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.attn.proj.weight", f"{hf_prefix}encoder.layer.{i}.attention.output.dense.weight")
-        )
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.attn.proj.bias", f"{hf_prefix}encoder.layer.{i}.attention.output.dense.bias")
-        )
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.norm2.weight", f"{hf_prefix}encoder.layer.{i}.layernorm_after.weight")
-        )
-        rename_keys.append((f"{prefix}blocks.{i}.norm2.bias", f"{hf_prefix}encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.mlp.fc1.weight", f"{hf_prefix}encoder.layer.{i}.intermediate.dense.weight")
-        )
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.mlp.fc1.bias", f"{hf_prefix}encoder.layer.{i}.intermediate.dense.bias")
-        )
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc2.weight", f"{hf_prefix}encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc2.bias", f"{hf_prefix}encoder.layer.{i}.output.dense.bias"))
-
-    # projection layer + position embeddings
-    rename_keys.extend(
-        [
-            (f"{prefix}cls_token", f"{hf_prefix}embeddings.cls_token"),
-            (f"{prefix}patch_embed.proj.weight", f"{hf_prefix}embeddings.patch_embeddings.projection.weight"),
-            (f"{prefix}patch_embed.proj.bias", f"{hf_prefix}embeddings.patch_embeddings.projection.bias"),
-        ]
-    )
-
-    if has_lm_head:
-        # mask token + shared relative position bias + layernorm
-        rename_keys.extend(
-            [
-                ("mask_token", f"{hf_prefix}embeddings.mask_token"),
-                (
-                    "rel_pos_bias.relative_position_bias_table",
-                    f"{hf_prefix}encoder.relative_position_bias.relative_position_bias_table",
-                ),
-                (
-                    "rel_pos_bias.relative_position_index",
-                    f"{hf_prefix}encoder.relative_position_bias.relative_position_index",
-                ),
-                ("norm.weight", "layernorm.weight"),
-                ("norm.bias", "layernorm.bias"),
-            ]
-        )
-    elif is_semantic:
-        # semantic segmentation classification heads
-        rename_keys.extend(
-            [
-                ("decode_head.conv_seg.weight", "decode_head.classifier.weight"),
-                ("decode_head.conv_seg.bias", "decode_head.classifier.bias"),
-                ("auxiliary_head.conv_seg.weight", "auxiliary_head.classifier.weight"),
-                ("auxiliary_head.conv_seg.bias", "auxiliary_head.classifier.bias"),
-            ]
-        )
-    else:
-        # layernorm + classification head
-        rename_keys.extend(
-            [
-                ("fc_norm.weight", f"{hf_prefix}pooler.layernorm.weight"),
-                ("fc_norm.bias", f"{hf_prefix}pooler.layernorm.bias"),
-                ("head.weight", "classifier.weight"),
-                ("head.bias", "classifier.bias"),
-            ]
-        )
-
-    return rename_keys
-
-
-def read_in_q_k_v(state_dict, config, has_lm_head=False, is_semantic=False, hf_prefix="data2vec_vision."):
-    for i in range(config.num_hidden_layers):
-        prefix = "backbone." if is_semantic else ""
-        # queries, keys and values
-        in_proj_weight = state_dict.pop(f"{prefix}blocks.{i}.attn.qkv.weight")
-        q_bias = state_dict.pop(f"{prefix}blocks.{i}.attn.q_bias")
-        v_bias = state_dict.pop(f"{prefix}blocks.{i}.attn.v_bias")
-
-        state_dict[f"{hf_prefix}encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"{hf_prefix}encoder.layer.{i}.attention.attention.query.bias"] = q_bias
-        state_dict[f"{hf_prefix}encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"{hf_prefix}encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"{hf_prefix}encoder.layer.{i}.attention.attention.value.bias"] = v_bias
-
-        # gamma_1 and gamma_2
-        # we call them lambda because otherwise they are renamed when using .from_pretrained
-        gamma_1 = state_dict.pop(f"{prefix}blocks.{i}.gamma_1")
-        gamma_2 = state_dict.pop(f"{prefix}blocks.{i}.gamma_2")
-
-        state_dict[f"{hf_prefix}encoder.layer.{i}.lambda_1"] = gamma_1
-        state_dict[f"{hf_prefix}encoder.layer.{i}.lambda_2"] = gamma_2
-
-        # relative_position bias table + index
-        if not has_lm_head:
-            # each layer has its own relative position bias
-            table = state_dict.pop(f"{prefix}blocks.{i}.attn.relative_position_bias_table")
-            index = state_dict.pop(f"{prefix}blocks.{i}.attn.relative_position_index")
-
-            state_dict[
-                f"{hf_prefix}encoder.layer.{i}.attention.attention.relative_position_bias.relative_position_bias_table"
-            ] = table
-            state_dict[
-                f"{hf_prefix}encoder.layer.{i}.attention.attention.relative_position_bias.relative_position_index"
-            ] = index
-
-
-def get_args():
-    parser = argparse.ArgumentParser(
-        "Convert Data2VecVision to HF for image classification and pretraining", add_help=False
-    )
-    parser.add_argument("--hf_checkpoint_name", type=str)
-    parser.add_argument("--input_size", default=224, type=int, help="images input size")
-    parser.add_argument("--beit_checkpoint", default="", help="beit checkpoint")
-
-    return parser.parse_args()
-
-
-def load_beit_model(args, is_finetuned, is_large):
-    def load_state_dict(model, state_dict, prefix="", ignore_missing="relative_position_index"):
-        missing_keys = []
-        unexpected_keys = []
-        error_msgs = []
-        # copy state_dict so _load_from_state_dict can modify it
-        metadata = getattr(state_dict, "_metadata", None)
-        state_dict = state_dict.copy()
-        if metadata is not None:
-            state_dict._metadata = metadata
-
-        def load(module, prefix=""):
-            local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})
-            module._load_from_state_dict(
-                state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs
-            )
-            for name, child in module._modules.items():
-                if child is not None:
-                    load(child, prefix + name + ".")
-
-        load(model, prefix=prefix)
-
-        warn_missing_keys = []
-        ignore_missing_keys = []
-        for key in missing_keys:
-            keep_flag = True
-            for ignore_key in ignore_missing.split("|"):
-                if ignore_key in key:
-                    keep_flag = False
-                    break
-            if keep_flag:
-                warn_missing_keys.append(key)
-            else:
-                ignore_missing_keys.append(key)
-
-        missing_keys = warn_missing_keys
-
-        if len(missing_keys) > 0:
-            print(
-                "Weights of {} not initialized from pretrained model: {}".format(
-                    model.__class__.__name__, missing_keys
-                )
-            )
-        if len(unexpected_keys) > 0:
-            print("Weights from pretrained model not used in {}: {}".format(model.__class__.__name__, unexpected_keys))
-        if len(ignore_missing_keys) > 0:
-            print(
-                "Ignored weights of {} not initialized from pretrained model: {}".format(
-                    model.__class__.__name__, ignore_missing_keys
-                )
-            )
-        if len(error_msgs) > 0:
-            print("\n".join(error_msgs))
-
-    model_kwargs = {
-        "pretrained": False,
-        "use_shared_rel_pos_bias": True,
-        "use_abs_pos_emb": False,
-        "init_values": 0.1,
-    }
-
-    if is_finetuned:
-        model_kwargs.update(
-            {
-                "num_classes": 1000,
-                "use_mean_pooling": True,
-                "init_scale": 0.001,
-                "use_rel_pos_bias": True,
-            }
-        )
-
-    model = create_model(
-        "beit_large_patch16_224" if is_large else "beit_base_patch16_224",
-        **model_kwargs,
-    )
-    patch_size = model.patch_embed.patch_size
-    args.window_size = (args.input_size // patch_size[0], args.input_size // patch_size[1])
-    checkpoint = torch.load(args.beit_checkpoint, map_location="cpu")
-
-    print(f"Load ckpt from {args.beit_checkpoint}")
-    checkpoint_model = None
-    for model_key in ("model", "module"):
-        if model_key in checkpoint:
-            checkpoint_model = checkpoint[model_key]
-            print(f"Load state_dict by model_key = {model_key}")
-            break
-
-    all_keys = list(checkpoint_model.keys())
-    for key in all_keys:
-        if "relative_position_index" in key:
-            checkpoint_model.pop(key)
-
-        if "relative_position_bias_table" in key:
-            rel_pos_bias = checkpoint_model[key]
-            src_num_pos, num_attn_heads = rel_pos_bias.size()
-            dst_num_pos, _ = model.state_dict()[key].size()
-            dst_patch_shape = model.patch_embed.patch_shape
-            if dst_patch_shape[0] != dst_patch_shape[1]:
-                raise NotImplementedError()
-
-    load_state_dict(model, checkpoint_model, prefix="")
-
-    return model
-
-
-def main():
-    args = get_args()
-
-    is_finetuned = "ft1k" in args.hf_checkpoint_name
-    is_large = "large" in args.hf_checkpoint_name
-
-    if is_finetuned:
-        # To convert Beit's data2vec_vision to HF you need to copy
-        # https://github.com/facebookresearch/data2vec_vision/blob/main/beit/modeling_finetune.py
-        # into this folder.
-        import modeling_finetune  # noqa: F401
-    else:
-        # To convert Beit's data2vec_vision to HF you need to copy
-        # https://github.com/facebookresearch/data2vec_vision/blob/main/beit/modeling_cyclical.py
-        # into this folder
-        # IMPORTANT: Note that for now we've only converted the down-stream
-        # model and not the full pretrained model. This means for the integration
-        # test you need to add a `return x` after the following line:
-        # https://github.com/facebookresearch/data2vec_vision/blob/af9a36349aaed59ae66e69b5dabeef2d62fdc5da/beit/modeling_cyclical.py#L197
-        # to make the integration test pass.
-        import modeling_cyclical  # noqa: F401
-
-    # 1. Create model config
-    config = Data2VecVisionConfig()
-    if is_finetuned:
-        config.use_relative_position_bias = True
-        config.use_shared_relative_position_bias = False
-        config.use_mean_pooling = True
-        config.num_labels = 1000
-
-        repo_id = "huggingface/label-files"
-        filename = "imagenet-1k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-    else:
-        config.use_relative_position_bias = False
-        config.use_shared_relative_position_bias = True
-        config.use_mean_pooling = False
-
-    if is_large:
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-
-    # 2. Load Beit model
-    orig_model = load_beit_model(args, is_finetuned, is_large)
-    orig_model.eval()
-
-    # 3. Forward Beit model
-    image_processor = BeitImageProcessor(size=config.image_size, do_center_crop=False)
-    image = Image.open("../../../../tests/fixtures/tests_samples/COCO/000000039769.png")
-    encoding = image_processor(images=image, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    orig_args = (pixel_values,) if is_finetuned else (pixel_values, None)
-    with torch.no_grad():
-        orig_model_output = orig_model(*orig_args)
-
-    # 4. Load HF Data2VecVision model
-    if is_finetuned:
-        hf_model = Data2VecVisionForImageClassification(config)
-        hf_model.eval()
-        has_lm_head = False
-        hf_prefix = "data2vec_vision."
-    else:
-        hf_model = Data2VecVisionModel(config)
-        hf_model.eval()
-        has_lm_head = True
-        hf_prefix = ""
-
-    rename_keys = create_rename_keys(config, hf_prefix=hf_prefix, has_lm_head=has_lm_head)
-    state_dict = orig_model.state_dict()
-    for src, dest in rename_keys:
-        val = state_dict.pop(src)
-        state_dict[dest] = val
-
-    read_in_q_k_v(state_dict, config, hf_prefix=hf_prefix, has_lm_head=has_lm_head)
-    missing_keys, unexpected_keys = hf_model.load_state_dict(state_dict, strict=False)
-    print("HF missing", missing_keys)
-    print("HF unexpected_keys", unexpected_keys)
-
-    # 5. Forward HF Data2VecVision model
-    with torch.no_grad():
-        hf_model_output = hf_model(pixel_values)
-
-    hf_output = hf_model_output.logits if is_finetuned else hf_model_output.last_hidden_state
-
-    # 6. Compare
-    max_absolute_diff = torch.max(torch.abs(hf_output - orig_model_output)).item()
-
-    print(f"max_absolute_diff = {max_absolute_diff}")
-    success = torch.allclose(hf_output, orig_model_output, atol=1e-3)
-    print("Do both models output the same tensors?", "🔥" if success else "💩")
-    if not success:
-        raise Exception("Something went wRoNg")
-
-    # 7. Save
-    print(f"Saving to {args.hf_checkpoint_name}")
-    hf_model.save_pretrained(args.hf_checkpoint_name)
-    image_processor.save_pretrained(args.hf_checkpoint_name)
-
-
-if __name__ == "__main__":
-    main()
-    # Run the following to convert checkpoints
-    #  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
-    #          --beit_checkpoint ./pretrained_base.pt \
-    #          --hf_checkpoint_name "./data2vec-vision-base"
-    #  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
-    #          --beit_checkpoint ./finetuned_base.pt \
-    #          --hf_checkpoint_name "./data2vec-vision-base-ft1k"
-    #  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
-    #          --beit_checkpoint ./pretrained_large.pt \
-    #          --hf_checkpoint_name "./data2vec-vision-large"
-    #  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
-    #          --beit_checkpoint ./finetuned_large.pt \
-    #          --hf_checkpoint_name "./data2vec-vision-large-ft1k"
diff --git a/src/transformers/models/deformable_detr/convert_deformable_detr_to_pytorch.py b/src/transformers/models/deformable_detr/convert_deformable_detr_to_pytorch.py
deleted file mode 100644
index 781b823e96f3..000000000000
--- a/src/transformers/models/deformable_detr/convert_deformable_detr_to_pytorch.py
+++ /dev/null
@@ -1,236 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Deformable DETR checkpoints."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DeformableDetrConfig, DeformableDetrForObjectDetection, DeformableDetrImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def rename_key(orig_key):
-    if "backbone.0.body" in orig_key:
-        orig_key = orig_key.replace("backbone.0.body", "backbone.conv_encoder.model")
-    if "transformer" in orig_key:
-        orig_key = orig_key.replace("transformer.", "")
-    if "norm1" in orig_key:
-        if "encoder" in orig_key:
-            orig_key = orig_key.replace("norm1", "self_attn_layer_norm")
-        else:
-            orig_key = orig_key.replace("norm1", "encoder_attn_layer_norm")
-    if "norm2" in orig_key:
-        if "encoder" in orig_key:
-            orig_key = orig_key.replace("norm2", "final_layer_norm")
-        else:
-            orig_key = orig_key.replace("norm2", "self_attn_layer_norm")
-    if "norm3" in orig_key:
-        orig_key = orig_key.replace("norm3", "final_layer_norm")
-    if "linear1" in orig_key:
-        orig_key = orig_key.replace("linear1", "fc1")
-    if "linear2" in orig_key:
-        orig_key = orig_key.replace("linear2", "fc2")
-    if "query_embed" in orig_key:
-        orig_key = orig_key.replace("query_embed", "query_position_embeddings")
-    if "cross_attn" in orig_key:
-        orig_key = orig_key.replace("cross_attn", "encoder_attn")
-
-    return orig_key
-
-
-def read_in_q_k_v(state_dict):
-    # transformer decoder self-attention layers
-    for i in range(6):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-
-    return im
-
-
-@torch.no_grad()
-def convert_deformable_detr_checkpoint(
-    checkpoint_path,
-    single_scale,
-    dilation,
-    with_box_refine,
-    two_stage,
-    pytorch_dump_folder_path,
-    push_to_hub,
-):
-    """
-    Copy/paste/tweak model's weights to our Deformable DETR structure.
-    """
-
-    # load default config
-    config = DeformableDetrConfig()
-    # set config attributes
-    if single_scale:
-        config.num_feature_levels = 1
-    config.dilation = dilation
-    config.with_box_refine = with_box_refine
-    config.two_stage = two_stage
-    # set labels
-    config.num_labels = 91
-    repo_id = "huggingface/label-files"
-    filename = "coco-detection-id2label.json"
-    id2label = json.loads(Path(hf_hub_download(repo_id, filename, repo_type="dataset")).read_text())
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    # load image processor
-    image_processor = DeformableDetrImageProcessor(format="coco_detection")
-
-    # prepare image
-    img = prepare_img()
-    encoding = image_processor(images=img, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    logger.info("Converting model...")
-
-    # load original state dict
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-    # rename keys
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        state_dict[rename_key(key)] = val
-    # query, key and value matrices need special treatment
-    read_in_q_k_v(state_dict)
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    prefix = "model."
-    for key in state_dict.copy().keys():
-        if not key.startswith("class_embed") and not key.startswith("bbox_embed"):
-            val = state_dict.pop(key)
-            state_dict[prefix + key] = val
-    # finally, create HuggingFace model and load state dict
-    model = DeformableDetrForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    model.to(device)
-    # verify our conversion
-    outputs = model(pixel_values.to(device))
-
-    expected_logits = torch.tensor(
-        [[-9.6645, -4.3449, -5.8705], [-9.7035, -3.8504, -5.0724], [-10.5634, -5.3379, -7.5116]]
-    )
-    expected_boxes = torch.tensor([[0.8693, 0.2289, 0.2492], [0.3150, 0.5489, 0.5845], [0.5563, 0.7580, 0.8518]])
-
-    if single_scale:
-        expected_logits = torch.tensor(
-            [[-9.9051, -4.2541, -6.4852], [-9.6947, -4.0854, -6.8033], [-10.0665, -5.8470, -7.7003]]
-        )
-        expected_boxes = torch.tensor([[0.7292, 0.4991, 0.5532], [0.7959, 0.2426, 0.4236], [0.7582, 0.3518, 0.4451]])
-
-    if single_scale and dilation:
-        expected_logits = torch.tensor(
-            [[-8.9652, -4.1074, -5.6635], [-9.0596, -4.9447, -6.6075], [-10.1178, -4.5275, -6.2671]]
-        )
-        expected_boxes = torch.tensor([[0.7665, 0.4130, 0.4769], [0.8364, 0.1841, 0.3391], [0.6261, 0.3895, 0.7978]])
-
-    if with_box_refine:
-        expected_logits = torch.tensor(
-            [[-8.8895, -5.4187, -6.8153], [-8.4706, -6.1668, -7.6184], [-9.0042, -5.5359, -6.9141]]
-        )
-        expected_boxes = torch.tensor([[0.7828, 0.2208, 0.4323], [0.0892, 0.5996, 0.1319], [0.5524, 0.6389, 0.8914]])
-
-    if with_box_refine and two_stage:
-        expected_logits = torch.tensor(
-            [[-6.7108, -4.3213, -6.3777], [-8.9014, -6.1799, -6.7240], [-6.9315, -4.4735, -6.2298]]
-        )
-        expected_boxes = torch.tensor([[0.2583, 0.5499, 0.4683], [0.7652, 0.9068, 0.4882], [0.5490, 0.2763, 0.0564]])
-
-    print("Logits:", outputs.logits[0, :3, :3])
-
-    assert torch.allclose(outputs.logits[0, :3, :3], expected_logits.to(device), atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes[0, :3, :3], expected_boxes.to(device), atol=1e-4)
-
-    print("Everything ok!")
-
-    # Save model and image processor
-    logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    # Push to hub
-    if push_to_hub:
-        model_name = "deformable-detr"
-        model_name += "-single-scale" if single_scale else ""
-        model_name += "-dc5" if dilation else ""
-        model_name += "-with-box-refine" if with_box_refine else ""
-        model_name += "-two-stage" if two_stage else ""
-        print("Pushing model to hub...")
-        model.push_to_hub(repo_path_or_name=model_name, organization="nielsr", commit_message="Add model")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_path",
-        type=str,
-        default="/home/niels/checkpoints/deformable_detr/r50_deformable_detr-checkpoint.pth",
-        help="Path to Pytorch checkpoint (.pth file) you'd like to convert.",
-    )
-    parser.add_argument("--single_scale", action="store_true", help="Whether to set config.num_features_levels = 1.")
-    parser.add_argument("--dilation", action="store_true", help="Whether to set config.dilation=True.")
-    parser.add_argument("--with_box_refine", action="store_true", help="Whether to set config.with_box_refine=True.")
-    parser.add_argument("--two_stage", action="store_true", help="Whether to set config.two_stage=True.")
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the folder to output PyTorch model.",
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-    convert_deformable_detr_checkpoint(
-        args.checkpoint_path,
-        args.single_scale,
-        args.dilation,
-        args.with_box_refine,
-        args.two_stage,
-        args.pytorch_dump_folder_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/deit/convert_deit_timm_to_pytorch.py b/src/transformers/models/deit/convert_deit_timm_to_pytorch.py
deleted file mode 100644
index e7bf3e7a12e8..000000000000
--- a/src/transformers/models/deit/convert_deit_timm_to_pytorch.py
+++ /dev/null
@@ -1,218 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DeiT distilled checkpoints from the timm library."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import timm
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DeiTConfig, DeiTForImageClassificationWithTeacher, DeiTImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, base_model=False):
-    rename_keys = []
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"blocks.{i}.norm1.weight", f"deit.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"blocks.{i}.norm1.bias", f"deit.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append((f"blocks.{i}.attn.proj.weight", f"deit.encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.attn.proj.bias", f"deit.encoder.layer.{i}.attention.output.dense.bias"))
-        rename_keys.append((f"blocks.{i}.norm2.weight", f"deit.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"blocks.{i}.norm2.bias", f"deit.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"deit.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"deit.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"deit.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"deit.encoder.layer.{i}.output.dense.bias"))
-
-    # projection layer + position embeddings
-    rename_keys.extend(
-        [
-            ("cls_token", "deit.embeddings.cls_token"),
-            ("dist_token", "deit.embeddings.distillation_token"),
-            ("patch_embed.proj.weight", "deit.embeddings.patch_embeddings.projection.weight"),
-            ("patch_embed.proj.bias", "deit.embeddings.patch_embeddings.projection.bias"),
-            ("pos_embed", "deit.embeddings.position_embeddings"),
-        ]
-    )
-
-    if base_model:
-        # layernorm + pooler
-        rename_keys.extend(
-            [
-                ("norm.weight", "layernorm.weight"),
-                ("norm.bias", "layernorm.bias"),
-                ("pre_logits.fc.weight", "pooler.dense.weight"),
-                ("pre_logits.fc.bias", "pooler.dense.bias"),
-            ]
-        )
-
-        # if just the base model, we should remove "deit" from all keys that start with "deit"
-        rename_keys = [(pair[0], pair[1][4:]) if pair[1].startswith("deit") else pair for pair in rename_keys]
-    else:
-        # layernorm + classification heads
-        rename_keys.extend(
-            [
-                ("norm.weight", "deit.layernorm.weight"),
-                ("norm.bias", "deit.layernorm.bias"),
-                ("head.weight", "cls_classifier.weight"),
-                ("head.bias", "cls_classifier.bias"),
-                ("head_dist.weight", "distillation_classifier.weight"),
-                ("head_dist.bias", "distillation_classifier.bias"),
-            ]
-        )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, base_model=False):
-    for i in range(config.num_hidden_layers):
-        if base_model:
-            prefix = ""
-        else:
-            prefix = "deit."
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_deit_checkpoint(deit_name, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our DeiT structure.
-    """
-
-    # define default DeiT configuration
-    config = DeiTConfig()
-    # all deit models have fine-tuned heads
-    base_model = False
-    # dataset (fine-tuned on ImageNet 2012), patch_size and image_size
-    config.num_labels = 1000
-    repo_id = "huggingface/label-files"
-    filename = "imagenet-1k-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-    config.patch_size = int(deit_name[-6:-4])
-    config.image_size = int(deit_name[-3:])
-    # size of the architecture
-    if deit_name[9:].startswith("tiny"):
-        config.hidden_size = 192
-        config.intermediate_size = 768
-        config.num_hidden_layers = 12
-        config.num_attention_heads = 3
-    elif deit_name[9:].startswith("small"):
-        config.hidden_size = 384
-        config.intermediate_size = 1536
-        config.num_hidden_layers = 12
-        config.num_attention_heads = 6
-    if deit_name[9:].startswith("base"):
-        pass
-    elif deit_name[4:].startswith("large"):
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-
-    # load original model from timm
-    timm_model = timm.create_model(deit_name, pretrained=True)
-    timm_model.eval()
-
-    # load state_dict of original model, remove and rename some keys
-    state_dict = timm_model.state_dict()
-    rename_keys = create_rename_keys(config, base_model)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config, base_model)
-
-    # load HuggingFace model
-    model = DeiTForImageClassificationWithTeacher(config).eval()
-    model.load_state_dict(state_dict)
-
-    # Check outputs on an image, prepared by DeiTImageProcessor
-    size = int(
-        (256 / 224) * config.image_size
-    )  # to maintain same ratio w.r.t. 224 images, see https://github.com/facebookresearch/deit/blob/ab5715372db8c6cad5740714b2216d55aeae052e/datasets.py#L103
-    image_processor = DeiTImageProcessor(size=size, crop_size=config.image_size)
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-    outputs = model(pixel_values)
-
-    timm_logits = timm_model(pixel_values)
-    assert timm_logits.shape == outputs.logits.shape
-    assert torch.allclose(timm_logits, outputs.logits, atol=1e-3)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {deit_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--deit_name",
-        default="vit_deit_base_distilled_patch16_224",
-        type=str,
-        help="Name of the DeiT timm model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_deit_checkpoint(args.deit_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/deprecated/bort/convert_bort_original_gluonnlp_checkpoint_to_pytorch.py b/src/transformers/models/deprecated/bort/convert_bort_original_gluonnlp_checkpoint_to_pytorch.py
deleted file mode 100644
index 1f3d675e091d..000000000000
--- a/src/transformers/models/deprecated/bort/convert_bort_original_gluonnlp_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,318 +0,0 @@
-# coding=utf-8
-# Copyright 2020, The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Bort checkpoint."""
-
-import argparse
-import os
-
-import gluonnlp as nlp
-import mxnet as mx
-import numpy as np
-import torch
-from gluonnlp.base import get_home_dir
-from gluonnlp.model.bert import BERTEncoder
-from gluonnlp.model.utils import _load_vocab
-from gluonnlp.vocab import Vocab
-from packaging import version
-from torch import nn
-
-from transformers import BertConfig, BertForMaskedLM, BertModel, RobertaTokenizer
-from transformers.models.bert.modeling_bert import (
-    BertIntermediate,
-    BertLayer,
-    BertOutput,
-    BertSelfAttention,
-    BertSelfOutput,
-)
-from transformers.utils import logging
-
-
-if version.parse(nlp.__version__) != version.parse("0.8.3"):
-    raise Exception("requires gluonnlp == 0.8.3")
-
-if version.parse(mx.__version__) != version.parse("1.5.0"):
-    raise Exception("requires mxnet == 1.5.0")
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-SAMPLE_TEXT = "The Nymphenburg Palace is a beautiful palace in Munich!"
-
-
-def convert_bort_checkpoint_to_pytorch(bort_checkpoint_path: str, pytorch_dump_folder_path: str):
-    """
-    Convert the original Bort checkpoint (based on MXNET and Gluonnlp) to our BERT structure-
-    """
-
-    # Original Bort configuration
-    bort_4_8_768_1024_hparams = {
-        "attention_cell": "multi_head",
-        "num_layers": 4,
-        "units": 1024,
-        "hidden_size": 768,
-        "max_length": 512,
-        "num_heads": 8,
-        "scaled": True,
-        "dropout": 0.1,
-        "use_residual": True,
-        "embed_size": 1024,
-        "embed_dropout": 0.1,
-        "word_embed": None,
-        "layer_norm_eps": 1e-5,
-        "token_type_vocab_size": 2,
-    }
-
-    predefined_args = bort_4_8_768_1024_hparams
-
-    # Let's construct the original Bort model here
-    # Taken from official BERT implementation, see:
-    # https://github.com/alexa/bort/blob/master/bort/bort.py
-    encoder = BERTEncoder(
-        attention_cell=predefined_args["attention_cell"],
-        num_layers=predefined_args["num_layers"],
-        units=predefined_args["units"],
-        hidden_size=predefined_args["hidden_size"],
-        max_length=predefined_args["max_length"],
-        num_heads=predefined_args["num_heads"],
-        scaled=predefined_args["scaled"],
-        dropout=predefined_args["dropout"],
-        output_attention=False,
-        output_all_encodings=False,
-        use_residual=predefined_args["use_residual"],
-        activation=predefined_args.get("activation", "gelu"),
-        layer_norm_eps=predefined_args.get("layer_norm_eps", None),
-    )
-
-    # Vocab information needs to be fetched first
-    # It's the same as RoBERTa, so RobertaTokenizer can be used later
-    vocab_name = "openwebtext_ccnews_stories_books_cased"
-
-    # Specify download folder to Gluonnlp's vocab
-    gluon_cache_dir = os.path.join(get_home_dir(), "models")
-    bort_vocab = _load_vocab(vocab_name, None, gluon_cache_dir, cls=Vocab)
-
-    original_bort = nlp.model.BERTModel(
-        encoder,
-        len(bort_vocab),
-        units=predefined_args["units"],
-        embed_size=predefined_args["embed_size"],
-        embed_dropout=predefined_args["embed_dropout"],
-        word_embed=predefined_args["word_embed"],
-        use_pooler=False,
-        use_token_type_embed=False,
-        token_type_vocab_size=predefined_args["token_type_vocab_size"],
-        use_classifier=False,
-        use_decoder=False,
-    )
-
-    original_bort.load_parameters(bort_checkpoint_path, cast_dtype=True, ignore_extra=True)
-    params = original_bort._collect_params_with_prefix()
-
-    # Build our config 🤗
-    hf_bort_config_json = {
-        "architectures": ["BertForMaskedLM"],
-        "attention_probs_dropout_prob": predefined_args["dropout"],
-        "hidden_act": "gelu",
-        "hidden_dropout_prob": predefined_args["dropout"],
-        "hidden_size": predefined_args["embed_size"],
-        "initializer_range": 0.02,
-        "intermediate_size": predefined_args["hidden_size"],
-        "layer_norm_eps": predefined_args["layer_norm_eps"],
-        "max_position_embeddings": predefined_args["max_length"],
-        "model_type": "bort",
-        "num_attention_heads": predefined_args["num_heads"],
-        "num_hidden_layers": predefined_args["num_layers"],
-        "pad_token_id": 1,  # 2 = BERT, 1 = RoBERTa
-        "type_vocab_size": 1,  # 2 = BERT, 1 = RoBERTa
-        "vocab_size": len(bort_vocab),
-    }
-
-    hf_bort_config = BertConfig.from_dict(hf_bort_config_json)
-    hf_bort_model = BertForMaskedLM(hf_bort_config)
-    hf_bort_model.eval()
-
-    # Parameter mapping table (Gluonnlp to Transformers)
-    # * denotes layer index
-    #
-    # | Gluon Parameter                                                | Transformers Parameter
-    # | -------------------------------------------------------------- | ----------------------
-    # | `encoder.layer_norm.beta`                                      | `bert.embeddings.LayerNorm.bias`
-    # | `encoder.layer_norm.gamma`                                     | `bert.embeddings.LayerNorm.weight`
-    # | `encoder.position_weight`                                      | `bert.embeddings.position_embeddings.weight`
-    # | `word_embed.0.weight`                                          | `bert.embeddings.word_embeddings.weight`
-    # | `encoder.transformer_cells.*.attention_cell.proj_key.bias`     | `bert.encoder.layer.*.attention.self.key.bias`
-    # | `encoder.transformer_cells.*.attention_cell.proj_key.weight`   | `bert.encoder.layer.*.attention.self.key.weight`
-    # | `encoder.transformer_cells.*.attention_cell.proj_query.bias`   | `bert.encoder.layer.*.attention.self.query.bias`
-    # | `encoder.transformer_cells.*.attention_cell.proj_query.weight` | `bert.encoder.layer.*.attention.self.query.weight`
-    # | `encoder.transformer_cells.*.attention_cell.proj_value.bias`   | `bert.encoder.layer.*.attention.self.value.bias`
-    # | `encoder.transformer_cells.*.attention_cell.proj_value.weight` | `bert.encoder.layer.*.attention.self.value.weight`
-    # | `encoder.transformer_cells.*.ffn.ffn_2.bias`                   | `bert.encoder.layer.*.attention.output.dense.bias`
-    # | `encoder.transformer_cells.*.ffn.ffn_2.weight`                 | `bert.encoder.layer.*.attention.output.dense.weight`
-    # | `encoder.transformer_cells.*.layer_norm.beta`                  | `bert.encoder.layer.*.attention.output.LayerNorm.bias`
-    # | `encoder.transformer_cells.*.layer_norm.gamma`                 | `bert.encoder.layer.*.attention.output.LayerNorm.weight`
-    # | `encoder.transformer_cells.*.ffn.ffn_1.bias`                   | `bert.encoder.layer.*.intermediate.dense.bias`
-    # | `encoder.transformer_cells.*.ffn.ffn_1.weight`                 | `bert.encoder.layer.*.intermediate.dense.weight`
-    # | `encoder.transformer_cells.*.ffn.layer_norm.beta`              | `bert.encoder.layer.*.output.LayerNorm.bias`
-    # | `encoder.transformer_cells.*.ffn.layer_norm.gamma`             | `bert.encoder.layer.*.output.LayerNorm.weight`
-    # | `encoder.transformer_cells.*.proj.bias`                        | `bert.encoder.layer.*.output.dense.bias`
-    # | `encoder.transformer_cells.*.proj.weight`                      | `bert.encoder.layer.*.output.dense.weight`
-
-    # Helper function to convert MXNET Arrays to PyTorch
-    def to_torch(mx_array) -> nn.Parameter:
-        return nn.Parameter(torch.FloatTensor(mx_array.data().asnumpy()))
-
-    # Check param shapes and map new HF param back
-    def check_and_map_params(hf_param, gluon_param):
-        shape_hf = hf_param.shape
-
-        gluon_param = to_torch(params[gluon_param])
-        shape_gluon = gluon_param.shape
-
-        assert shape_hf == shape_gluon, (
-            f"The gluon parameter {gluon_param} has shape {shape_gluon}, but expects shape {shape_hf} for Transformers"
-        )
-
-        return gluon_param
-
-    hf_bort_model.bert.embeddings.word_embeddings.weight = check_and_map_params(
-        hf_bort_model.bert.embeddings.word_embeddings.weight, "word_embed.0.weight"
-    )
-    hf_bort_model.bert.embeddings.position_embeddings.weight = check_and_map_params(
-        hf_bort_model.bert.embeddings.position_embeddings.weight, "encoder.position_weight"
-    )
-    hf_bort_model.bert.embeddings.LayerNorm.bias = check_and_map_params(
-        hf_bort_model.bert.embeddings.LayerNorm.bias, "encoder.layer_norm.beta"
-    )
-    hf_bort_model.bert.embeddings.LayerNorm.weight = check_and_map_params(
-        hf_bort_model.bert.embeddings.LayerNorm.weight, "encoder.layer_norm.gamma"
-    )
-
-    # Inspired by RoBERTa conversion script, we just zero them out (Bort does not use them)
-    hf_bort_model.bert.embeddings.token_type_embeddings.weight.data = torch.zeros_like(
-        hf_bort_model.bert.embeddings.token_type_embeddings.weight.data
-    )
-
-    for i in range(hf_bort_config.num_hidden_layers):
-        layer: BertLayer = hf_bort_model.bert.encoder.layer[i]
-
-        # self attention
-        self_attn: BertSelfAttention = layer.attention.self
-
-        self_attn.key.bias.data = check_and_map_params(
-            self_attn.key.bias.data, f"encoder.transformer_cells.{i}.attention_cell.proj_key.bias"
-        )
-
-        self_attn.key.weight.data = check_and_map_params(
-            self_attn.key.weight.data, f"encoder.transformer_cells.{i}.attention_cell.proj_key.weight"
-        )
-        self_attn.query.bias.data = check_and_map_params(
-            self_attn.query.bias.data, f"encoder.transformer_cells.{i}.attention_cell.proj_query.bias"
-        )
-        self_attn.query.weight.data = check_and_map_params(
-            self_attn.query.weight.data, f"encoder.transformer_cells.{i}.attention_cell.proj_query.weight"
-        )
-        self_attn.value.bias.data = check_and_map_params(
-            self_attn.value.bias.data, f"encoder.transformer_cells.{i}.attention_cell.proj_value.bias"
-        )
-        self_attn.value.weight.data = check_and_map_params(
-            self_attn.value.weight.data, f"encoder.transformer_cells.{i}.attention_cell.proj_value.weight"
-        )
-
-        # self attention output
-        self_output: BertSelfOutput = layer.attention.output
-
-        self_output.dense.bias = check_and_map_params(
-            self_output.dense.bias, f"encoder.transformer_cells.{i}.proj.bias"
-        )
-        self_output.dense.weight = check_and_map_params(
-            self_output.dense.weight, f"encoder.transformer_cells.{i}.proj.weight"
-        )
-        self_output.LayerNorm.bias = check_and_map_params(
-            self_output.LayerNorm.bias, f"encoder.transformer_cells.{i}.layer_norm.beta"
-        )
-        self_output.LayerNorm.weight = check_and_map_params(
-            self_output.LayerNorm.weight, f"encoder.transformer_cells.{i}.layer_norm.gamma"
-        )
-
-        # intermediate
-        intermediate: BertIntermediate = layer.intermediate
-
-        intermediate.dense.bias = check_and_map_params(
-            intermediate.dense.bias, f"encoder.transformer_cells.{i}.ffn.ffn_1.bias"
-        )
-        intermediate.dense.weight = check_and_map_params(
-            intermediate.dense.weight, f"encoder.transformer_cells.{i}.ffn.ffn_1.weight"
-        )
-
-        # output
-        bert_output: BertOutput = layer.output
-
-        bert_output.dense.bias = check_and_map_params(
-            bert_output.dense.bias, f"encoder.transformer_cells.{i}.ffn.ffn_2.bias"
-        )
-        bert_output.dense.weight = check_and_map_params(
-            bert_output.dense.weight, f"encoder.transformer_cells.{i}.ffn.ffn_2.weight"
-        )
-        bert_output.LayerNorm.bias = check_and_map_params(
-            bert_output.LayerNorm.bias, f"encoder.transformer_cells.{i}.ffn.layer_norm.beta"
-        )
-        bert_output.LayerNorm.weight = check_and_map_params(
-            bert_output.LayerNorm.weight, f"encoder.transformer_cells.{i}.ffn.layer_norm.gamma"
-        )
-
-    # Save space and energy 🎄
-    hf_bort_model.half()
-
-    # Compare output of both models
-    tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
-
-    input_ids = tokenizer.encode_plus(SAMPLE_TEXT)["input_ids"]
-
-    # Get gluon output
-    gluon_input_ids = mx.nd.array([input_ids])
-    output_gluon = original_bort(inputs=gluon_input_ids, token_types=[])
-
-    # Get Transformer output (save and reload model again)
-    hf_bort_model.save_pretrained(pytorch_dump_folder_path)
-    hf_bort_model = BertModel.from_pretrained(pytorch_dump_folder_path)
-    hf_bort_model.eval()
-
-    input_ids = tokenizer.encode_plus(SAMPLE_TEXT, return_tensors="pt")
-    output_hf = hf_bort_model(**input_ids)[0]
-
-    gluon_layer = output_gluon[0].asnumpy()
-    hf_layer = output_hf[0].detach().numpy()
-
-    max_absolute_diff = np.max(np.abs(hf_layer - gluon_layer)).item()
-    success = np.allclose(gluon_layer, hf_layer, atol=1e-3)
-
-    if success:
-        print("✔️ Both model do output the same tensors")
-    else:
-        print("❌ Both model do **NOT** output the same tensors")
-        print("Absolute difference is:", max_absolute_diff)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--bort_checkpoint_path", default=None, type=str, required=True, help="Path the official Bort params file."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/deprecated/deta/convert_deta_resnet_to_pytorch.py b/src/transformers/models/deprecated/deta/convert_deta_resnet_to_pytorch.py
deleted file mode 100644
index 60e93efe7c60..000000000000
--- a/src/transformers/models/deprecated/deta/convert_deta_resnet_to_pytorch.py
+++ /dev/null
@@ -1,319 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DETA checkpoints from the original repository.
-
-URL: https://github.com/jozhang97/DETA/tree/master"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_deta_config():
-    config = DetaConfig(
-        num_queries=900,
-        encoder_ffn_dim=2048,
-        decoder_ffn_dim=2048,
-        num_feature_levels=5,
-        assign_first_stage=True,
-        with_box_refine=True,
-        two_stage=True,
-    )
-
-    # set labels
-    config.num_labels = 91
-    repo_id = "huggingface/label-files"
-    filename = "coco-detection-id2label.json"
-    id2label = json.loads(Path(hf_hub_download(repo_id, filename, repo_type="dataset")).read_text())
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-
-    # stem
-    # fmt: off
-    rename_keys.append(("backbone.0.body.conv1.weight", "model.backbone.model.embedder.embedder.convolution.weight"))
-    rename_keys.append(("backbone.0.body.bn1.weight", "model.backbone.model.embedder.embedder.normalization.weight"))
-    rename_keys.append(("backbone.0.body.bn1.bias", "model.backbone.model.embedder.embedder.normalization.bias"))
-    rename_keys.append(("backbone.0.body.bn1.running_mean", "model.backbone.model.embedder.embedder.normalization.running_mean"))
-    rename_keys.append(("backbone.0.body.bn1.running_var", "model.backbone.model.embedder.embedder.normalization.running_var"))
-    # stages
-    for stage_idx in range(len(config.backbone_config.depths)):
-        for layer_idx in range(config.backbone_config.depths[stage_idx]):
-            # shortcut
-            if layer_idx == 0:
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var",
-                    )
-                )
-            # 3 convs
-            for i in range(3):
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var",
-                    )
-                )
-    # transformer encoder
-    for i in range(config.encoder_layers):
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight", f"model.encoder.layers.{i}.self_attn.sampling_offsets.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias", f"model.encoder.layers.{i}.self_attn.sampling_offsets.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.attention_weights.weight", f"model.encoder.layers.{i}.self_attn.attention_weights.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.attention_weights.bias", f"model.encoder.layers.{i}.self_attn.attention_weights.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.value_proj.weight", f"model.encoder.layers.{i}.self_attn.value_proj.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.value_proj.bias", f"model.encoder.layers.{i}.self_attn.value_proj.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.output_proj.weight", f"model.encoder.layers.{i}.self_attn.output_proj.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.output_proj.bias", f"model.encoder.layers.{i}.self_attn.output_proj.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm1.weight", f"model.encoder.layers.{i}.self_attn_layer_norm.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm1.bias", f"model.encoder.layers.{i}.self_attn_layer_norm.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.weight", f"model.encoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.bias", f"model.encoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.weight", f"model.encoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.bias", f"model.encoder.layers.{i}.fc2.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm2.weight", f"model.encoder.layers.{i}.final_layer_norm.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm2.bias", f"model.encoder.layers.{i}.final_layer_norm.bias"))
-
-    # transformer decoder
-    for i in range(config.decoder_layers):
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight", f"model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias", f"model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.attention_weights.weight", f"model.decoder.layers.{i}.encoder_attn.attention_weights.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.attention_weights.bias", f"model.decoder.layers.{i}.encoder_attn.attention_weights.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.value_proj.weight", f"model.decoder.layers.{i}.encoder_attn.value_proj.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.value_proj.bias", f"model.decoder.layers.{i}.encoder_attn.value_proj.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.output_proj.weight", f"model.decoder.layers.{i}.encoder_attn.output_proj.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.output_proj.bias", f"model.decoder.layers.{i}.encoder_attn.output_proj.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm1.weight", f"model.decoder.layers.{i}.encoder_attn_layer_norm.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm1.bias", f"model.decoder.layers.{i}.encoder_attn_layer_norm.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.self_attn.out_proj.weight", f"model.decoder.layers.{i}.self_attn.out_proj.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.self_attn.out_proj.bias", f"model.decoder.layers.{i}.self_attn.out_proj.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm2.weight", f"model.decoder.layers.{i}.self_attn_layer_norm.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm2.bias", f"model.decoder.layers.{i}.self_attn_layer_norm.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.weight", f"model.decoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.bias", f"model.decoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.weight", f"model.decoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.bias", f"model.decoder.layers.{i}.fc2.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm3.weight", f"model.decoder.layers.{i}.final_layer_norm.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm3.bias", f"model.decoder.layers.{i}.final_layer_norm.bias"))
-
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def read_in_decoder_q_k_v(state_dict, config):
-    # transformer decoder self-attention layers
-    hidden_size = config.d_model
-    for i in range(config.decoder_layers):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:hidden_size, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:hidden_size]
-        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[hidden_size : hidden_size * 2]
-        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-hidden_size:, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-hidden_size:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-
-    return im
-
-
-@torch.no_grad()
-def convert_deta_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our DETA structure.
-    """
-
-    # load config
-    config = get_deta_config()
-
-    # load original state dict
-    if model_name == "deta-resnet-50":
-        filename = "adet_checkpoint0011.pth"
-    elif model_name == "deta-resnet-50-24-epochs":
-        filename = "adet_2x_checkpoint0023.pth"
-    else:
-        raise ValueError(f"Model name {model_name} not supported")
-    checkpoint_path = hf_hub_download(repo_id="nielsr/deta-checkpoints", filename=filename)
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_decoder_q_k_v(state_dict, config)
-
-    # fix some prefixes
-    for key in state_dict.copy().keys():
-        if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
-            val = state_dict.pop(key)
-            state_dict[key.replace("transformer.decoder", "model.decoder")] = val
-        if "input_proj" in key:
-            val = state_dict.pop(key)
-            state_dict["model." + key] = val
-        if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
-            val = state_dict.pop(key)
-            state_dict[key.replace("transformer", "model")] = val
-
-    # finally, create HuggingFace model and load state dict
-    model = DetaForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    model.to(device)
-
-    # load image processor
-    processor = DetaImageProcessor(format="coco_detection")
-
-    # verify our conversion on image
-    img = prepare_img()
-    encoding = processor(images=img, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-    outputs = model(pixel_values.to(device))
-
-    # verify logits
-    if model_name == "deta-resnet-50":
-        expected_logits = torch.tensor(
-            [[-7.3978, -2.5406, -4.1668], [-8.2684, -3.9933, -3.8096], [-7.0515, -3.7973, -5.8516]]
-        )
-        expected_boxes = torch.tensor([[0.5043, 0.4973, 0.9998], [0.2542, 0.5489, 0.4748], [0.5490, 0.2765, 0.0570]])
-    elif model_name == "deta-resnet-50-24-epochs":
-        expected_logits = torch.tensor(
-            [[-7.1688, -2.4857, -4.8669], [-7.8630, -3.8154, -4.2674], [-7.2730, -4.1865, -5.5323]]
-        )
-        expected_boxes = torch.tensor([[0.5021, 0.4971, 0.9994], [0.2546, 0.5486, 0.4731], [0.1686, 0.1986, 0.2142]])
-
-    assert torch.allclose(outputs.logits[0, :3, :3], expected_logits.to(device), atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes[0, :3, :3], expected_boxes.to(device), atol=1e-4)
-    print("Everything ok!")
-
-    if pytorch_dump_folder_path:
-        # Save model and processor
-        logger.info(f"Saving PyTorch model and processor to {pytorch_dump_folder_path}...")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    # Push to hub
-    if push_to_hub:
-        print("Pushing model and processor to hub...")
-        model.push_to_hub(f"jozhang97/{model_name}")
-        processor.push_to_hub(f"jozhang97/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--model_name",
-        type=str,
-        default="deta-resnet-50",
-        choices=["deta-resnet-50", "deta-resnet-50-24-epochs"],
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the folder to output PyTorch model.",
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-    convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/deprecated/deta/convert_deta_swin_to_pytorch.py b/src/transformers/models/deprecated/deta/convert_deta_swin_to_pytorch.py
deleted file mode 100644
index 392750fa67a1..000000000000
--- a/src/transformers/models/deprecated/deta/convert_deta_swin_to_pytorch.py
+++ /dev/null
@@ -1,326 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DETA checkpoints from the original repository.
-
-URL: https://github.com/jozhang97/DETA/tree/master"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_deta_config(model_name):
-    backbone_config = SwinConfig(
-        embed_dim=192,
-        depths=(2, 2, 18, 2),
-        num_heads=(6, 12, 24, 48),
-        window_size=12,
-        out_features=["stage2", "stage3", "stage4"],
-    )
-
-    config = DetaConfig(
-        backbone_config=backbone_config,
-        num_queries=900,
-        encoder_ffn_dim=2048,
-        decoder_ffn_dim=2048,
-        num_feature_levels=5,
-        assign_first_stage=True,
-        with_box_refine=True,
-        two_stage=True,
-    )
-
-    # set labels
-    repo_id = "huggingface/label-files"
-    if "o365" in model_name:
-        num_labels = 366
-        filename = "object365-id2label.json"
-    else:
-        num_labels = 91
-        filename = "coco-detection-id2label.json"
-
-    config.num_labels = num_labels
-    id2label = json.loads(Path(hf_hub_download(repo_id, filename, repo_type="dataset")).read_text())
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-
-    # stem
-    # fmt: off
-    rename_keys.append(("backbone.0.body.patch_embed.proj.weight", "model.backbone.model.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("backbone.0.body.patch_embed.proj.bias", "model.backbone.model.embeddings.patch_embeddings.projection.bias"))
-    rename_keys.append(("backbone.0.body.patch_embed.norm.weight", "model.backbone.model.embeddings.norm.weight"))
-    rename_keys.append(("backbone.0.body.patch_embed.norm.bias", "model.backbone.model.embeddings.norm.bias"))
-    # stages
-    for i in range(len(config.backbone_config.depths)):
-        for j in range(config.backbone_config.depths[i]):
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.norm1.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.norm1.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.norm2.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.norm2.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias"))
-
-        if i < 3:
-            rename_keys.append((f"backbone.0.body.layers.{i}.downsample.reduction.weight", f"model.backbone.model.encoder.layers.{i}.downsample.reduction.weight"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.downsample.norm.weight", f"model.backbone.model.encoder.layers.{i}.downsample.norm.weight"))
-            rename_keys.append((f"backbone.0.body.layers.{i}.downsample.norm.bias", f"model.backbone.model.encoder.layers.{i}.downsample.norm.bias"))
-
-    rename_keys.append(("backbone.0.body.norm1.weight", "model.backbone.model.hidden_states_norms.stage2.weight"))
-    rename_keys.append(("backbone.0.body.norm1.bias", "model.backbone.model.hidden_states_norms.stage2.bias"))
-    rename_keys.append(("backbone.0.body.norm2.weight", "model.backbone.model.hidden_states_norms.stage3.weight"))
-    rename_keys.append(("backbone.0.body.norm2.bias", "model.backbone.model.hidden_states_norms.stage3.bias"))
-    rename_keys.append(("backbone.0.body.norm3.weight", "model.backbone.model.hidden_states_norms.stage4.weight"))
-    rename_keys.append(("backbone.0.body.norm3.bias", "model.backbone.model.hidden_states_norms.stage4.bias"))
-
-    # transformer encoder
-    for i in range(config.encoder_layers):
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight", f"model.encoder.layers.{i}.self_attn.sampling_offsets.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias", f"model.encoder.layers.{i}.self_attn.sampling_offsets.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.attention_weights.weight", f"model.encoder.layers.{i}.self_attn.attention_weights.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.attention_weights.bias", f"model.encoder.layers.{i}.self_attn.attention_weights.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.value_proj.weight", f"model.encoder.layers.{i}.self_attn.value_proj.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.value_proj.bias", f"model.encoder.layers.{i}.self_attn.value_proj.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.output_proj.weight", f"model.encoder.layers.{i}.self_attn.output_proj.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.output_proj.bias", f"model.encoder.layers.{i}.self_attn.output_proj.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm1.weight", f"model.encoder.layers.{i}.self_attn_layer_norm.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm1.bias", f"model.encoder.layers.{i}.self_attn_layer_norm.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.weight", f"model.encoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.bias", f"model.encoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.weight", f"model.encoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.bias", f"model.encoder.layers.{i}.fc2.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm2.weight", f"model.encoder.layers.{i}.final_layer_norm.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm2.bias", f"model.encoder.layers.{i}.final_layer_norm.bias"))
-
-    # transformer decoder
-    for i in range(config.decoder_layers):
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight", f"model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias", f"model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.attention_weights.weight", f"model.decoder.layers.{i}.encoder_attn.attention_weights.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.attention_weights.bias", f"model.decoder.layers.{i}.encoder_attn.attention_weights.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.value_proj.weight", f"model.decoder.layers.{i}.encoder_attn.value_proj.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.value_proj.bias", f"model.decoder.layers.{i}.encoder_attn.value_proj.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.output_proj.weight", f"model.decoder.layers.{i}.encoder_attn.output_proj.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.output_proj.bias", f"model.decoder.layers.{i}.encoder_attn.output_proj.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm1.weight", f"model.decoder.layers.{i}.encoder_attn_layer_norm.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm1.bias", f"model.decoder.layers.{i}.encoder_attn_layer_norm.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.self_attn.out_proj.weight", f"model.decoder.layers.{i}.self_attn.out_proj.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.self_attn.out_proj.bias", f"model.decoder.layers.{i}.self_attn.out_proj.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm2.weight", f"model.decoder.layers.{i}.self_attn_layer_norm.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm2.bias", f"model.decoder.layers.{i}.self_attn_layer_norm.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.weight", f"model.decoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.bias", f"model.decoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.weight", f"model.decoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.bias", f"model.decoder.layers.{i}.fc2.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm3.weight", f"model.decoder.layers.{i}.final_layer_norm.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm3.bias", f"model.decoder.layers.{i}.final_layer_norm.bias"))
-
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_swin_q_k_v(state_dict, backbone_config):
-    num_features = [int(backbone_config.embed_dim * 2**i) for i in range(len(backbone_config.depths))]
-    for i in range(len(backbone_config.depths)):
-        dim = num_features[i]
-        for j in range(backbone_config.depths[i]):
-            # fmt: off
-            # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-            in_proj_weight = state_dict.pop(f"backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight")
-            in_proj_bias = state_dict.pop(f"backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias")
-            # next, add query, keys and values (in that order) to the state dict
-            state_dict[f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.query.weight"] = in_proj_weight[:dim, :]
-            state_dict[f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.query.bias"] = in_proj_bias[: dim]
-            state_dict[f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.key.weight"] = in_proj_weight[
-                dim : dim * 2, :
-            ]
-            state_dict[f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.key.bias"] = in_proj_bias[
-                dim : dim * 2
-            ]
-            state_dict[f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.value.weight"] = in_proj_weight[
-                -dim :, :
-            ]
-            state_dict[f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.value.bias"] = in_proj_bias[-dim :]
-            # fmt: on
-
-
-def read_in_decoder_q_k_v(state_dict, config):
-    # transformer decoder self-attention layers
-    hidden_size = config.d_model
-    for i in range(config.decoder_layers):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:hidden_size, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:hidden_size]
-        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[hidden_size : hidden_size * 2]
-        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-hidden_size:, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-hidden_size:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-
-    return im
-
-
-@torch.no_grad()
-def convert_deta_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our DETA structure.
-    """
-
-    # load config
-    config = get_deta_config(model_name)
-
-    # load original state dict
-    if model_name == "deta-swin-large":
-        checkpoint_path = hf_hub_download(repo_id="nielsr/deta-checkpoints", filename="adet_swin_ft.pth")
-    elif model_name == "deta-swin-large-o365":
-        checkpoint_path = hf_hub_download(repo_id="jozhang97/deta-swin-l-o365", filename="deta_swin_pt_o365.pth")
-    else:
-        raise ValueError(f"Model name {model_name} not supported")
-
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-
-    # original state dict
-    for name, param in state_dict.items():
-        print(name, param.shape)
-
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_swin_q_k_v(state_dict, config.backbone_config)
-    read_in_decoder_q_k_v(state_dict, config)
-
-    # fix some prefixes
-    for key in state_dict.copy().keys():
-        if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
-            val = state_dict.pop(key)
-            state_dict[key.replace("transformer.decoder", "model.decoder")] = val
-        if "input_proj" in key:
-            val = state_dict.pop(key)
-            state_dict["model." + key] = val
-        if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
-            val = state_dict.pop(key)
-            state_dict[key.replace("transformer", "model")] = val
-
-    # finally, create HuggingFace model and load state dict
-    model = DetaForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    model.to(device)
-
-    # load image processor
-    processor = DetaImageProcessor(format="coco_detection")
-
-    # verify our conversion on image
-    img = prepare_img()
-    encoding = processor(images=img, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-    outputs = model(pixel_values.to(device))
-
-    # verify logits
-    print("Logits:", outputs.logits[0, :3, :3])
-    print("Boxes:", outputs.pred_boxes[0, :3, :3])
-    if model_name == "deta-swin-large":
-        expected_logits = torch.tensor(
-            [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]]
-        )
-        expected_boxes = torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]])
-    elif model_name == "deta-swin-large-o365":
-        expected_logits = torch.tensor(
-            [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]]
-        )
-        expected_boxes = torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]])
-    assert torch.allclose(outputs.logits[0, :3, :3], expected_logits.to(device), atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes[0, :3, :3], expected_boxes.to(device), atol=1e-4)
-    print("Everything ok!")
-
-    if pytorch_dump_folder_path:
-        # Save model and processor
-        logger.info(f"Saving PyTorch model and processor to {pytorch_dump_folder_path}...")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    # Push to hub
-    if push_to_hub:
-        print("Pushing model and processor to hub...")
-        model.push_to_hub(f"jozhang97/{model_name}")
-        processor.push_to_hub(f"jozhang97/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--model_name",
-        type=str,
-        default="deta-swin-large",
-        choices=["deta-swin-large", "deta-swin-large-o365"],
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the folder to output PyTorch model.",
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-    convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/deprecated/efficientformer/convert_efficientformer_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/deprecated/efficientformer/convert_efficientformer_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 7431cd6136a5..000000000000
--- a/src/transformers/models/deprecated/efficientformer/convert_efficientformer_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,252 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert EfficientFormer checkpoints from the original repository.
-
-URL: https://github.com/snap-research/EfficientFormer
-"""
-
-import argparse
-import re
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-from torchvision.transforms import CenterCrop, Compose, Normalize, Resize, ToTensor
-
-from transformers import (
-    EfficientFormerConfig,
-    EfficientFormerForImageClassificationWithTeacher,
-    EfficientFormerImageProcessor,
-)
-from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling
-
-
-def rename_key(old_name, num_meta4D_last_stage):
-    new_name = old_name
-
-    if "patch_embed" in old_name:
-        _, layer, param = old_name.split(".")
-
-        if layer == "0":
-            new_name = old_name.replace("0", "convolution1")
-        elif layer == "1":
-            new_name = old_name.replace("1", "batchnorm_before")
-        elif layer == "3":
-            new_name = old_name.replace("3", "convolution2")
-        else:
-            new_name = old_name.replace("4", "batchnorm_after")
-
-    if "network" in old_name and re.search(r"\d\.\d", old_name):
-        two_digit_num = r"\b\d{2}\b"
-        if bool(re.search(two_digit_num, old_name)):
-            match = re.search(r"\d\.\d\d.", old_name).group()
-        else:
-            match = re.search(r"\d\.\d.", old_name).group()
-        if int(match[0]) < 6:
-            trimmed_name = old_name.replace(match, "")
-            trimmed_name = trimmed_name.replace("network", match[0] + ".meta4D_layers.blocks." + match[2:-1])
-            new_name = "intermediate_stages." + trimmed_name
-        else:
-            trimmed_name = old_name.replace(match, "")
-            if int(match[2]) < num_meta4D_last_stage:
-                trimmed_name = trimmed_name.replace("network", "meta4D_layers.blocks." + match[2])
-            else:
-                layer_index = str(int(match[2]) - num_meta4D_last_stage)
-                trimmed_name = trimmed_name.replace("network", "meta3D_layers.blocks." + layer_index)
-                if "norm1" in old_name:
-                    trimmed_name = trimmed_name.replace("norm1", "layernorm1")
-                elif "norm2" in old_name:
-                    trimmed_name = trimmed_name.replace("norm2", "layernorm2")
-                elif "fc1" in old_name:
-                    trimmed_name = trimmed_name.replace("fc1", "linear_in")
-                elif "fc2" in old_name:
-                    trimmed_name = trimmed_name.replace("fc2", "linear_out")
-
-            new_name = "last_stage." + trimmed_name
-
-    elif "network" in old_name and re.search(r".\d.", old_name):
-        new_name = old_name.replace("network", "intermediate_stages")
-
-    if "fc" in new_name:
-        new_name = new_name.replace("fc", "convolution")
-    elif ("norm1" in new_name) and ("layernorm1" not in new_name):
-        new_name = new_name.replace("norm1", "batchnorm_before")
-    elif ("norm2" in new_name) and ("layernorm2" not in new_name):
-        new_name = new_name.replace("norm2", "batchnorm_after")
-    if "proj" in new_name:
-        new_name = new_name.replace("proj", "projection")
-    if "dist_head" in new_name:
-        new_name = new_name.replace("dist_head", "distillation_classifier")
-    elif "head" in new_name:
-        new_name = new_name.replace("head", "classifier")
-    elif "patch_embed" in new_name:
-        new_name = "efficientformer." + new_name
-    elif new_name == "norm.weight" or new_name == "norm.bias":
-        new_name = new_name.replace("norm", "layernorm")
-        new_name = "efficientformer." + new_name
-    else:
-        new_name = "efficientformer.encoder." + new_name
-
-    return new_name
-
-
-def convert_torch_checkpoint(checkpoint, num_meta4D_last_stage):
-    for key in checkpoint.copy().keys():
-        val = checkpoint.pop(key)
-        checkpoint[rename_key(key, num_meta4D_last_stage)] = val
-
-    return checkpoint
-
-
-# We will verify our results on a COCO image
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-
-    return image
-
-
-def convert_efficientformer_checkpoint(
-    checkpoint_path: Path, efficientformer_config_file: Path, pytorch_dump_path: Path, push_to_hub: bool
-):
-    orig_state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-    config = EfficientFormerConfig.from_json_file(efficientformer_config_file)
-    model = EfficientFormerForImageClassificationWithTeacher(config)
-    model_name = "_".join(checkpoint_path.split("/")[-1].split(".")[0].split("_")[:-1])
-
-    num_meta4D_last_stage = config.depths[-1] - config.num_meta3d_blocks + 1
-    new_state_dict = convert_torch_checkpoint(orig_state_dict, num_meta4D_last_stage)
-
-    model.load_state_dict(new_state_dict)
-    model.eval()
-
-    pillow_resamplings = {
-        "bilinear": PILImageResampling.BILINEAR,
-        "bicubic": PILImageResampling.BICUBIC,
-        "nearest": PILImageResampling.NEAREST,
-    }
-
-    # prepare image
-    image = prepare_img()
-    image_size = 256
-    crop_size = 224
-    processor = EfficientFormerImageProcessor(
-        size={"shortest_edge": image_size},
-        crop_size={"height": crop_size, "width": crop_size},
-        resample=pillow_resamplings["bicubic"],
-    )
-    pixel_values = processor(images=image, return_tensors="pt").pixel_values
-
-    # original processing pipeline
-    image_transforms = Compose(
-        [
-            Resize(image_size, interpolation=pillow_resamplings["bicubic"]),
-            CenterCrop(crop_size),
-            ToTensor(),
-            Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD),
-        ]
-    )
-    original_pixel_values = image_transforms(image).unsqueeze(0)
-
-    assert torch.allclose(original_pixel_values, pixel_values)
-
-    outputs = model(pixel_values)
-    logits = outputs.logits
-
-    expected_shape = (1, 1000)
-
-    if "l1" in model_name:
-        expected_logits = torch.Tensor(
-            [-0.1312, 0.4353, -1.0499, -0.5124, 0.4183, -0.6793, -1.3777, -0.0893, -0.7358, -2.4328]
-        )
-        assert torch.allclose(logits[0, :10], expected_logits, atol=1e-3)
-        assert logits.shape == expected_shape
-    elif "l3" in model_name:
-        expected_logits = torch.Tensor(
-            [-1.3150, -1.5456, -1.2556, -0.8496, -0.7127, -0.7897, -0.9728, -0.3052, 0.3751, -0.3127]
-        )
-        assert torch.allclose(logits[0, :10], expected_logits, atol=1e-3)
-        assert logits.shape == expected_shape
-    elif "l7" in model_name:
-        expected_logits = torch.Tensor(
-            [-1.0283, -1.4131, -0.5644, -1.3115, -0.5785, -1.2049, -0.7528, 0.1992, -0.3822, -0.0878]
-        )
-        assert logits.shape == expected_shape
-    else:
-        raise ValueError(
-            f"Unknown model checkpoint: {checkpoint_path}. Supported version of efficientformer are l1, l3 and l7"
-        )
-
-    # Save Checkpoints
-    Path(pytorch_dump_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_path)
-    print(f"Checkpoint successfuly converted. Model saved at {pytorch_dump_path}")
-    processor.save_pretrained(pytorch_dump_path)
-    print(f"Processor successfuly saved at {pytorch_dump_path}")
-
-    if push_to_hub:
-        print("Pushing model to the hub...")
-
-        model.push_to_hub(
-            repo_id=f"Bearnardd/{pytorch_dump_path}",
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
-        processor.push_to_hub(
-            repo_id=f"Bearnardd/{pytorch_dump_path}",
-            commit_message="Add image processor",
-            use_temp_dir=True,
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--pytorch_model_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to EfficientFormer pytorch checkpoint.",
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The json file for EfficientFormer model config.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-
-    parser.add_argument("--push_to_hub", action="store_true", help="Push model and image processor to the hub")
-    parser.add_argument(
-        "--no-push_to_hub",
-        dest="push_to_hub",
-        action="store_false",
-        help="Do not push model and image processor to the hub",
-    )
-    parser.set_defaults(push_to_hub=True)
-
-    args = parser.parse_args()
-    convert_efficientformer_checkpoint(
-        checkpoint_path=args.pytorch_model_path,
-        efficientformer_config_file=args.config_file,
-        pytorch_dump_path=args.pytorch_dump_path,
-        push_to_hub=args.push_to_hub,
-    )
diff --git a/src/transformers/models/deprecated/gptsan_japanese/convert_gptsan_tf_checkpoint_to_pytorch.py b/src/transformers/models/deprecated/gptsan_japanese/convert_gptsan_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index a84d000d4439..000000000000
--- a/src/transformers/models/deprecated/gptsan_japanese/convert_gptsan_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,181 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert GPTSANJapanese checkpoints from the original repository to pytorch model."""
-
-import argparse
-import json
-import os
-from collections import OrderedDict
-
-import numpy as np
-import tensorflow as tf
-import torch
-
-
-def convert_tf_gptsan_to_pt(args):
-    parameter_file = os.path.join(args.tf_model_dir, "parameters.json")
-    params = json.loads(open(parameter_file).read())
-    if not params:
-        raise ValueError(
-            f"It seems that the json file at {parameter_file} is empty. Make sure you have a correct json file."
-        )
-    if not args.output.endswith(".pt"):
-        args.output = args.output + ".pt"
-    new_state = OrderedDict()
-    with tf.device("/CPU:0"):
-        reader = tf.train.load_checkpoint(args.tf_model_dir)
-        shapes = reader.get_variable_to_shape_map()
-        for key_name in shapes.keys():
-            vnp = reader.get_tensor(key_name).astype(np.float16)
-            if key_name.endswith("/adam_m") or key_name.endswith("/adam_v"):
-                continue
-            if key_name.startswith("pasts/"):
-                if key_name.startswith("pasts/mlp"):
-                    player = int(key_name[9])
-                elif key_name.startswith("pasts/out"):
-                    player = 8
-                name = "model.sqout.%d.weight" % (player * 2)  # enter to nn.Sequencial with Tanh, so 2 at a time
-                state = vnp.transpose([1, 0]).copy()  # Mesh-Tensorflow is a diagonal matrix
-                new_state[name] = torch.tensor(state)
-            elif key_name.startswith("model/moe"):
-                player = int(key_name[9:].split("/")[0])
-                if key_name.endswith("/switch_gating/kernel"):
-                    name = "model.blocks.%d.feed_forward.mlp.router.classifier.weight" % player
-                    state = vnp.transpose([1, 0]).copy()  # Mesh-Tensorflow is a diagonal matrix
-                    new_state[name] = torch.tensor(state)
-                elif key_name.endswith("/softmlp/kernel"):
-                    name = "model.blocks.%d.feed_forward.soft_bypass_mlp.weight" % player
-                    state = vnp.transpose([1, 0]).copy()  # Mesh-Tensorflow is a diagonal matrix
-                    new_state[name] = torch.tensor(state)
-                elif key_name.endswith("/wo/kernel") or key_name.endswith("/wi/kernel"):
-                    nlayer = key_name[-9:-7]
-                    for i in range(16):
-                        name = "model.blocks.%d.feed_forward.mlp.experts.expert_%d.%s.weight" % (player, i, nlayer)
-                        state = (
-                            vnp[i].transpose([1, 0]).copy()
-                        )  # In Mesh-Tensorflow, it is one array, so it is divided
-                        new_state[name] = torch.tensor(state)
-            elif key_name.startswith("model/mlp"):
-                player = int(key_name[9:].split("/")[0])
-                if key_name.endswith("/p1/kernel"):
-                    name = "model.blocks.%d.feed_forward.mlp.wi.weight" % player
-                    state = vnp.transpose([1, 0]).copy()  # Mesh-Tensorflow is a diagonal matrix
-                    new_state[name] = torch.tensor(state)
-                elif key_name.endswith("/p1/bias"):
-                    name = "model.blocks.%d.feed_forward.mlp.wi.bias" % player
-                    state = vnp.copy()  # same because it is one dimensional
-                    new_state[name] = torch.tensor(state)
-                elif key_name.endswith("/p2/kernel"):
-                    name = "model.blocks.%d.feed_forward.mlp.wo.weight" % player
-                    state = vnp.transpose([1, 0]).copy()  # Mesh-Tensorflow is a diagonal matrix
-                    new_state[name] = torch.tensor(state)
-                elif key_name.endswith("/p2/bias"):
-                    name = "model.blocks.%d.feed_forward.mlp.wo.bias" % player
-                    state = vnp.copy()  # same because it is one dimensional
-                    new_state[name] = torch.tensor(state)
-            elif key_name.startswith("model/ln"):
-                player = int(key_name[8:].split("/")[0])
-                if key_name.endswith("/b"):
-                    name = "model.blocks.%d.feed_forward.norm.bias" % player
-                    state = vnp.copy()  # same because it is one dimensional
-                    new_state[name] = torch.tensor(state)
-                elif key_name.endswith("/g"):
-                    name = "model.blocks.%d.feed_forward.norm.weight" % player
-                    state = vnp.copy()  # same because it is one dimensional
-                    new_state[name] = torch.tensor(state)
-            elif key_name.startswith("model/att"):
-                player = int(key_name[9:].split("/")[0])
-                if key_name.endswith("/qkv/kernel"):
-                    state = vnp.copy()  # Compute same dimension as Mesh-tensorflow using einsum
-                    state_q = state[:, 0, :, :]
-                    state_k = state[:, 1, :, :]
-                    state_v = state[:, 2, :, :]
-                    state_q = (
-                        state_q.reshape([state_q.shape[0], state_q.shape[1] * state_q.shape[2]])
-                        .transpose([1, 0])
-                        .copy()
-                    )  # Mesh-Tensorflow is a diagonal matrix
-                    state_k = (
-                        state_k.reshape([state_k.shape[0], state_k.shape[1] * state_k.shape[2]])
-                        .transpose([1, 0])
-                        .copy()
-                    )  # Mesh-Tensorflow is a diagonal matrix
-                    state_v = (
-                        state_v.reshape([state_v.shape[0], state_v.shape[1] * state_v.shape[2]])
-                        .transpose([1, 0])
-                        .copy()
-                    )  # Mesh-Tensorflow is a diagonal matrix
-                    name = "model.blocks.%d.self_attn.self_attn.q_proj.weight" % player
-                    new_state[name] = torch.tensor(state_q)
-                    name = "model.blocks.%d.self_attn.self_attn.k_proj.weight" % player
-                    new_state[name] = torch.tensor(state_k)
-                    name = "model.blocks.%d.self_attn.self_attn.v_proj.weight" % player
-                    new_state[name] = torch.tensor(state_v)
-                elif key_name.endswith("/o/kernel"):
-                    name = "model.blocks.%d.self_attn.self_attn.out_proj.weight" % player
-                    state = (
-                        vnp.reshape([vnp.shape[0] * vnp.shape[1], vnp.shape[2]]).transpose([1, 0]).copy()
-                    )  # Mesh-Tensorflow is a diagonal matrix
-                    new_state[name] = torch.tensor(state)
-            elif key_name.startswith("model/an"):
-                player = int(key_name[8:].split("/")[0])
-                if key_name.endswith("/b"):
-                    name = "model.blocks.%d.self_attn.norm.bias" % player
-                    state = vnp.copy()  # same because it is one dimensional
-                    new_state[name] = torch.tensor(state)
-                elif key_name.endswith("/g"):
-                    name = "model.blocks.%d.self_attn.norm.weight" % player
-                    state = vnp.copy()  # same because it is one dimensional
-                    new_state[name] = torch.tensor(state)
-            elif (
-                key_name.startswith("model/wte")
-                or key_name.startswith("model/wpe")
-                or key_name.startswith("model/ete")
-            ):
-                nlayer = {"wte": "embed_tokens", "wpe": "position_embeddings", "ete": "extra_position_embeddings"}[
-                    key_name[-3:]
-                ]
-                name = "model.%s.weight" % nlayer
-                state = vnp.copy()  # same in embedded
-                new_state[name] = torch.tensor(state)
-                if key_name.startswith("model/wte"):
-                    name = "lm_head.weight"
-                    state = vnp.copy()  # same in embedded
-                    new_state[name] = torch.tensor(state)
-            elif key_name.startswith("model/wob"):
-                name = "final_logits_bias"
-                state = vnp.copy()  # same in embedded
-                state = state.reshape((1, -1))
-                new_state[name] = torch.tensor(state)
-            elif key_name == "model/dense/kernel":
-                name = "model.last_project.weight"
-                state = vnp.transpose([1, 0]).copy()  # Mesh-Tensorflow is a diagonal matrix
-                new_state[name] = torch.tensor(state)
-            elif key_name == "model/dense_1/bias":
-                name = "model.last_project.bias"
-                state = vnp.copy()  # same because it is one dimensional
-                new_state[name] = torch.tensor(state)
-    torch.save(new_state, args.output)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="model converter.", formatter_class=argparse.ArgumentDefaultsHelpFormatter
-    )
-    parser.add_argument("--tf_model_dir", metavar="PATH", type=str, required=True, help="import model")
-    parser.add_argument("--output", metavar="PATH", type=str, required=True, help="output model")
-    args = parser.parse_args()
-    convert_tf_gptsan_to_pt(args)
diff --git a/src/transformers/models/deprecated/jukebox/convert_jukebox.py b/src/transformers/models/deprecated/jukebox/convert_jukebox.py
deleted file mode 100644
index 960c8f6ff574..000000000000
--- a/src/transformers/models/deprecated/jukebox/convert_jukebox.py
+++ /dev/null
@@ -1,279 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Jukebox checkpoints"""
-
-import argparse
-import json
-import os
-from pathlib import Path
-
-import requests
-import torch
-
-from transformers import JukeboxConfig, JukeboxModel
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-PREFIX = "https://openaipublic.azureedge.net/jukebox/models/"
-MODEL_MAPPING = {
-    "jukebox-1b-lyrics": [
-        "5b/vqvae.pth.tar",
-        "5b/prior_level_0.pth.tar",
-        "5b/prior_level_1.pth.tar",
-        "1b_lyrics/prior_level_2.pth.tar",
-    ],
-    "jukebox-5b-lyrics": [
-        "5b/vqvae.pth.tar",
-        "5b/prior_level_0.pth.tar",
-        "5b/prior_level_1.pth.tar",
-        "5b_lyrics/prior_level_2.pth.tar",
-    ],
-}
-
-
-def replace_key(key):
-    if key.endswith(".model.1.bias") and len(key.split(".")) > 10:
-        key = key.replace(".model.1.bias", ".conv1d_1.bias")
-    elif key.endswith(".model.1.weight") and len(key.split(".")) > 10:
-        key = key.replace(".model.1.weight", ".conv1d_1.weight")
-    elif key.endswith(".model.3.bias") and len(key.split(".")) > 10:
-        key = key.replace(".model.3.bias", ".conv1d_2.bias")
-    elif key.endswith(".model.3.weight") and len(key.split(".")) > 10:
-        key = key.replace(".model.3.weight", ".conv1d_2.weight")
-
-    if "conditioner_blocks.0." in key:
-        key = key.replace("conditioner_blocks.0", "conditioner_blocks")
-
-    if "prime_prior" in key:
-        key = key.replace("prime_prior", "encoder")
-
-    if ".emb." in key and "total" not in key and "absolute" not in key and "relative" not in key:
-        key = key.replace(".emb.", ".")
-
-    if key.endswith("k"):  # replace vqvae.X.k with vqvae.X.codebook
-        return key.replace(".k", ".codebook")
-    if "y_emb." in key:
-        return key.replace("y_emb.", "metadata_embedding.")
-
-    if "x_emb.emb." in key:
-        key = key.replace("0.x_emb.emb", "embed_tokens")
-
-    if "prime_state_ln" in key:
-        return key.replace("prime_state_ln", "encoder.final_layer_norm")
-    if ".ln" in key:
-        return key.replace(".ln", ".layer_norm")
-    if "_ln" in key:
-        return key.replace("_ln", "_layer_norm")
-
-    if "prime_state_proj" in key:
-        return key.replace("prime_state_proj", "encoder.proj_in")
-    if "prime_x_out" in key:
-        return key.replace("prime_x_out", "encoder.lm_head")
-    if "prior.x_out" in key:
-        return key.replace("x_out", "fc_proj_out")
-    if "x_emb" in key:
-        return key.replace("x_emb", "embed_tokens")
-
-    return key
-
-
-def fix_jukebox_keys(state_dict, model_state_dict, key_prefix, mapping):
-    new_dict = {}
-    import re
-
-    re_encoder_block_conv_in = re.compile(r"encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)")
-    re_encoder_block_resnet = re.compile(
-        r"encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)"
-    )
-    re_encoder_block_proj_out = re.compile(r"encoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)")
-
-    re_decoder_block_conv_out = re.compile(r"decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)")
-    re_decoder_block_resnet = re.compile(
-        r"decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)"
-    )
-    re_decoder_block_proj_in = re.compile(r"decoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)")
-
-    re_prior_cond_conv_out = re.compile(r"conditioner_blocks.(\d*).cond.model.(\d*).(\d).(bias|weight)")
-    re_prior_cond_resnet = re.compile(
-        r"conditioner_blocks.(\d*).cond.model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)"
-    )
-    re_prior_cond_proj_in = re.compile(r"conditioner_blocks.(\d*).cond.model.(\d*).(bias|weight)")
-
-    for original_key, value in state_dict.items():
-        # rename vqvae.encoder keys
-        if re_encoder_block_conv_in.fullmatch(original_key):
-            regex_match = re_encoder_block_conv_in.match(original_key)
-            groups = regex_match.groups()
-            block_index = int(groups[2]) * 2 + int(groups[3])
-            re_new_key = f"encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}.{groups[-1]}"
-            key = re_encoder_block_conv_in.sub(re_new_key, original_key)
-
-        elif re_encoder_block_resnet.fullmatch(original_key):
-            regex_match = re_encoder_block_resnet.match(original_key)
-            groups = regex_match.groups()
-            block_index = int(groups[2]) * 2 + int(groups[3])
-            conv_index = {"1": 1, "3": 2}[groups[-2]]
-            prefix = f"encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}."
-            resnet_block = f"resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"
-            re_new_key = prefix + resnet_block
-            key = re_encoder_block_resnet.sub(re_new_key, original_key)
-
-        elif re_encoder_block_proj_out.fullmatch(original_key):
-            regex_match = re_encoder_block_proj_out.match(original_key)
-            groups = regex_match.groups()
-            re_new_key = f"encoders.{groups[0]}.level_blocks.{groups[1]}.proj_out.{groups[-1]}"
-            key = re_encoder_block_proj_out.sub(re_new_key, original_key)
-
-        # rename vqvae.decoder keys
-        elif re_decoder_block_conv_out.fullmatch(original_key):
-            regex_match = re_decoder_block_conv_out.match(original_key)
-            groups = regex_match.groups()
-            block_index = int(groups[2]) * 2 + int(groups[3]) - 2
-            re_new_key = f"decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}.{groups[-1]}"
-            key = re_decoder_block_conv_out.sub(re_new_key, original_key)
-
-        elif re_decoder_block_resnet.fullmatch(original_key):
-            regex_match = re_decoder_block_resnet.match(original_key)
-            groups = regex_match.groups()
-            block_index = int(groups[2]) * 2 + int(groups[3]) - 2
-            conv_index = {"1": 1, "3": 2}[groups[-2]]
-            prefix = f"decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}."
-            resnet_block = f"resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"
-            re_new_key = prefix + resnet_block
-            key = re_decoder_block_resnet.sub(re_new_key, original_key)
-
-        elif re_decoder_block_proj_in.fullmatch(original_key):
-            regex_match = re_decoder_block_proj_in.match(original_key)
-            groups = regex_match.groups()
-            re_new_key = f"decoders.{groups[0]}.level_blocks.{groups[1]}.proj_in.{groups[-1]}"
-            key = re_decoder_block_proj_in.sub(re_new_key, original_key)
-
-        # rename prior cond.model to upsampler.upsample_block and resnet
-        elif re_prior_cond_conv_out.fullmatch(original_key):
-            regex_match = re_prior_cond_conv_out.match(original_key)
-            groups = regex_match.groups()
-            block_index = int(groups[1]) * 2 + int(groups[2]) - 2
-            re_new_key = f"conditioner_blocks.upsampler.upsample_block.{block_index}.{groups[-1]}"
-            key = re_prior_cond_conv_out.sub(re_new_key, original_key)
-
-        elif re_prior_cond_resnet.fullmatch(original_key):
-            regex_match = re_prior_cond_resnet.match(original_key)
-            groups = regex_match.groups()
-            block_index = int(groups[1]) * 2 + int(groups[2]) - 2
-            conv_index = {"1": 1, "3": 2}[groups[-2]]
-            prefix = f"conditioner_blocks.upsampler.upsample_block.{block_index}."
-            resnet_block = f"resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"
-            re_new_key = prefix + resnet_block
-            key = re_prior_cond_resnet.sub(re_new_key, original_key)
-
-        elif re_prior_cond_proj_in.fullmatch(original_key):
-            regex_match = re_prior_cond_proj_in.match(original_key)
-            groups = regex_match.groups()
-            re_new_key = f"conditioner_blocks.upsampler.proj_in.{groups[-1]}"
-            key = re_prior_cond_proj_in.sub(re_new_key, original_key)
-
-        # keep original key
-        else:
-            key = original_key
-
-        key = replace_key(key)
-
-        if f"{key_prefix}.{key}" not in model_state_dict or key is None:
-            print(f"failed converting {original_key} to {key}, does not match")
-
-        # handle missmatched shape
-        elif value.shape != model_state_dict[f"{key_prefix}.{key}"].shape:
-            val = model_state_dict[f"{key_prefix}.{key}"]
-            print(f"{original_key}-> {key} : \nshape {val.shape} and {value.shape}, do not match")
-            key = original_key
-
-        mapping[key] = original_key
-        new_dict[key] = value
-
-    return new_dict
-
-
-@torch.no_grad()
-def convert_openai_checkpoint(model_name=None, pytorch_dump_folder_path=None):
-    """
-    Copy/paste/tweak model's weights to our Jukebox structure.
-    """
-    for file in MODEL_MAPPING[model_name]:
-        if not os.path.isfile(f"{pytorch_dump_folder_path}/{file.split('/')[-1]}"):
-            r = requests.get(f"{PREFIX}{file}", allow_redirects=True)
-            os.makedirs(f"{pytorch_dump_folder_path}/", exist_ok=True)
-            open(f"{pytorch_dump_folder_path}/{file.split('/')[-1]}", "wb").write(r.content)
-
-    model_to_convert = MODEL_MAPPING[model_name.split("/")[-1]]
-
-    config = JukeboxConfig.from_pretrained(model_name)
-    model = JukeboxModel(config)
-
-    weight_dict = []
-    mapping = {}
-    for i, dict_name in enumerate(model_to_convert):
-        old_dic = torch.load(f"{pytorch_dump_folder_path}/{dict_name.split('/')[-1]}")["model"]
-
-        new_dic = {}
-        for k in old_dic.keys():
-            if k.endswith(".b"):
-                new_dic[k.replace("b", "bias")] = old_dic[k]
-            elif k.endswith(".w"):
-                new_dic[k.replace("w", "weight")] = old_dic[k]
-            elif "level_2" not in dict_name and "cond.model." in k:
-                new_dic[k.replace(".blocks.", ".model.")] = old_dic[k]
-            else:
-                new_dic[k] = old_dic[k]
-
-        key_prefix = "vqvae" if i == 0 else f"priors.{3 - i}"
-        new_dic = fix_jukebox_keys(new_dic, model.state_dict(), key_prefix, mapping)
-        weight_dict.append(new_dic)
-
-    vqvae_state_dict = weight_dict.pop(0)
-    model.vqvae.load_state_dict(vqvae_state_dict)
-    for i in range(len(weight_dict)):
-        model.priors[i].load_state_dict(weight_dict[2 - i])
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    with open(f"{pytorch_dump_folder_path}/mapping.json", "w") as txtfile:
-        json.dump(mapping, txtfile)
-
-    print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    return weight_dict
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="jukebox-5b-lyrics",
-        type=str,
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="jukebox-5b-lyrics-converted",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    args = parser.parse_args()
-    convert_openai_checkpoint(args.model_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/deprecated/mega/convert_mega_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/deprecated/mega/convert_mega_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 1f791dab2404..000000000000
--- a/src/transformers/models/deprecated/mega/convert_mega_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,292 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Convert Mega pretrained checkpoint. Built to convert the Masked LM checkpoint located at
-https://huggingface.co/mnaylor/mega-wikitext-103
-
-Requirements:
-  - clone the Mega repo and install fairseq from there
-    1. git clone https://github.com/facebookresearch/mega.git
-    2. cd mega && pip install -e
-  - clone the pretrained weights for the original implementation from the hugging face repo
-    * use this location as the path for pretrained weights
-"""
-
-import argparse
-
-# utilities to import the model weights and config file
-import os
-import pickle as pkl
-
-# PyTorch + new model classes
-import torch
-from torch import nn
-
-from transformers import AutoTokenizer, MegaConfig, MegaForMaskedLM
-
-
-# import the EncoderLayer class used to pretrain
-# !! NOTE !! this requires the version of fairseq that is built when you install the Mega source
-try:
-    from fairseq.modules.mega_layer import MegaEncoderLayer
-except ImportError:
-    raise ImportError("You need to install the version of fairseq from the Mega repo!")
-
-
-# define the wrapper classes used to train the MLM  (see colab notebook below)
-# https://colab.research.google.com/drive/1qfUO6o5HRdxBblWlw058HVyvaEPhPpH8?usp=sharing
-# MegaLM outputs hidden states
-class MegaLM(nn.Module):
-    "The base class for our Mega encoder - given input IDs, embed text and return encoder output"
-
-    def __init__(self, mega_args, depth, vocab_size):
-        super().__init__()
-        self.mega_args = mega_args
-        self.embedding_layer = nn.Embedding(vocab_size, self.mega_args.encoder_embed_dim)
-        self.encoders = nn.ModuleList([MegaEncoderLayer(self.mega_args) for _ in range(depth)])
-        self.depth = depth
-
-    def forward(self, input_ids, attention_mask, batch_first=True, ignore_mask_value=0):
-        """
-        Code for a forward pass - expects input_ids and attention_mask to come from a Hugging Face tokenizer as PyTorch
-        tensors, and returns a tensor of size (batch, n_classes) containing classification logits
-
-        Other options:
-          - batch_first: boolean indicating whether the batch dimension is first in input_ids (default: True, which
-            aligns with the HF tokenizer behavior)
-          - ignore_mask_value: the value in attention_mask that identifies tokens that should be ignored (default: 0,
-            which aligns with HF tokenizer)
-        """
-
-        # Mega expects embeddings to be (time, batch, embedding size), but
-        # Hugging Face returns tokens as (batch, time)
-        if batch_first:
-            input_ids = input_ids.T
-
-        # to make things more confusing, Mega expects the attention mask to
-        # be (batch, time), but with values of 0 (normal token) and 1 (ignore token)
-        # which is the opposite of what HF returns
-        if ignore_mask_value == 0:
-            attention_mask = 1 - attention_mask
-
-        # get token embeddings from IDs
-        embeds = self.embedding_layer(input_ids)
-
-        # pass through the Mega layers
-        # input is (time, batch, encoder dim) and output is the same
-        for encoder in self.encoders:
-            embeds = encoder(embeds, attention_mask)
-
-        # return according to the shape specified
-        if batch_first:
-            # (T, B, H) --> (B, T, H)
-            return torch.transpose(embeds, 0, 1)
-        else:
-            return embeds
-
-
-# renamed from MegaForMaskedLM to avoid confusion with new module
-class OriginalMegaForMaskedLM(nn.Module):
-    "A wrapper class for doing masked language modeling with Mega"
-
-    def __init__(self, mega_args, depth, vocab_size):
-        super().__init__()
-        self.mega = MegaLM(mega_args, depth, vocab_size)
-        self.mlm_head = nn.Linear(mega_args.encoder_embed_dim, vocab_size)
-        self.dropout = nn.Dropout(p=0.1)
-
-    def forward(self, input_ids, attention_mask, batch_first=True, ignore_mask_value=0):
-        """
-        Perform a forward pass through the Mega encoder and the masked LM head. Returns logits for each vocabulary
-        entry.
-
-        If `batch_first` (default to align with Hugging Face tokenizer behavior), output will have the shape (Batch
-        size, Sequence length, Vocab size); otherwise (S, B, V)
-        """
-        encoder_output = self.mega(input_ids, attention_mask, batch_first, ignore_mask_value)
-        return self.mlm_head(self.dropout(encoder_output))
-
-
-# code to convert the checkpoint located in the user-specified location
-def convert_checkpoint_to_huggingface(pretrained_checkpoint_path, output_path, includes_tokenizer):
-    with open(os.path.join(pretrained_checkpoint_path, "model_args.pkl"), "rb") as f:
-        mega_original_args = pkl.load(f)
-
-    # load the original encoder
-    original_mlm = OriginalMegaForMaskedLM(**mega_original_args).eval()
-
-    # load its weights
-    print(
-        "Original Mega encoder:",
-        original_mlm.mega.load_state_dict(
-            torch.load(os.path.join(pretrained_checkpoint_path, "encoder_weights.pt"), map_location="cpu")
-        ),
-    )
-    print(
-        "Original Mega MLM layer:",
-        original_mlm.mlm_head.load_state_dict(
-            torch.load(os.path.join(pretrained_checkpoint_path, "mlm_head_weights.pt"), map_location="cpu")
-        ),
-    )
-
-    # create a new config from the old one
-    hf_config = MegaConfig(
-        num_hidden_layers=mega_original_args["depth"],
-        vocab_size=mega_original_args["vocab_size"],
-        hidden_size=mega_original_args["mega_args"].encoder_embed_dim,
-        shared_representation_size=mega_original_args["mega_args"].encoder_z_dim,
-        intermediate_size=mega_original_args["mega_args"].encoder_hidden_dim,
-        ema_projection_size=mega_original_args["mega_args"].encoder_n_dim,
-        dropout_prob=mega_original_args["mega_args"].dropout,
-        attention_probs_dropout_prob=mega_original_args["mega_args"].attention_dropout,
-        hidden_dropout_prob=mega_original_args["mega_args"].hidden_dropout,
-        activation=mega_original_args["mega_args"].activation_fn,
-        attention_activation=mega_original_args["mega_args"].attention_activation_fn,
-        bidirectional=mega_original_args["mega_args"].bidirectional,
-        use_chunking=mega_original_args["mega_args"].encoder_chunk_size > 0,
-        chunk_size=mega_original_args["mega_args"].encoder_chunk_size,
-        truncation=mega_original_args["mega_args"].truncation_length,
-        normalization_type=mega_original_args["mega_args"].normalization_type,
-        normalize_before_mega=True,
-        norm_affine=True,
-        use_feature_dropout=mega_original_args["mega_args"].feature_dropout,
-        relative_positional_bias=mega_original_args["mega_args"].rel_pos_bias,
-        max_positions=mega_original_args["mega_args"].max_source_positions,
-        nffn_hidden_size=mega_original_args["mega_args"].encoder_ffn_embed_dim,
-        normalize_before_ffn=mega_original_args["mega_args"].normalize_before,
-        # new arguments added for HF implementation
-        nffn_activation_dropout_prob=0.0,
-        add_token_type_embeddings=False,
-        add_lm_hidden_dense_layer=False,
-    )
-
-    hf_mlm = MegaForMaskedLM(hf_config).eval()
-
-    # the originl checkpoint just uses nn.Embedding for the word embeddings
-    # we use a wrapper module for embeddings to add support for positional embeddings
-    hf_mlm.mega.embedding_layer.word_embeddings.weight = original_mlm.mega.embedding_layer.weight
-
-    # modify the state dictionary of the original checkpoint to account for naming issues in the Hugging Face
-    # ecosystem -- any names containing "beta" or "gamma" aren't safe to use and are renamed upon _load_pretrained,
-    # also renaming previously confusing parameter names
-    original_state_dict = original_mlm.mega.encoders.state_dict()
-    updated_keys = {}
-    for module_name in original_state_dict.keys():
-        new_module_name = None
-        # have to handle gamma, beta, and alpha differently due to their use
-        # in multiple modules within the original repository;
-        # beta is used in EMA, MovingAverageGatedAttention, and RotaryRelativePositionalBias, and must be renamed due to flax/tf weights
-        # the EMA sublayer was renamed from "move" to "ema_gate" for readability, so that is also done here
-        if "beta" in module_name:
-            # EMA sub-layers were always called "move" in the original repo
-            if "move.beta" in module_name:
-                new_module_name = module_name.replace("move.beta", "ema_gate.ema_expansion_matrix")
-            elif "mega_layer.beta" in module_name:
-                new_module_name = module_name.replace("beta", "qk_bias")
-            else:
-                new_module_name = module_name.replace("beta", "b_param")
-        # beta is used in EMA and MovingAverageGatedAttention, and must be renamed due to flax/tf weights
-        elif "gamma" in module_name:
-            if "move.gamma" in module_name:
-                new_module_name = module_name.replace("move.gamma", "ema_gate.kernel_projection_matrix")
-            elif "mega_layer.gamma" in module_name:
-                new_module_name = module_name.replace("gamma", "qk_weight")
-            else:
-                new_module_name = module_name.replace("gamma", "g_param")
-        # alpha is used in EMA and positional bias; renaming to improve readability
-        elif "move.alpha" in module_name:
-            new_module_name = module_name.replace("move.alpha", "ema_gate.decay_factor")
-        # delta is only used in EMA; renaming to improve readability
-        elif "move.delta" in module_name:
-            new_module_name = module_name.replace("move.delta", "ema_gate.damping_factor")
-        # omega is only used in EMA; renaming to improve readability
-        elif "omega" in module_name:
-            new_module_name = module_name.replace("move.omega", "ema_gate.residual_weight")
-
-        if new_module_name:
-            updated_keys[module_name] = new_module_name
-
-    if len(updated_keys) != 0:
-        print(f"Renaming these keys: {updated_keys.keys()}")
-    else:
-        print("No need to rename state dict entries")
-    for old, new in updated_keys.items():
-        original_state_dict[new] = original_state_dict.pop(old)
-
-    # now attempt to load the state dictionary with updated names
-    # note that we now call it `mega.layers` instead of `mega.encoders` due to hugging face style
-    print("HF Mega encoder:", hf_mlm.mega.layers.load_state_dict(original_state_dict))
-
-    # load the MLM head weights directly
-    print(
-        "HF Mega MLM layer:",
-        hf_mlm.mlm_head.load_state_dict(
-            torch.load(os.path.join(pretrained_checkpoint_path, "mlm_head_weights.pt"), map_location="cpu")
-        ),
-    )
-
-    # test on a randomly generated input sequence
-    input_ids = torch.randint(0, hf_config.vocab_size, size=(4, 256))
-    input_mask = torch.ones_like(input_ids)
-    # mask a few tokens to make sure masking is applied appropriately :)
-    input_mask[:, -10:] = 0
-
-    # run forward passes
-    original_output = original_mlm(input_ids, input_mask, batch_first=True, ignore_mask_value=0)
-    hf_output = hf_mlm(input_ids, input_mask)[0]
-
-    # print shapes and diff
-    print(f"original output {original_output.shape}")
-    print(f"hf output {hf_output.shape}")
-    print(f"max diff: {(original_output - hf_output).max()}")  # 0.0
-    success = torch.allclose(original_output, hf_output, atol=1e-3)
-
-    if success:
-        print("Yay!")
-        hf_mlm.save_pretrained(output_path)
-    else:
-        raise RuntimeError(f"Something's broken :(\nOriginal:\n{original_output}\n\nHF\n{hf_output}\n{hf_mlm}")
-
-    if includes_tokenizer:
-        print("Transferring tokenizer")
-        tokenizer = AutoTokenizer.from_pretrained(pretrained_checkpoint_path)
-        tokenizer.save_pretrained(output_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--pretrained_checkpoint_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Point to the directory containing your model weights using the official Mega repo",
-    )
-
-    parser.add_argument(
-        "--output_path", default=None, type=str, required=True, help="Location to save the Hugging Face version"
-    )
-
-    parser.add_argument(
-        "--includes_tokenizer",
-        action="store_true",
-        help="Use this flag if there is a Hugging Face tokenizer in the original checkpoint repo",
-    )
-
-    args = parser.parse_args()
-
-    convert_checkpoint_to_huggingface(args.pretrained_checkpoint_path, args.output_path, args.includes_tokenizer)
diff --git a/src/transformers/models/deprecated/trajectory_transformer/convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/deprecated/trajectory_transformer/convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index da7f7806671d..000000000000
--- a/src/transformers/models/deprecated/trajectory_transformer/convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The Trajectory Transformers paper authors and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""TrajectoryTransformer pytorch checkpoint conversion"""
-
-import torch
-import trajectory.utils as utils
-
-from transformers import TrajectoryTransformerModel
-
-
-class Parser(utils.Parser):
-    dataset: str = "halfcheetah-medium-expert-v2"
-    config: str = "config.offline"
-
-
-def convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch(logbase, dataset, loadpath, epoch, device):
-    """Converting Sequential blocks to ModuleList"""
-
-    gpt, gpt_epoch = utils.load_model(logbase, dataset, loadpath, epoch=epoch, device=device)
-    trajectory_transformer = TrajectoryTransformerModel(gpt.config)
-
-    trajectory_transformer.tok_emb.load_state_dict(gpt.tok_emb.state_dict())
-    trajectory_transformer.pos_emb = gpt.pos_emb
-    trajectory_transformer.drop.load_state_dict(gpt.drop.state_dict())
-    trajectory_transformer.ln_f.load_state_dict(gpt.ln_f.state_dict())
-    trajectory_transformer.head.load_state_dict(gpt.head.state_dict())
-
-    for i, block in enumerate(gpt.blocks):
-        trajectory_transformer.blocks[i].ln1.load_state_dict(gpt.blocks[i].ln1.state_dict())
-        trajectory_transformer.blocks[i].ln2.load_state_dict(gpt.blocks[i].ln2.state_dict())
-        trajectory_transformer.blocks[i].attn.load_state_dict(gpt.blocks[i].attn.state_dict())
-
-        trajectory_transformer.blocks[i].l1.load_state_dict(gpt.blocks[i].mlp[0].state_dict())
-        trajectory_transformer.blocks[i].act.load_state_dict(gpt.blocks[i].mlp[1].state_dict())
-        trajectory_transformer.blocks[i].l2.load_state_dict(gpt.blocks[i].mlp[2].state_dict())
-        trajectory_transformer.blocks[i].drop.load_state_dict(gpt.blocks[i].mlp[3].state_dict())
-
-    torch.save(trajectory_transformer.state_dict(), "pytorch_model.bin")
-
-
-if __name__ == "__main__":
-    """
-    To run this script you will need to install the original repository to run the original model. You can find it
-    here: https://github.com/jannerm/trajectory-transformer From this repository code you can also download the
-    original pytorch checkpoints.
-
-    Run with the command:
-
-    ```sh
-    >>> python convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch.py --dataset <dataset_name>
-    ...     --gpt_loadpath <path_to_original_pytorch_checkpoint>
-    ```
-    """
-
-    args = Parser().parse_args("plan")
-    convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch(
-        args.logbase, args.dataset, args.gpt_loadpath, args.gpt_epoch, args.device
-    )
diff --git a/src/transformers/models/deprecated/transfo_xl/convert_transfo_xl_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/deprecated/transfo_xl/convert_transfo_xl_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index 2c7b687c4d98..000000000000
--- a/src/transformers/models/deprecated/transfo_xl/convert_transfo_xl_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,121 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Transformer XL checkpoint and datasets."""
-
-import argparse
-import os
-import pickle
-import sys
-
-import torch
-
-from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
-from transformers.models.deprecated.transfo_xl import tokenization_transfo_xl as data_utils
-from transformers.models.deprecated.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
-from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging
-
-
-logging.set_verbosity_info()
-
-# We do this to be able to load python 2 datasets pickles
-# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
-data_utils.Vocab = data_utils.TransfoXLTokenizer
-data_utils.Corpus = data_utils.TransfoXLCorpus
-sys.modules["data_utils"] = data_utils
-sys.modules["vocabulary"] = data_utils
-
-
-def convert_transfo_xl_checkpoint_to_pytorch(
-    tf_checkpoint_path, transfo_xl_config_file, pytorch_dump_folder_path, transfo_xl_dataset_file
-):
-    if transfo_xl_dataset_file:
-        # Convert a pre-processed corpus (see original TensorFlow repo)
-        with open(transfo_xl_dataset_file, "rb") as fp:
-            corpus = pickle.load(fp, encoding="latin1")
-        # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
-        pytorch_vocab_dump_path = pytorch_dump_folder_path + "/" + VOCAB_FILES_NAMES["pretrained_vocab_file"]
-        print(f"Save vocabulary to {pytorch_vocab_dump_path}")
-        corpus_vocab_dict = corpus.vocab.__dict__
-        torch.save(corpus_vocab_dict, pytorch_vocab_dump_path)
-
-        corpus_dict_no_vocab = corpus.__dict__
-        corpus_dict_no_vocab.pop("vocab", None)
-        pytorch_dataset_dump_path = pytorch_dump_folder_path + "/" + CORPUS_NAME
-        print(f"Save dataset to {pytorch_dataset_dump_path}")
-        torch.save(corpus_dict_no_vocab, pytorch_dataset_dump_path)
-
-    if tf_checkpoint_path:
-        # Convert a pre-trained TensorFlow model
-        config_path = os.path.abspath(transfo_xl_config_file)
-        tf_path = os.path.abspath(tf_checkpoint_path)
-
-        print(f"Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.")
-        # Initialise PyTorch model
-        if transfo_xl_config_file == "":
-            config = TransfoXLConfig()
-        else:
-            config = TransfoXLConfig.from_json_file(transfo_xl_config_file)
-        print(f"Building PyTorch model from configuration: {config}")
-        model = TransfoXLLMHeadModel(config)
-
-        model = load_tf_weights_in_transfo_xl(model, config, tf_path)
-        # Save pytorch-model
-        pytorch_weights_dump_path = os.path.join(pytorch_dump_folder_path, WEIGHTS_NAME)
-        pytorch_config_dump_path = os.path.join(pytorch_dump_folder_path, CONFIG_NAME)
-        print(f"Save PyTorch model to {os.path.abspath(pytorch_weights_dump_path)}")
-        torch.save(model.state_dict(), pytorch_weights_dump_path)
-        print(f"Save configuration file to {os.path.abspath(pytorch_config_dump_path)}")
-        with open(pytorch_config_dump_path, "w", encoding="utf-8") as f:
-            f.write(config.to_json_string())
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the folder to store the PyTorch model or dataset/vocab.",
-    )
-    parser.add_argument(
-        "--tf_checkpoint_path",
-        default="",
-        type=str,
-        help="An optional path to a TensorFlow checkpoint path to be converted.",
-    )
-    parser.add_argument(
-        "--transfo_xl_config_file",
-        default="",
-        type=str,
-        help=(
-            "An optional config json file corresponding to the pre-trained BERT model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--transfo_xl_dataset_file",
-        default="",
-        type=str,
-        help="An optional dataset file to be converted in a vocabulary.\n"
-        "Given the files are in the pickle format, please be wary of passing it files you trust.",
-    )
-    args = parser.parse_args()
-    convert_transfo_xl_checkpoint_to_pytorch(
-        args.tf_checkpoint_path,
-        args.transfo_xl_config_file,
-        args.pytorch_dump_folder_path,
-        args.transfo_xl_dataset_file,
-    )
diff --git a/src/transformers/models/deprecated/van/convert_van_to_pytorch.py b/src/transformers/models/deprecated/van/convert_van_to_pytorch.py
deleted file mode 100644
index 466b14f6badf..000000000000
--- a/src/transformers/models/deprecated/van/convert_van_to_pytorch.py
+++ /dev/null
@@ -1,290 +0,0 @@
-# coding=utf-8
-# Copyright 2022 BNRist (Tsinghua University), TKLNDST (Nankai University) and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert VAN checkpoints from the original repository.
-
-URL: https://github.com/Visual-Attention-Network/VAN-Classification"""
-
-import argparse
-import json
-import sys
-from dataclasses import dataclass, field
-from functools import partial
-from pathlib import Path
-from typing import List, Optional
-
-import torch
-import torch.nn as nn
-from huggingface_hub import cached_download, hf_hub_download
-from torch import Tensor
-
-from transformers import AutoImageProcessor, VanConfig, VanForImageClassification
-from transformers.models.deprecated.van.modeling_van import VanLayerScaling
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-@dataclass
-class Tracker:
-    module: nn.Module
-    traced: List[nn.Module] = field(default_factory=list)
-    handles: list = field(default_factory=list)
-
-    def _forward_hook(self, m, inputs: Tensor, outputs: Tensor):
-        has_not_submodules = len(list(m.modules())) == 1 or isinstance(m, nn.Conv2d) or isinstance(m, nn.BatchNorm2d)
-        if has_not_submodules:
-            if not isinstance(m, VanLayerScaling):
-                self.traced.append(m)
-
-    def __call__(self, x: Tensor):
-        for m in self.module.modules():
-            self.handles.append(m.register_forward_hook(self._forward_hook))
-        self.module(x)
-        [x.remove() for x in self.handles]
-        return self
-
-    @property
-    def parametrized(self):
-        # check the len of the state_dict keys to see if we have learnable params
-        return list(filter(lambda x: len(list(x.state_dict().keys())) > 0, self.traced))
-
-
-@dataclass
-class ModuleTransfer:
-    src: nn.Module
-    dest: nn.Module
-    verbose: int = 0
-    src_skip: List = field(default_factory=list)
-    dest_skip: List = field(default_factory=list)
-
-    def __call__(self, x: Tensor):
-        """
-        Transfer the weights of `self.src` to `self.dest` by performing a forward pass using `x` as input. Under the
-        hood we tracked all the operations in both modules.
-        """
-        dest_traced = Tracker(self.dest)(x).parametrized
-        src_traced = Tracker(self.src)(x).parametrized
-
-        src_traced = list(filter(lambda x: type(x) not in self.src_skip, src_traced))
-        dest_traced = list(filter(lambda x: type(x) not in self.dest_skip, dest_traced))
-
-        if len(dest_traced) != len(src_traced):
-            raise Exception(
-                f"Numbers of operations are different. Source module has {len(src_traced)} operations while"
-                f" destination module has {len(dest_traced)}."
-            )
-
-        for dest_m, src_m in zip(dest_traced, src_traced):
-            dest_m.load_state_dict(src_m.state_dict())
-            if self.verbose == 1:
-                print(f"Transfered from={src_m} to={dest_m}")
-
-
-def copy_parameters(from_model: nn.Module, our_model: nn.Module) -> nn.Module:
-    # nn.Parameter cannot be tracked by the Tracker, thus we need to manually convert them
-    from_state_dict = from_model.state_dict()
-    our_state_dict = our_model.state_dict()
-    config = our_model.config
-    all_keys = []
-    for stage_idx in range(len(config.hidden_sizes)):
-        for block_id in range(config.depths[stage_idx]):
-            from_key = f"block{stage_idx + 1}.{block_id}.layer_scale_1"
-            to_key = f"van.encoder.stages.{stage_idx}.layers.{block_id}.attention_scaling.weight"
-
-            all_keys.append((from_key, to_key))
-            from_key = f"block{stage_idx + 1}.{block_id}.layer_scale_2"
-            to_key = f"van.encoder.stages.{stage_idx}.layers.{block_id}.mlp_scaling.weight"
-
-            all_keys.append((from_key, to_key))
-
-    for from_key, to_key in all_keys:
-        our_state_dict[to_key] = from_state_dict.pop(from_key)
-
-    our_model.load_state_dict(our_state_dict)
-    return our_model
-
-
-def convert_weight_and_push(
-    name: str,
-    config: VanConfig,
-    checkpoint: str,
-    from_model: nn.Module,
-    save_directory: Path,
-    push_to_hub: bool = True,
-):
-    print(f"Downloading weights for {name}...")
-    checkpoint_path = cached_download(checkpoint)
-    print(f"Converting {name}...")
-    from_state_dict = torch.load(checkpoint_path)["state_dict"]
-    from_model.load_state_dict(from_state_dict)
-    from_model.eval()
-    with torch.no_grad():
-        our_model = VanForImageClassification(config).eval()
-        module_transfer = ModuleTransfer(src=from_model, dest=our_model)
-        x = torch.randn((1, 3, 224, 224))
-        module_transfer(x)
-        our_model = copy_parameters(from_model, our_model)
-
-    if not torch.allclose(from_model(x), our_model(x).logits):
-        raise ValueError("The model logits don't match the original one.")
-
-    checkpoint_name = name
-    print(checkpoint_name)
-
-    if push_to_hub:
-        our_model.push_to_hub(
-            repo_path_or_name=save_directory / checkpoint_name,
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
-
-        # we can use the convnext one
-        image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k")
-        image_processor.push_to_hub(
-            repo_path_or_name=save_directory / checkpoint_name,
-            commit_message="Add image processor",
-            use_temp_dir=True,
-        )
-
-        print(f"Pushed {checkpoint_name}")
-
-
-def convert_weights_and_push(save_directory: Path, model_name: Optional[str] = None, push_to_hub: bool = True):
-    filename = "imagenet-1k-id2label.json"
-    num_labels = 1000
-
-    repo_id = "huggingface/label-files"
-    num_labels = num_labels
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    id2label = id2label
-    label2id = {v: k for k, v in id2label.items()}
-
-    ImageNetPreTrainedConfig = partial(VanConfig, num_labels=num_labels, id2label=id2label, label2id=label2id)
-
-    names_to_config = {
-        "van-tiny": ImageNetPreTrainedConfig(
-            hidden_sizes=[32, 64, 160, 256],
-            depths=[3, 3, 5, 2],
-            mlp_ratios=[8, 8, 4, 4],
-        ),
-        "van-small": ImageNetPreTrainedConfig(
-            hidden_sizes=[64, 128, 320, 512],
-            depths=[2, 2, 4, 2],
-            mlp_ratios=[8, 8, 4, 4],
-        ),
-        "van-base": ImageNetPreTrainedConfig(
-            hidden_sizes=[64, 128, 320, 512],
-            depths=[3, 3, 12, 3],
-            mlp_ratios=[8, 8, 4, 4],
-        ),
-        "van-large": ImageNetPreTrainedConfig(
-            hidden_sizes=[64, 128, 320, 512],
-            depths=[3, 5, 27, 3],
-            mlp_ratios=[8, 8, 4, 4],
-        ),
-    }
-
-    names_to_original_models = {
-        "van-tiny": van_tiny,
-        "van-small": van_small,
-        "van-base": van_base,
-        "van-large": van_large,
-    }
-
-    names_to_original_checkpoints = {
-        "van-tiny": (
-            "https://huggingface.co/Visual-Attention-Network/VAN-Tiny-original/resolve/main/van_tiny_754.pth.tar"
-        ),
-        "van-small": (
-            "https://huggingface.co/Visual-Attention-Network/VAN-Small-original/resolve/main/van_small_811.pth.tar"
-        ),
-        "van-base": (
-            "https://huggingface.co/Visual-Attention-Network/VAN-Base-original/resolve/main/van_base_828.pth.tar"
-        ),
-        "van-large": (
-            "https://huggingface.co/Visual-Attention-Network/VAN-Large-original/resolve/main/van_large_839.pth.tar"
-        ),
-    }
-
-    if model_name:
-        convert_weight_and_push(
-            model_name,
-            names_to_config[model_name],
-            checkpoint=names_to_original_checkpoints[model_name],
-            from_model=names_to_original_models[model_name](),
-            save_directory=save_directory,
-            push_to_hub=push_to_hub,
-        )
-    else:
-        for model_name, config in names_to_config.items():
-            convert_weight_and_push(
-                model_name,
-                config,
-                checkpoint=names_to_original_checkpoints[model_name],
-                from_model=names_to_original_models[model_name](),
-                save_directory=save_directory,
-                push_to_hub=push_to_hub,
-            )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model-name",
-        default=None,
-        type=str,
-        help=(
-            "The name of the model you wish to convert, it must be one of the supported resnet* architecture,"
-            " currently: van-tiny/small/base/large. If `None`, all of them will the converted."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=Path,
-        required=True,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--van_dir",
-        required=True,
-        type=Path,
-        help=(
-            "A path to VAN's original implementation directory. You can download from here:"
-            " https://github.com/Visual-Attention-Network/VAN-Classification"
-        ),
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        default=True,
-        type=bool,
-        required=False,
-        help="If True, push model and image processor to the hub.",
-    )
-
-    args = parser.parse_args()
-    pytorch_dump_folder_path: Path = args.pytorch_dump_folder_path
-    pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
-    van_dir = args.van_dir
-    # append the path to the parents to maskformer dir
-    sys.path.append(str(van_dir.parent))
-    from van.models.van import van_base, van_large, van_small, van_tiny
-
-    convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
diff --git a/src/transformers/models/deprecated/vit_hybrid/convert_vit_hybrid_timm_to_pytorch.py b/src/transformers/models/deprecated/vit_hybrid/convert_vit_hybrid_timm_to_pytorch.py
deleted file mode 100644
index 1d717d74c961..000000000000
--- a/src/transformers/models/deprecated/vit_hybrid/convert_vit_hybrid_timm_to_pytorch.py
+++ /dev/null
@@ -1,282 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ViT hybrid checkpoints from the timm library."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import timm
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from timm.data import resolve_data_config
-from timm.data.transforms_factory import create_transform
-
-from transformers import (
-    BitConfig,
-    ViTHybridConfig,
-    ViTHybridForImageClassification,
-    ViTHybridImageProcessor,
-    ViTHybridModel,
-)
-from transformers.image_utils import PILImageResampling
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, base_model=False):
-    rename_keys = []
-
-    # fmt: off
-    # stem:
-    rename_keys.append(("cls_token", "vit.embeddings.cls_token"))
-    rename_keys.append(("pos_embed", "vit.embeddings.position_embeddings"))
-
-    rename_keys.append(("patch_embed.proj.weight", "vit.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("patch_embed.proj.bias", "vit.embeddings.patch_embeddings.projection.bias"))
-
-    # backbone
-    rename_keys.append(("patch_embed.backbone.stem.conv.weight", "vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight"))
-    rename_keys.append(("patch_embed.backbone.stem.norm.weight", "vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight"))
-    rename_keys.append(("patch_embed.backbone.stem.norm.bias", "vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias"))
-
-    for stage_idx in range(len(config.backbone_config.depths)):
-        for layer_idx in range(config.backbone_config.depths[stage_idx]):
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight"))
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight"))
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias"))
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight"))
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight"))
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias"))
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight"))
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight"))
-            rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias"))
-
-        rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight"))
-        rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight"))
-        rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias"))
-
-    # transformer encoder
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"blocks.{i}.norm1.weight", f"vit.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"blocks.{i}.norm1.bias", f"vit.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append((f"blocks.{i}.attn.proj.weight", f"vit.encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.attn.proj.bias", f"vit.encoder.layer.{i}.attention.output.dense.bias"))
-        rename_keys.append((f"blocks.{i}.norm2.weight", f"vit.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"blocks.{i}.norm2.bias", f"vit.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"vit.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"vit.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"vit.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"vit.encoder.layer.{i}.output.dense.bias"))
-
-    if base_model:
-        # layernorm + pooler
-        rename_keys.extend(
-            [
-                ("norm.weight", "layernorm.weight"),
-                ("norm.bias", "layernorm.bias"),
-                ("pre_logits.fc.weight", "pooler.dense.weight"),
-                ("pre_logits.fc.bias", "pooler.dense.bias"),
-            ]
-        )
-
-        # if just the base model, we should remove "vit" from all keys that start with "vit"
-        rename_keys = [(pair[0], pair[1][4:]) if pair[1].startswith("vit") else pair for pair in rename_keys]
-    else:
-        # layernorm + classification head
-        rename_keys.extend(
-            [
-                ("norm.weight", "vit.layernorm.weight"),
-                ("norm.bias", "vit.layernorm.bias"),
-                ("head.weight", "classifier.weight"),
-                ("head.bias", "classifier.bias"),
-            ]
-        )
-    # fmt: on
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, base_model=False):
-    for i in range(config.num_hidden_layers):
-        if base_model:
-            prefix = ""
-        else:
-            prefix = "vit."
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-def remove_classification_head_(state_dict):
-    ignore_keys = ["head.weight", "head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_vit_checkpoint(vit_name, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our ViT structure.
-    """
-
-    # define default ViT hybrid configuration
-    backbone_config = BitConfig(
-        global_padding="same",
-        layer_type="bottleneck",
-        depths=(3, 4, 9),
-        out_features=["stage3"],
-        embedding_dynamic_padding=True,
-    )
-    config = ViTHybridConfig(backbone_config=backbone_config, image_size=384, num_labels=1000)
-    base_model = False
-
-    # load original model from timm
-    timm_model = timm.create_model(vit_name, pretrained=True)
-    timm_model.eval()
-
-    # load state_dict of original model, remove and rename some keys
-    state_dict = timm_model.state_dict()
-    if base_model:
-        remove_classification_head_(state_dict)
-    rename_keys = create_rename_keys(config, base_model)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config, base_model)
-
-    repo_id = "huggingface/label-files"
-    filename = "imagenet-1k-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    # load HuggingFace model
-    if vit_name[-5:] == "in21k":
-        model = ViTHybridModel(config).eval()
-    else:
-        model = ViTHybridForImageClassification(config).eval()
-    model.load_state_dict(state_dict)
-
-    # create image processor
-    transform = create_transform(**resolve_data_config({}, model=timm_model))
-    timm_transforms = transform.transforms
-
-    pillow_resamplings = {
-        "bilinear": PILImageResampling.BILINEAR,
-        "bicubic": PILImageResampling.BICUBIC,
-        "nearest": PILImageResampling.NEAREST,
-    }
-
-    processor = ViTHybridImageProcessor(
-        do_resize=True,
-        size={"shortest_edge": timm_transforms[0].size},
-        resample=pillow_resamplings[timm_transforms[0].interpolation.value],
-        do_center_crop=True,
-        crop_size={"height": timm_transforms[1].size[0], "width": timm_transforms[1].size[1]},
-        do_normalize=True,
-        image_mean=timm_transforms[-1].mean.tolist(),
-        image_std=timm_transforms[-1].std.tolist(),
-    )
-
-    image = prepare_img()
-    timm_pixel_values = transform(image).unsqueeze(0)
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    # verify pixel values
-    assert torch.allclose(timm_pixel_values, pixel_values)
-
-    # verify logits
-    with torch.no_grad():
-        outputs = model(pixel_values)
-        logits = outputs.logits
-
-    print("Predicted class:", logits.argmax(-1).item())
-    if base_model:
-        timm_pooled_output = timm_model.forward_features(pixel_values)
-        assert timm_pooled_output.shape == outputs.pooler_output.shape
-        assert torch.allclose(timm_pooled_output, outputs.pooler_output, atol=1e-3)
-    else:
-        timm_logits = timm_model(pixel_values)
-        assert timm_logits.shape == outputs.logits.shape
-        assert torch.allclose(timm_logits, outputs.logits, atol=1e-3)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model {vit_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving processor to {pytorch_dump_folder_path}")
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and processor to the hub {vit_name}")
-        model.push_to_hub(f"ybelkada/{vit_name}")
-        processor.push_to_hub(f"ybelkada/{vit_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--vit_name",
-        default="vit_base_r50_s16_384",
-        type=str,
-        help="Name of the hybrid ViT timm model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether to upload the model to the HuggingFace hub."
-    )
-
-    args = parser.parse_args()
-    convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/depth_anything/convert_depth_anything_to_hf.py b/src/transformers/models/depth_anything/convert_depth_anything_to_hf.py
deleted file mode 100644
index 5c6da13ae885..000000000000
--- a/src/transformers/models/depth_anything/convert_depth_anything_to_hf.py
+++ /dev/null
@@ -1,368 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Depth Anything checkpoints from the original repository. URL:
-https://github.com/LiheYoung/Depth-Anything"""
-
-import argparse
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DepthAnythingConfig, DepthAnythingForDepthEstimation, Dinov2Config, DPTImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dpt_config(model_name):
-    if "small" in model_name:
-        out_indices = [3, 6, 9, 12] if "v2" in model_name else [9, 10, 11, 12]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-small", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 64
-        neck_hidden_sizes = [48, 96, 192, 384]
-    elif "base" in model_name:
-        out_indices = [3, 6, 9, 12] if "v2" in model_name else [9, 10, 11, 12]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-base", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 128
-        neck_hidden_sizes = [96, 192, 384, 768]
-    elif "large" in model_name:
-        out_indices = [5, 12, 18, 24] if "v2" in model_name else [21, 22, 23, 24]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-large", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 256
-        neck_hidden_sizes = [256, 512, 1024, 1024]
-    else:
-        raise NotImplementedError(f"Model not supported: {model_name}")
-
-    if "metric" in model_name:
-        depth_estimation_type = "metric"
-        max_depth = 20 if "indoor" in model_name else 80
-    else:
-        depth_estimation_type = "relative"
-        max_depth = None
-
-    config = DepthAnythingConfig(
-        reassemble_hidden_size=backbone_config.hidden_size,
-        patch_size=backbone_config.patch_size,
-        backbone_config=backbone_config,
-        fusion_hidden_size=fusion_hidden_size,
-        neck_hidden_sizes=neck_hidden_sizes,
-        depth_estimation_type=depth_estimation_type,
-        max_depth=max_depth,
-    )
-
-    return config
-
-
-def create_rename_keys(config):
-    rename_keys = []
-
-    # fmt: off
-    # stem
-    rename_keys.append(("pretrained.cls_token", "backbone.embeddings.cls_token"))
-    rename_keys.append(("pretrained.mask_token", "backbone.embeddings.mask_token"))
-    rename_keys.append(("pretrained.pos_embed", "backbone.embeddings.position_embeddings"))
-    rename_keys.append(("pretrained.patch_embed.proj.weight", "backbone.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("pretrained.patch_embed.proj.bias", "backbone.embeddings.patch_embeddings.projection.bias"))
-
-    # Transfomer encoder
-    for i in range(config.backbone_config.num_hidden_layers):
-        rename_keys.append((f"pretrained.blocks.{i}.ls1.gamma", f"backbone.encoder.layer.{i}.layer_scale1.lambda1"))
-        rename_keys.append((f"pretrained.blocks.{i}.ls2.gamma", f"backbone.encoder.layer.{i}.layer_scale2.lambda1"))
-        rename_keys.append((f"pretrained.blocks.{i}.norm1.weight", f"backbone.encoder.layer.{i}.norm1.weight"))
-        rename_keys.append((f"pretrained.blocks.{i}.norm1.bias", f"backbone.encoder.layer.{i}.norm1.bias"))
-        rename_keys.append((f"pretrained.blocks.{i}.norm2.weight", f"backbone.encoder.layer.{i}.norm2.weight"))
-        rename_keys.append((f"pretrained.blocks.{i}.norm2.bias", f"backbone.encoder.layer.{i}.norm2.bias"))
-        rename_keys.append((f"pretrained.blocks.{i}.mlp.fc1.weight", f"backbone.encoder.layer.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"pretrained.blocks.{i}.mlp.fc1.bias", f"backbone.encoder.layer.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"pretrained.blocks.{i}.mlp.fc2.weight", f"backbone.encoder.layer.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"pretrained.blocks.{i}.mlp.fc2.bias", f"backbone.encoder.layer.{i}.mlp.fc2.bias"))
-        rename_keys.append((f"pretrained.blocks.{i}.attn.proj.weight", f"backbone.encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"pretrained.blocks.{i}.attn.proj.bias", f"backbone.encoder.layer.{i}.attention.output.dense.bias"))
-
-    # Head
-    rename_keys.append(("pretrained.norm.weight", "backbone.layernorm.weight"))
-    rename_keys.append(("pretrained.norm.bias", "backbone.layernorm.bias"))
-
-    # activation postprocessing (readout projections + resize blocks)
-    # Depth Anything does not use CLS token => readout_projects not required
-
-    for i in range(4):
-        rename_keys.append((f"depth_head.projects.{i}.weight", f"neck.reassemble_stage.layers.{i}.projection.weight"))
-        rename_keys.append((f"depth_head.projects.{i}.bias", f"neck.reassemble_stage.layers.{i}.projection.bias"))
-
-        if i != 2:
-            rename_keys.append((f"depth_head.resize_layers.{i}.weight", f"neck.reassemble_stage.layers.{i}.resize.weight"))
-            rename_keys.append((f"depth_head.resize_layers.{i}.bias", f"neck.reassemble_stage.layers.{i}.resize.bias"))
-
-    # refinenet (tricky here)
-    mapping = {1:3, 2:2, 3:1, 4:0}
-
-    for i in range(1, 5):
-        j = mapping[i]
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.out_conv.weight", f"neck.fusion_stage.layers.{j}.projection.weight"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.out_conv.bias", f"neck.fusion_stage.layers.{j}.projection.bias"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.resConfUnit1.conv1.weight", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution1.weight"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.resConfUnit1.conv1.bias", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution1.bias"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.resConfUnit1.conv2.weight", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution2.weight"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.resConfUnit1.conv2.bias", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution2.bias"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.resConfUnit2.conv1.weight", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution1.weight"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.resConfUnit2.conv1.bias", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution1.bias"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.resConfUnit2.conv2.weight", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution2.weight"))
-        rename_keys.append((f"depth_head.scratch.refinenet{i}.resConfUnit2.conv2.bias", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution2.bias"))
-
-    # scratch convolutions
-    for i in range(4):
-        rename_keys.append((f"depth_head.scratch.layer{i+1}_rn.weight", f"neck.convs.{i}.weight"))
-
-    # head
-    rename_keys.append(("depth_head.scratch.output_conv1.weight", "head.conv1.weight"))
-    rename_keys.append(("depth_head.scratch.output_conv1.bias", "head.conv1.bias"))
-    rename_keys.append(("depth_head.scratch.output_conv2.0.weight", "head.conv2.weight"))
-    rename_keys.append(("depth_head.scratch.output_conv2.0.bias", "head.conv2.bias"))
-    rename_keys.append(("depth_head.scratch.output_conv2.2.weight", "head.conv3.weight"))
-    rename_keys.append(("depth_head.scratch.output_conv2.2.bias", "head.conv3.bias"))
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    hidden_size = config.backbone_config.hidden_size
-    for i in range(config.backbone_config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"pretrained.blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"pretrained.blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[:hidden_size, :]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[:hidden_size]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            hidden_size : hidden_size * 2
-        ]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[-hidden_size:, :]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-hidden_size:]
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-name_to_checkpoint = {
-    "depth-anything-small": "pytorch_model.bin",
-    "depth-anything-base": "pytorch_model.bin",
-    "depth-anything-large": "pytorch_model.bin",
-    "depth-anything-v2-small": "depth_anything_v2_vits.pth",
-    "depth-anything-v2-base": "depth_anything_v2_vitb.pth",
-    "depth-anything-v2-large": "depth_anything_v2_vitl.pth",
-    "depth-anything-v2-metric-indoor-small": "depth_anything_v2_metric_hypersim_vits.pth",
-    "depth-anything-v2-metric-indoor-base": "depth_anything_v2_metric_hypersim_vitb.pth",
-    "depth-anything-v2-metric-indoor-large": "depth_anything_v2_metric_hypersim_vitl.pth",
-    "depth-anything-v2-metric-outdoor-small": "depth_anything_v2_metric_vkitti_vits.pth",
-    "depth-anything-v2-metric-outdoor-base": "depth_anything_v2_metric_vkitti_vitb.pth",
-    "depth-anything-v2-metric-outdoor-large": "depth_anything_v2_metric_vkitti_vitl.pth",
-    # v2-giant pending
-}
-
-
-@torch.no_grad()
-def convert_dpt_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub, verify_logits):
-    """
-    Copy/paste/tweak model's weights to our DPT structure.
-    """
-
-    # define DPT configuration
-    config = get_dpt_config(model_name)
-
-    model_name_to_repo = {
-        "depth-anything-small": "LiheYoung/depth_anything_vits14",
-        "depth-anything-base": "LiheYoung/depth_anything_vitb14",
-        "depth-anything-large": "LiheYoung/depth_anything_vitl14",
-        "depth-anything-v2-small": "depth-anything/Depth-Anything-V2-Small",
-        "depth-anything-v2-base": "depth-anything/Depth-Anything-V2-Base",
-        "depth-anything-v2-large": "depth-anything/Depth-Anything-V2-Large",
-        "depth-anything-v2-metric-indoor-small": "depth-anything/Depth-Anything-V2-Metric-Hypersim-Small",
-        "depth-anything-v2-metric-indoor-base": "depth-anything/Depth-Anything-V2-Metric-Hypersim-Base",
-        "depth-anything-v2-metric-indoor-large": "depth-anything/Depth-Anything-V2-Metric-Hypersim-Large",
-        "depth-anything-v2-metric-outdoor-small": "depth-anything/Depth-Anything-V2-Metric-VKITTI-Small",
-        "depth-anything-v2-metric-outdoor-base": "depth-anything/Depth-Anything-V2-Metric-VKITTI-Base",
-        "depth-anything-v2-metric-outdoor-large": "depth-anything/Depth-Anything-V2-Metric-VKITTI-Large",
-    }
-
-    # load original state_dict
-    repo_id = model_name_to_repo[model_name]
-    filename = name_to_checkpoint[model_name]
-    filepath = hf_hub_download(
-        repo_id=repo_id,
-        filename=f"{filename}",
-    )
-
-    state_dict = torch.load(filepath, map_location="cpu")
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    # read in qkv matrices
-    read_in_q_k_v(state_dict, config)
-
-    # load HuggingFace model
-    model = DepthAnythingForDepthEstimation(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    processor = DPTImageProcessor(
-        do_resize=True,
-        size={"height": 518, "width": 518},
-        ensure_multiple_of=14,
-        keep_aspect_ratio=True,
-        do_rescale=True,
-        do_normalize=True,
-        image_mean=[0.485, 0.456, 0.406],
-        image_std=[0.229, 0.224, 0.225],
-    )
-
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    # Verify forward pass
-    with torch.no_grad():
-        outputs = model(pixel_values)
-        predicted_depth = outputs.predicted_depth
-
-    print("Shape of predicted depth:", predicted_depth.shape)
-    print("First values:", predicted_depth[0, :3, :3])
-
-    # assert logits
-    if verify_logits:
-        expected_shape = torch.Size([1, 518, 686])
-        if model_name == "depth-anything-small":
-            expected_slice = torch.tensor(
-                [[8.8204, 8.6468, 8.6195], [8.3313, 8.6027, 8.7526], [8.6526, 8.6866, 8.7453]],
-            )
-        elif model_name == "depth-anything-base":
-            expected_slice = torch.tensor(
-                [[26.3997, 26.3004, 26.3928], [26.2260, 26.2092, 26.3427], [26.0719, 26.0483, 26.1254]],
-            )
-        elif model_name == "depth-anything-large":
-            expected_slice = torch.tensor(
-                [[87.9968, 87.7493, 88.2704], [87.1927, 87.6611, 87.3640], [86.7789, 86.9469, 86.7991]]
-            )
-        elif model_name == "depth-anything-v2-small":
-            expected_slice = torch.tensor(
-                [[2.6751, 2.6211, 2.6571], [2.5820, 2.6138, 2.6271], [2.6160, 2.6141, 2.6306]]
-            )
-        elif model_name == "depth-anything-v2-base":
-            expected_slice = torch.tensor(
-                [[4.3576, 4.3723, 4.3908], [4.3231, 4.3146, 4.3611], [4.3016, 4.3170, 4.3121]]
-            )
-        elif model_name == "depth-anything-v2-large":
-            expected_slice = torch.tensor(
-                [[162.2751, 161.8504, 162.8788], [160.3138, 160.8050, 161.9835], [159.3812, 159.9884, 160.0768]]
-            )
-        elif model_name == "depth-anything-v2-metric-indoor-small":
-            expected_slice = torch.tensor(
-                [[1.3349, 1.2946, 1.2801], [1.2793, 1.2337, 1.2899], [1.2629, 1.2218, 1.2476]]
-            )
-        elif model_name == "depth-anything-v2-metric-indoor-base":
-            expected_slice = torch.tensor(
-                [[1.4601, 1.3824, 1.4904], [1.5031, 1.4349, 1.4274], [1.4570, 1.4578, 1.4200]]
-            )
-        elif model_name == "depth-anything-v2-metric-indoor-large":
-            expected_slice = torch.tensor(
-                [[1.5040, 1.5019, 1.5218], [1.5087, 1.5195, 1.5149], [1.5437, 1.5128, 1.5252]]
-            )
-        elif model_name == "depth-anything-v2-metric-outdoor-small":
-            expected_slice = torch.tensor(
-                [[9.5804, 8.0339, 7.7386], [7.9890, 7.2464, 7.7149], [7.7021, 7.2330, 7.3304]]
-            )
-        elif model_name == "depth-anything-v2-metric-outdoor-base":
-            expected_slice = torch.tensor(
-                [[10.2916, 9.0933, 8.8622], [9.1964, 9.3393, 9.0644], [8.9618, 9.4201, 9.2262]]
-            )
-        elif model_name == "depth-anything-v2-metric-outdoor-large":
-            expected_slice = torch.tensor(
-                [[14.0137, 13.3627, 13.1080], [13.2522, 13.3943, 13.3705], [13.0581, 13.4505, 13.3925]]
-            )
-        else:
-            raise ValueError("Not supported")
-
-        assert predicted_depth.shape == torch.Size(expected_shape)
-        assert torch.allclose(predicted_depth[0, :3, :3], expected_slice, atol=1e-4)
-        print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model and processor to hub...")
-        model.push_to_hub(repo_id=f"{model_name.title()}-hf")
-        processor.push_to_hub(repo_id=f"{model_name.title()}-hf")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="depth-anything-small",
-        type=str,
-        choices=name_to_checkpoint.keys(),
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model to the hub after conversion.",
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_false",
-        required=False,
-        help="Whether to verify the logits after conversion.",
-    )
-
-    args = parser.parse_args()
-    convert_dpt_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.verify_logits)
diff --git a/src/transformers/models/depth_anything/convert_distill_any_depth_to_hf.py b/src/transformers/models/depth_anything/convert_distill_any_depth_to_hf.py
deleted file mode 100644
index 47cec7afac1a..000000000000
--- a/src/transformers/models/depth_anything/convert_distill_any_depth_to_hf.py
+++ /dev/null
@@ -1,246 +0,0 @@
-# coding=utf-8
-# Copyright 2025 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Distill Any Depth checkpoints from the original repository. URL:
-https://github.com/Westlake-AGI-Lab/Distill-Any-Depth"""
-
-import argparse
-import re
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from safetensors.torch import load_file
-
-from transformers import DepthAnythingConfig, DepthAnythingForDepthEstimation, Dinov2Config, DPTImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    r"(backbone|pretrained)\.cls_token": r"backbone.embeddings.cls_token",
-    r"(backbone|pretrained)\.mask_token": r"backbone.embeddings.mask_token",
-    r"(backbone|pretrained)\.pos_embed": r"backbone.embeddings.position_embeddings",
-    r"(backbone|pretrained)\.patch_embed\.proj\.(weight|bias)": r"backbone.embeddings.patch_embeddings.projection.\2",
-    r"(backbone|pretrained)\.norm\.(weight|bias)": r"backbone.layernorm.\2",
-    r"(backbone|pretrained)(\.blocks(\.\d+)?)?\.(\d+)\.attn\.proj\.(weight|bias)": r"backbone.encoder.layer.\4.attention.output.dense.\5",
-    r"(backbone|pretrained)(\.blocks(\.\d+)?)?\.(\d+)\.ls(1|2)\.gamma": r"backbone.encoder.layer.\4.layer_scale\5.lambda1",
-    r"(backbone|pretrained)(\.blocks(\.\d+)?)?\.(\d+)\.mlp\.fc(1|2)\.(weight|bias)": r"backbone.encoder.layer.\4.mlp.fc\5.\6",
-    r"(backbone|pretrained)(\.blocks(\.\d+)?)?\.(\d+)\.norm(1|2)\.(weight|bias)": r"backbone.encoder.layer.\4.norm\5.\6",
-    r"depth_head\.projects\.(\d+)\.(weight|bias)": r"neck.reassemble_stage.layers.\1.projection.\2",
-    r"depth_head\.resize_layers\.(?!2)(\d+)\.(weight|bias)": r"neck.reassemble_stage.layers.\1.resize.\2",
-    r"depth_head\.scratch\.layer(\d+)_rn\.weight": lambda m: f"neck.convs.{int(m[1]) - 1}.weight",
-    r"depth_head\.scratch\.output_conv(\d+)(?:\.(\d+))?\.(weight|bias)": lambda m: (
-        f"head.conv{int(m[1]) + (int(m[2]) // 2 if m[2] else 0)}.{m[3]}" if m[1] == "2" else f"head.conv{m[1]}.{m[3]}"
-    ),
-    r"depth_head\.scratch\.refinenet(\d+)\.out_conv\.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{3 - (int(m[1]) - 1)}.projection.{m[2]}",
-    r"depth_head\.scratch\.refinenet(\d+)\.resConfUnit(\d+)\.conv(\d+)\.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{3 - (int(m[1]) - 1)}.residual_layer{m[2]}.convolution{m[3]}.{m[4]}",
-}
-
-
-def get_dpt_config(model_name):
-    if "small" in model_name:
-        out_indices = [3, 6, 9, 12]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-small", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 64
-        neck_hidden_sizes = [48, 96, 192, 384]
-    elif "base" in model_name:
-        out_indices = [3, 6, 9, 12]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-base", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 128
-        neck_hidden_sizes = [96, 192, 384, 768]
-    elif "large" in model_name:
-        out_indices = [5, 12, 18, 24]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-large", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 256
-        neck_hidden_sizes = [256, 512, 1024, 1024]
-    else:
-        raise NotImplementedError(f"Model not supported: {model_name}")
-
-    depth_estimation_type = "relative"
-    max_depth = None
-
-    config = DepthAnythingConfig(
-        reassemble_hidden_size=backbone_config.hidden_size,
-        patch_size=backbone_config.patch_size,
-        backbone_config=backbone_config,
-        fusion_hidden_size=fusion_hidden_size,
-        neck_hidden_sizes=neck_hidden_sizes,
-        depth_estimation_type=depth_estimation_type,
-        max_depth=max_depth,
-    )
-
-    return config
-
-
-def convert_key_pattern(key, mapping):
-    for pattern, replacement in mapping.items():
-        match = re.fullmatch(pattern, key)
-        if match:
-            if callable(replacement):
-                return replacement(match)
-            return re.sub(pattern, replacement, key)
-    return None
-
-
-def convert_keys(state_dict, config):
-    new_state_dict = {}
-    qkv_pattern = r"(backbone|pretrained)(\.blocks(\.\d+)?)?\.(\d+)\.attn\.qkv\.(weight|bias)"
-    qkv_keys = [k for k in list(state_dict.keys()) if re.match(qkv_pattern, k)]
-    for old_key in qkv_keys:
-        value = state_dict.pop(old_key)
-        match = re.match(qkv_pattern, old_key)
-        _, _, _, layer, attr = match.groups()
-        hidden_size = config.backbone_config.hidden_size
-        q = value[:hidden_size]
-        k = value[hidden_size : hidden_size * 2]
-        v = value[-hidden_size:]
-
-        for proj, tensor in zip(["query", "key", "value"], [q, k, v]):
-            new_key = f"backbone.encoder.layer.{layer}.attention.attention.{proj}.{attr}"
-            new_state_dict[new_key] = tensor
-
-    for old_key in list(state_dict.keys()):
-        value = state_dict.pop(old_key)
-        new_key = convert_key_pattern(old_key, ORIGINAL_TO_CONVERTED_KEY_MAPPING)
-
-        new_state_dict[new_key] = value
-
-    return new_state_dict
-
-
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    return Image.open(requests.get(url, stream=True).raw)
-
-
-name_to_checkpoint = {
-    "distill-any-depth-small": "small/model.safetensors",
-    "distill-any-depth-base": "base/model.safetensors",
-    "distill-any-depth-large": "large/model.safetensors",
-}
-
-
-@torch.no_grad()
-def convert_dpt_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub, verify_logits):
-    config = get_dpt_config(model_name)
-
-    repo_id = "xingyang1/Distill-Any-Depth"
-    filepath = hf_hub_download(repo_id=repo_id, filename=name_to_checkpoint[model_name])
-    state_dict = load_file(filepath)
-
-    converted_state_dict = convert_keys(state_dict, config)
-
-    model = DepthAnythingForDepthEstimation(config)
-    model.load_state_dict(converted_state_dict)
-    model.eval()
-
-    processor = DPTImageProcessor(
-        do_resize=True,
-        size={"height": 518, "width": 518},
-        ensure_multiple_of=14,
-        keep_aspect_ratio=True,
-        do_rescale=True,
-        do_normalize=True,
-        image_mean=[0.485, 0.456, 0.406],
-        image_std=[0.229, 0.224, 0.225],
-    )
-
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    with torch.no_grad():
-        outputs = model(pixel_values)
-        predicted_depth = outputs.predicted_depth
-
-    print("Shape of predicted depth:", predicted_depth.shape)
-    print("First values:", predicted_depth[0, :3, :3])
-
-    if verify_logits:
-        print("Verifying logits...")
-        expected_shape = torch.Size([1, 518, 686])
-
-        if model_name == "distill-any-depth-small":
-            expected_slice = torch.tensor(
-                [[2.5653, 2.5249, 2.5570], [2.4897, 2.5235, 2.5355], [2.5255, 2.5261, 2.5422]]
-            )
-        elif model_name == "distill-any-depth-base":
-            expected_slice = torch.tensor(
-                [[4.8976, 4.9075, 4.9403], [4.8872, 4.8906, 4.9448], [4.8712, 4.8898, 4.8838]]
-            )
-        elif model_name == "distill-any-depth-large":
-            expected_slice = torch.tensor(
-                [[55.1067, 51.1828, 51.6803], [51.9098, 50.7529, 51.4494], [50.1745, 50.5491, 50.8818]]
-            )
-        else:
-            raise ValueError("Not supported")
-
-        assert predicted_depth.shape == torch.Size(expected_shape)
-        assert torch.allclose(predicted_depth[0, :3, :3], expected_slice, atol=1e-4)
-        print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model and processor to hub...")
-        model.push_to_hub(repo_id=f"{model_name.title()}-hf")
-        processor.push_to_hub(repo_id=f"{model_name.title()}-hf")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model_name",
-        default="distill-any-depth-small",
-        type=str,
-        choices=name_to_checkpoint.keys(),
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model to the hub after conversion.",
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_true",
-        required=False,
-        help="Whether to verify the logits after conversion.",
-    )
-
-    args = parser.parse_args()
-    convert_dpt_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.verify_logits)
diff --git a/src/transformers/models/depth_pro/convert_depth_pro_weights_to_hf.py b/src/transformers/models/depth_pro/convert_depth_pro_weights_to_hf.py
deleted file mode 100644
index b24c6a5174f0..000000000000
--- a/src/transformers/models/depth_pro/convert_depth_pro_weights_to_hf.py
+++ /dev/null
@@ -1,254 +0,0 @@
-# Copyright 2024 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import gc
-import os
-
-import regex as re
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import (
-    DepthProConfig,
-    DepthProForDepthEstimation,
-    DepthProImageProcessorFast,
-)
-
-
-# fmt: off
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-
-    # encoder
-    r"encoder.(patch|image)_encoder.cls_token":                                 r"depth_pro.encoder.\1_encoder.model.embeddings.cls_token",
-    r"encoder.(patch|image)_encoder.pos_embed":                                 r"depth_pro.encoder.\1_encoder.model.embeddings.position_embeddings",
-    r"encoder.(patch|image)_encoder.patch_embed.proj.(weight|bias)":            r"depth_pro.encoder.\1_encoder.model.embeddings.patch_embeddings.projection.\2",
-    r"encoder.(patch|image)_encoder.blocks.(\d+).norm(\d+).(weight|bias)":      r"depth_pro.encoder.\1_encoder.model.encoder.layer.\2.norm\3.\4",
-    r"encoder.(patch|image)_encoder.blocks.(\d+).attn.qkv.(weight|bias)":       r"depth_pro.encoder.\1_encoder.model.encoder.layer.\2.attention.attention.(query|key|value).\3",
-    r"encoder.(patch|image)_encoder.blocks.(\d+).attn.proj.(weight|bias)":      r"depth_pro.encoder.\1_encoder.model.encoder.layer.\2.attention.output.dense.\3",
-    r"encoder.(patch|image)_encoder.blocks.(\d+).ls(\d+).gamma":                r"depth_pro.encoder.\1_encoder.model.encoder.layer.\2.layer_scale\3.lambda1",
-    r"encoder.(patch|image)_encoder.blocks.(\d+).mlp.fc(\d+).(weight|bias)":    r"depth_pro.encoder.\1_encoder.model.encoder.layer.\2.mlp.fc\3.\4",
-    r"encoder.(patch|image)_encoder.norm.(weight|bias)":                        r"depth_pro.encoder.\1_encoder.model.layernorm.\2",
-    r"encoder.fuse_lowres.(weight|bias)":                                       r"depth_pro.neck.fuse_image_with_low_res.\1",
-
-    # fov
-    r"fov.encoder.0.cls_token":                                                 r"fov_model.fov_encoder.model.embeddings.cls_token",
-    r"fov.encoder.0.pos_embed":                                                 r"fov_model.fov_encoder.model.embeddings.position_embeddings",
-    r"fov.encoder.0.patch_embed.proj.(weight|bias)":                            r"fov_model.fov_encoder.model.embeddings.patch_embeddings.projection.\1",
-    r"fov.encoder.0.blocks.(\d+).norm(\d+).(weight|bias)":                      r"fov_model.fov_encoder.model.encoder.layer.\1.norm\2.\3",
-    r"fov.encoder.0.blocks.(\d+).attn.qkv.(weight|bias)":                       r"fov_model.fov_encoder.model.encoder.layer.\1.attention.attention.(query|key|value).\2",
-    r"fov.encoder.0.blocks.(\d+).attn.proj.(weight|bias)":                      r"fov_model.fov_encoder.model.encoder.layer.\1.attention.output.dense.\2",
-    r"fov.encoder.0.blocks.(\d+).ls(\d+).gamma":                                r"fov_model.fov_encoder.model.encoder.layer.\1.layer_scale\2.lambda1",
-    r"fov.encoder.0.blocks.(\d+).mlp.fc(\d+).(weight|bias)":                    r"fov_model.fov_encoder.model.encoder.layer.\1.mlp.fc\2.\3",
-    r"fov.encoder.0.norm.(weight|bias)":                                        r"fov_model.fov_encoder.model.layernorm.\1",
-    r"fov.downsample.0.(weight|bias)":                                          r"fov_model.conv.\1",
-    r"fov.encoder.1.(weight|bias)":                                             r"fov_model.fov_encoder.neck.\1",
-    r"fov.head.(\d+).(weight|bias)":                                            r"fov_model.head.layers.\1.\2",
-
-    # head
-    r"head.(\d+).(weight|bias)":                                                r"head.layers.\1.\2",
-
-    # upsamples
-    r"encoder.upsample_lowres.(weight|bias)":                                   r"depth_pro.neck.feature_upsample.image_block.layers.0.\1",
-    r"encoder.upsample_latent(\d+).(\d+).(weight|bias)": lambda match: (
-        f"depth_pro.neck.feature_upsample.intermediate.{1-int(match.group(1))}.layers.{match.group(2)}.{match.group(3)}"
-    ),
-    r"encoder.upsample(\d+).(\d+).(weight|bias)": lambda match: (
-        f"depth_pro.neck.feature_upsample.scaled_images.{2-int(match.group(1))}.layers.{match.group(2)}.{match.group(3)}"
-    ),
-
-    # projections between encoder and fusion
-    r"decoder.convs.(\d+).weight": lambda match: (
-        f"depth_pro.neck.feature_projection.projections.{4-int(match.group(1))}.weight"
-    ),
-
-    # fusion stage
-    r"decoder.fusions.([1234]).resnet(\d+).residual.(\d+).(weight|bias)": lambda match: (
-        f"fusion_stage.intermediate.{4-int(match.group(1))}.residual_layer{match.group(2)}.convolution{(int(match.group(3))+1)//2}.{match.group(4)}"
-    ),
-    r"decoder.fusions.0.resnet(\d+).residual.(\d+).(weight|bias)": lambda match: (
-        f"fusion_stage.final.residual_layer{match.group(1)}.convolution{(int(match.group(2))+1)//2}.{match.group(3)}"
-    ),
-    r"decoder.fusions.([1234]).out_conv.(weight|bias)": lambda match: (
-        f"fusion_stage.intermediate.{4-int(match.group(1))}.projection.{match.group(2)}"
-    ),
-    r"decoder.fusions.0.out_conv.(weight|bias)": lambda match: (
-        f"fusion_stage.final.projection.{match.group(1)}"
-    ),
-    r"decoder.fusions.(\d+).deconv.(weight|bias)": lambda match: (
-        f"fusion_stage.intermediate.{4-int(match.group(1))}.deconv.{match.group(2)}"
-    ),
-}
-# fmt: on
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-        for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-            if replacement is None:
-                new_text = re.sub(pattern, "", new_text)  # an empty line
-                continue
-            new_text = re.sub(pattern, replacement, new_text)
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-    return output_dict
-
-
-def get_qkv_state_dict(key, parameter):
-    """
-    new key which looks like this
-    xxxx.(q|k|v).xxx    (m, n)
-
-    is converted to
-    xxxx.q.xxxx         (m//3, n)
-    xxxx.k.xxxx         (m//3, n)
-    xxxx.v.xxxx         (m//3, n)
-    """
-    qkv_state_dict = {}
-    placeholder = re.search(r"(\(.*?\))", key).group(1)  # finds   "(query|key|value)"
-    replacements_keys = placeholder[1:-1].split("|")  # creates ['query', 'key', 'value']
-    replacements_vals = torch.split(
-        parameter, split_size_or_sections=parameter.size(0) // len(replacements_keys), dim=0
-    )
-    for replacement_key, replacement_val in zip(replacements_keys, replacements_vals):
-        qkv_state_dict[key.replace(placeholder, replacement_key)] = replacement_val
-    return qkv_state_dict
-
-
-def write_model(
-    hf_repo_id: str,
-    output_dir: str,
-    safe_serialization: bool = True,
-):
-    os.makedirs(output_dir, exist_ok=True)
-
-    # ------------------------------------------------------------
-    # Create and save config
-    # ------------------------------------------------------------
-
-    # create config
-    backbone_config = {
-        "model_type": "dinov2",
-        "num_hidden_layers": 24,
-        "patch_size": 16,
-        "hidden_size": 1024,
-        "num_attention_heads": 16,
-        "image_size": 384,
-        "use_mask_token": False,
-    }
-    config = DepthProConfig(
-        # original implementation uses same config for all 3 models
-        image_model_config=backbone_config,
-        patch_model_config=backbone_config,
-        fov_model_config=backbone_config,
-        use_fov_model=True,
-    )
-
-    # save config
-    config.save_pretrained(output_dir)
-    print("Model config saved successfully...")
-
-    # ------------------------------------------------------------
-    # Convert weights
-    # ------------------------------------------------------------
-
-    # download and load state_dict from hf repo
-    file_path = hf_hub_download(hf_repo_id, "depth_pro.pt")
-    loaded = torch.load(file_path, weights_only=True)
-
-    print("Converting model...")
-    all_keys = list(loaded.keys())
-    new_keys = convert_old_keys_to_new_keys(all_keys)
-
-    state_dict = {}
-    for key in all_keys:
-        new_key = new_keys[key]
-        current_parameter = loaded.pop(key)
-
-        if "qkv" in key:
-            qkv_state_dict = get_qkv_state_dict(new_key, current_parameter)
-            state_dict.update(qkv_state_dict)
-        else:
-            state_dict[new_key] = current_parameter
-
-    print("Loading the checkpoint in a DepthPro model.")
-    model = DepthProForDepthEstimation(config)
-    model.load_state_dict(state_dict, strict=True, assign=True)
-    print("Checkpoint loaded successfully.")
-
-    print("Saving the model.")
-    model.save_pretrained(output_dir, safe_serialization=safe_serialization)
-    del state_dict, model
-
-    # Safety check: reload the converted model
-    gc.collect()
-    print("Reloading the model to check if it's saved correctly.")
-    model = DepthProForDepthEstimation.from_pretrained(output_dir, device_map="auto")
-    print("Model reloaded successfully.")
-    return model
-
-
-def write_image_processor(output_dir: str):
-    image_processor = DepthProImageProcessorFast()
-    image_processor.save_pretrained(output_dir)
-    return image_processor
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--hf_repo_id",
-        default="apple/DepthPro",
-        help="Location of official weights from apple on HF",
-    )
-    parser.add_argument(
-        "--output_dir",
-        default="apple_DepthPro",
-        help="Location to write the converted model and processor",
-    )
-    parser.add_argument(
-        "--safe_serialization", default=True, type=bool, help="Whether or not to save using `safetensors`."
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action=argparse.BooleanOptionalAction,
-        help="Whether or not to push the converted model to the huggingface hub.",
-    )
-    parser.add_argument(
-        "--hub_repo_id",
-        default="apple/DepthPro-hf",
-        help="Huggingface hub repo to write the converted model and processor",
-    )
-    args = parser.parse_args()
-
-    model = write_model(
-        hf_repo_id=args.hf_repo_id,
-        output_dir=args.output_dir,
-        safe_serialization=args.safe_serialization,
-    )
-
-    image_processor = write_image_processor(
-        output_dir=args.output_dir,
-    )
-
-    if args.push_to_hub:
-        print("Pushing to hub...")
-        model.push_to_hub(args.hub_repo_id)
-        image_processor.push_to_hub(args.hub_repo_id)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/detr/convert_detr_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/detr/convert_detr_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index ba985145014c..000000000000
--- a/src/transformers/models/detr/convert_detr_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,277 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DETR checkpoints with timm backbone."""
-
-import argparse
-import json
-from collections import OrderedDict
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-rename_keys = []
-for i in range(6):
-    # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.self_attn.out_proj.weight", f"encoder.layers.{i}.self_attn.out_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.self_attn.out_proj.bias", f"encoder.layers.{i}.self_attn.out_proj.bias")
-    )
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear1.weight", f"encoder.layers.{i}.fc1.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear1.bias", f"encoder.layers.{i}.fc1.bias"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear2.weight", f"encoder.layers.{i}.fc2.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear2.bias", f"encoder.layers.{i}.fc2.bias"))
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.norm1.weight", f"encoder.layers.{i}.self_attn_layer_norm.weight")
-    )
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm1.bias", f"encoder.layers.{i}.self_attn_layer_norm.bias"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm2.weight", f"encoder.layers.{i}.final_layer_norm.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm2.bias", f"encoder.layers.{i}.final_layer_norm.bias"))
-    # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.self_attn.out_proj.weight", f"decoder.layers.{i}.self_attn.out_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.self_attn.out_proj.bias", f"decoder.layers.{i}.self_attn.out_proj.bias")
-    )
-    rename_keys.append(
-        (
-            f"transformer.decoder.layers.{i}.multihead_attn.out_proj.weight",
-            f"decoder.layers.{i}.encoder_attn.out_proj.weight",
-        )
-    )
-    rename_keys.append(
-        (
-            f"transformer.decoder.layers.{i}.multihead_attn.out_proj.bias",
-            f"decoder.layers.{i}.encoder_attn.out_proj.bias",
-        )
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear1.weight", f"decoder.layers.{i}.fc1.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear1.bias", f"decoder.layers.{i}.fc1.bias"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear2.weight", f"decoder.layers.{i}.fc2.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear2.bias", f"decoder.layers.{i}.fc2.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm1.weight", f"decoder.layers.{i}.self_attn_layer_norm.weight")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm1.bias", f"decoder.layers.{i}.self_attn_layer_norm.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm2.weight", f"decoder.layers.{i}.encoder_attn_layer_norm.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm2.bias", f"decoder.layers.{i}.encoder_attn_layer_norm.bias")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm3.weight", f"decoder.layers.{i}.final_layer_norm.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm3.bias", f"decoder.layers.{i}.final_layer_norm.bias"))
-
-# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
-rename_keys.extend(
-    [
-        ("input_proj.weight", "input_projection.weight"),
-        ("input_proj.bias", "input_projection.bias"),
-        ("query_embed.weight", "query_position_embeddings.weight"),
-        ("transformer.decoder.norm.weight", "decoder.layernorm.weight"),
-        ("transformer.decoder.norm.bias", "decoder.layernorm.bias"),
-        ("class_embed.weight", "class_labels_classifier.weight"),
-        ("class_embed.bias", "class_labels_classifier.bias"),
-        ("bbox_embed.layers.0.weight", "bbox_predictor.layers.0.weight"),
-        ("bbox_embed.layers.0.bias", "bbox_predictor.layers.0.bias"),
-        ("bbox_embed.layers.1.weight", "bbox_predictor.layers.1.weight"),
-        ("bbox_embed.layers.1.bias", "bbox_predictor.layers.1.bias"),
-        ("bbox_embed.layers.2.weight", "bbox_predictor.layers.2.weight"),
-        ("bbox_embed.layers.2.bias", "bbox_predictor.layers.2.bias"),
-    ]
-)
-
-
-def rename_key(state_dict, old, new):
-    val = state_dict.pop(old)
-    state_dict[new] = val
-
-
-def rename_backbone_keys(state_dict):
-    new_state_dict = OrderedDict()
-    for key, value in state_dict.items():
-        if "backbone.0.body" in key:
-            new_key = key.replace("backbone.0.body", "backbone.conv_encoder.model")
-            new_state_dict[new_key] = value
-        else:
-            new_state_dict[key] = value
-
-    return new_state_dict
-
-
-def read_in_q_k_v(state_dict, is_panoptic=False):
-    prefix = ""
-    if is_panoptic:
-        prefix = "detr."
-
-    # first: transformer encoder
-    for i in range(6):
-        # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-    # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
-    for i in range(6):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-        # read in weights + bias of input projection layer of cross-attention
-        in_proj_weight_cross_attn = state_dict.pop(
-            f"{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight"
-        )
-        in_proj_bias_cross_attn = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) of cross-attention to the state dict
-        state_dict[f"decoder.layers.{i}.encoder_attn.q_proj.weight"] = in_proj_weight_cross_attn[:256, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.q_proj.bias"] = in_proj_bias_cross_attn[:256]
-        state_dict[f"decoder.layers.{i}.encoder_attn.k_proj.weight"] = in_proj_weight_cross_attn[256:512, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.k_proj.bias"] = in_proj_bias_cross_attn[256:512]
-        state_dict[f"decoder.layers.{i}.encoder_attn.v_proj.weight"] = in_proj_weight_cross_attn[-256:, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.v_proj.bias"] = in_proj_bias_cross_attn[-256:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-
-    return im
-
-
-@torch.no_grad()
-def convert_detr_checkpoint(model_name, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our DETR structure.
-    """
-
-    # load default config
-    config = DetrConfig()
-    # set backbone and dilation attributes
-    if "resnet101" in model_name:
-        config.backbone = "resnet101"
-    if "dc5" in model_name:
-        config.dilation = True
-    is_panoptic = "panoptic" in model_name
-    if is_panoptic:
-        config.num_labels = 250
-    else:
-        config.num_labels = 91
-        repo_id = "huggingface/label-files"
-        filename = "coco-detection-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    # load image processor
-    format = "coco_panoptic" if is_panoptic else "coco_detection"
-    image_processor = DetrImageProcessor(format=format)
-
-    # prepare image
-    img = prepare_img()
-    encoding = image_processor(images=img, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    logger.info(f"Converting model {model_name}...")
-
-    # load original model from torch hub
-    detr = torch.hub.load("facebookresearch/detr", model_name, pretrained=True).eval()
-    state_dict = detr.state_dict()
-    # rename keys
-    for src, dest in rename_keys:
-        if is_panoptic:
-            src = "detr." + src
-        rename_key(state_dict, src, dest)
-    state_dict = rename_backbone_keys(state_dict)
-    # query, key and value matrices need special treatment
-    read_in_q_k_v(state_dict, is_panoptic=is_panoptic)
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    prefix = "detr.model." if is_panoptic else "model."
-    for key in state_dict.copy().keys():
-        if is_panoptic:
-            if (
-                key.startswith("detr")
-                and not key.startswith("class_labels_classifier")
-                and not key.startswith("bbox_predictor")
-            ):
-                val = state_dict.pop(key)
-                state_dict["detr.model" + key[4:]] = val
-            elif "class_labels_classifier" in key or "bbox_predictor" in key:
-                val = state_dict.pop(key)
-                state_dict["detr." + key] = val
-            elif key.startswith("bbox_attention") or key.startswith("mask_head"):
-                continue
-            else:
-                val = state_dict.pop(key)
-                state_dict[prefix + key] = val
-        else:
-            if not key.startswith("class_labels_classifier") and not key.startswith("bbox_predictor"):
-                val = state_dict.pop(key)
-                state_dict[prefix + key] = val
-    # finally, create HuggingFace model and load state dict
-    model = DetrForSegmentation(config) if is_panoptic else DetrForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-    # verify our conversion
-    original_outputs = detr(pixel_values)
-    outputs = model(pixel_values)
-    assert torch.allclose(outputs.logits, original_outputs["pred_logits"], atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes, original_outputs["pred_boxes"], atol=1e-4)
-    if is_panoptic:
-        assert torch.allclose(outputs.pred_masks, original_outputs["pred_masks"], atol=1e-4)
-
-    # Save model and image processor
-    logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--model_name", default="detr_resnet50", type=str, help="Name of the DETR model you'd like to convert."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/detr/convert_detr_to_pytorch.py b/src/transformers/models/detr/convert_detr_to_pytorch.py
deleted file mode 100644
index 6ba6a0e2920a..000000000000
--- a/src/transformers/models/detr/convert_detr_to_pytorch.py
+++ /dev/null
@@ -1,385 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DETR checkpoints with native (Transformers) backbone."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor, ResNetConfig
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_detr_config(model_name):
-    # initialize config
-    if "resnet-50" in model_name:
-        backbone_config = ResNetConfig.from_pretrained("microsoft/resnet-50")
-    elif "resnet-101" in model_name:
-        backbone_config = ResNetConfig.from_pretrained("microsoft/resnet-101")
-    else:
-        raise ValueError("Model name should include either resnet50 or resnet101")
-
-    config = DetrConfig(use_timm_backbone=False, backbone_config=backbone_config)
-
-    # set label attributes
-    is_panoptic = "panoptic" in model_name
-    if is_panoptic:
-        config.num_labels = 250
-    else:
-        config.num_labels = 91
-        repo_id = "huggingface/label-files"
-        filename = "coco-detection-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    return config, is_panoptic
-
-
-def create_rename_keys(config):
-    # here we list all keys to be renamed (original name on the left, our name on the right)
-    rename_keys = []
-
-    # stem
-    # fmt: off
-    rename_keys.append(("backbone.0.body.conv1.weight", "backbone.conv_encoder.model.embedder.embedder.convolution.weight"))
-    rename_keys.append(("backbone.0.body.bn1.weight", "backbone.conv_encoder.model.embedder.embedder.normalization.weight"))
-    rename_keys.append(("backbone.0.body.bn1.bias", "backbone.conv_encoder.model.embedder.embedder.normalization.bias"))
-    rename_keys.append(("backbone.0.body.bn1.running_mean", "backbone.conv_encoder.model.embedder.embedder.normalization.running_mean"))
-    rename_keys.append(("backbone.0.body.bn1.running_var", "backbone.conv_encoder.model.embedder.embedder.normalization.running_var"))
-    # stages
-    for stage_idx in range(len(config.backbone_config.depths)):
-        for layer_idx in range(config.backbone_config.depths[stage_idx]):
-            # shortcut
-            if layer_idx == 0:
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var",
-                    )
-                )
-            # 3 convs
-            for i in range(3):
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var",
-                    )
-                )
-    # fmt: on
-
-    for i in range(config.encoder_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append(
-            (
-                f"transformer.encoder.layers.{i}.self_attn.out_proj.weight",
-                f"encoder.layers.{i}.self_attn.out_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (f"transformer.encoder.layers.{i}.self_attn.out_proj.bias", f"encoder.layers.{i}.self_attn.out_proj.bias")
-        )
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.weight", f"encoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.bias", f"encoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.weight", f"encoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.bias", f"encoder.layers.{i}.fc2.bias"))
-        rename_keys.append(
-            (f"transformer.encoder.layers.{i}.norm1.weight", f"encoder.layers.{i}.self_attn_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"transformer.encoder.layers.{i}.norm1.bias", f"encoder.layers.{i}.self_attn_layer_norm.bias")
-        )
-        rename_keys.append(
-            (f"transformer.encoder.layers.{i}.norm2.weight", f"encoder.layers.{i}.final_layer_norm.weight")
-        )
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm2.bias", f"encoder.layers.{i}.final_layer_norm.bias"))
-        # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
-        rename_keys.append(
-            (
-                f"transformer.decoder.layers.{i}.self_attn.out_proj.weight",
-                f"decoder.layers.{i}.self_attn.out_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.self_attn.out_proj.bias", f"decoder.layers.{i}.self_attn.out_proj.bias")
-        )
-        rename_keys.append(
-            (
-                f"transformer.decoder.layers.{i}.multihead_attn.out_proj.weight",
-                f"decoder.layers.{i}.encoder_attn.out_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"transformer.decoder.layers.{i}.multihead_attn.out_proj.bias",
-                f"decoder.layers.{i}.encoder_attn.out_proj.bias",
-            )
-        )
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.weight", f"decoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.bias", f"decoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.weight", f"decoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.bias", f"decoder.layers.{i}.fc2.bias"))
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm1.weight", f"decoder.layers.{i}.self_attn_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm1.bias", f"decoder.layers.{i}.self_attn_layer_norm.bias")
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm2.weight", f"decoder.layers.{i}.encoder_attn_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm2.bias", f"decoder.layers.{i}.encoder_attn_layer_norm.bias")
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm3.weight", f"decoder.layers.{i}.final_layer_norm.weight")
-        )
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm3.bias", f"decoder.layers.{i}.final_layer_norm.bias"))
-
-    # convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
-    rename_keys.extend(
-        [
-            ("input_proj.weight", "input_projection.weight"),
-            ("input_proj.bias", "input_projection.bias"),
-            ("query_embed.weight", "query_position_embeddings.weight"),
-            ("transformer.decoder.norm.weight", "decoder.layernorm.weight"),
-            ("transformer.decoder.norm.bias", "decoder.layernorm.bias"),
-            ("class_embed.weight", "class_labels_classifier.weight"),
-            ("class_embed.bias", "class_labels_classifier.bias"),
-            ("bbox_embed.layers.0.weight", "bbox_predictor.layers.0.weight"),
-            ("bbox_embed.layers.0.bias", "bbox_predictor.layers.0.bias"),
-            ("bbox_embed.layers.1.weight", "bbox_predictor.layers.1.weight"),
-            ("bbox_embed.layers.1.bias", "bbox_predictor.layers.1.bias"),
-            ("bbox_embed.layers.2.weight", "bbox_predictor.layers.2.weight"),
-            ("bbox_embed.layers.2.bias", "bbox_predictor.layers.2.bias"),
-        ]
-    )
-
-    return rename_keys
-
-
-def rename_key(state_dict, old, new):
-    val = state_dict.pop(old)
-    state_dict[new] = val
-
-
-def read_in_q_k_v(state_dict, is_panoptic=False):
-    prefix = ""
-    if is_panoptic:
-        prefix = "detr."
-
-    # first: transformer encoder
-    for i in range(6):
-        # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-    # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
-    for i in range(6):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-        # read in weights + bias of input projection layer of cross-attention
-        in_proj_weight_cross_attn = state_dict.pop(
-            f"{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight"
-        )
-        in_proj_bias_cross_attn = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) of cross-attention to the state dict
-        state_dict[f"decoder.layers.{i}.encoder_attn.q_proj.weight"] = in_proj_weight_cross_attn[:256, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.q_proj.bias"] = in_proj_bias_cross_attn[:256]
-        state_dict[f"decoder.layers.{i}.encoder_attn.k_proj.weight"] = in_proj_weight_cross_attn[256:512, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.k_proj.bias"] = in_proj_bias_cross_attn[256:512]
-        state_dict[f"decoder.layers.{i}.encoder_attn.v_proj.weight"] = in_proj_weight_cross_attn[-256:, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.v_proj.bias"] = in_proj_bias_cross_attn[-256:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-
-    return im
-
-
-@torch.no_grad()
-def convert_detr_checkpoint(model_name, pytorch_dump_folder_path=None, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our DETR structure.
-    """
-
-    # load default config
-    config, is_panoptic = get_detr_config(model_name)
-
-    # load original model from torch hub
-    model_name_to_original_name = {
-        "detr-resnet-50": "detr_resnet50",
-        "detr-resnet-101": "detr_resnet101",
-    }
-    logger.info(f"Converting model {model_name}...")
-    detr = torch.hub.load("facebookresearch/detr", model_name_to_original_name[model_name], pretrained=True).eval()
-    state_dict = detr.state_dict()
-    # rename keys
-    for src, dest in create_rename_keys(config):
-        if is_panoptic:
-            src = "detr." + src
-        rename_key(state_dict, src, dest)
-    # query, key and value matrices need special treatment
-    read_in_q_k_v(state_dict, is_panoptic=is_panoptic)
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    prefix = "detr.model." if is_panoptic else "model."
-    for key in state_dict.copy().keys():
-        if is_panoptic:
-            if (
-                key.startswith("detr")
-                and not key.startswith("class_labels_classifier")
-                and not key.startswith("bbox_predictor")
-            ):
-                val = state_dict.pop(key)
-                state_dict["detr.model" + key[4:]] = val
-            elif "class_labels_classifier" in key or "bbox_predictor" in key:
-                val = state_dict.pop(key)
-                state_dict["detr." + key] = val
-            elif key.startswith("bbox_attention") or key.startswith("mask_head"):
-                continue
-            else:
-                val = state_dict.pop(key)
-                state_dict[prefix + key] = val
-        else:
-            if not key.startswith("class_labels_classifier") and not key.startswith("bbox_predictor"):
-                val = state_dict.pop(key)
-                state_dict[prefix + key] = val
-
-    # finally, create HuggingFace model and load state dict
-    model = DetrForSegmentation(config) if is_panoptic else DetrForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # verify our conversion on an image
-    format = "coco_panoptic" if is_panoptic else "coco_detection"
-    processor = DetrImageProcessor(format=format)
-
-    encoding = processor(images=prepare_img(), return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    original_outputs = detr(pixel_values)
-    outputs = model(pixel_values)
-
-    assert torch.allclose(outputs.logits, original_outputs["pred_logits"], atol=1e-3)
-    assert torch.allclose(outputs.pred_boxes, original_outputs["pred_boxes"], atol=1e-3)
-    if is_panoptic:
-        assert torch.allclose(outputs.pred_masks, original_outputs["pred_masks"], atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        # Save model and image processor
-        logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        # Upload model and image processor to the hub
-        logger.info("Uploading PyTorch model and image processor to the hub...")
-        model.push_to_hub(f"nielsr/{model_name}")
-        processor.push_to_hub(f"nielsr/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--model_name",
-        default="detr-resnet-50",
-        type=str,
-        choices=["detr-resnet-50", "detr-resnet-101"],
-        help="Name of the DETR model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to the hub or not.")
-    args = parser.parse_args()
-    convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/dialogpt/convert_dialogpt_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/dialogpt/convert_dialogpt_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index fbf34012924b..000000000000
--- a/src/transformers/models/dialogpt/convert_dialogpt_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import os
-
-import torch
-
-from transformers.utils import WEIGHTS_NAME
-
-
-DIALOGPT_MODELS = ["small", "medium", "large"]
-
-OLD_KEY = "lm_head.decoder.weight"
-NEW_KEY = "lm_head.weight"
-
-
-def convert_dialogpt_checkpoint(checkpoint_path: str, pytorch_dump_folder_path: str):
-    d = torch.load(checkpoint_path)
-    d[NEW_KEY] = d.pop(OLD_KEY)
-    os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-    torch.save(d, os.path.join(pytorch_dump_folder_path, WEIGHTS_NAME))
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--dialogpt_path", default=".", type=str)
-    args = parser.parse_args()
-    for MODEL in DIALOGPT_MODELS:
-        checkpoint_path = os.path.join(args.dialogpt_path, f"{MODEL}_ft.pkl")
-        pytorch_dump_folder_path = f"./DialoGPT-{MODEL}"
-        convert_dialogpt_checkpoint(
-            checkpoint_path,
-            pytorch_dump_folder_path,
-        )
diff --git a/src/transformers/models/dinov2/convert_dinov2_to_hf.py b/src/transformers/models/dinov2/convert_dinov2_to_hf.py
deleted file mode 100644
index d716191b2fcb..000000000000
--- a/src/transformers/models/dinov2/convert_dinov2_to_hf.py
+++ /dev/null
@@ -1,285 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DINOv2 checkpoints from the original repository.
-
-URL: https://github.com/facebookresearch/dinov2/tree/main
-"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-import torch.nn as nn
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision import transforms
-
-from transformers import BitImageProcessor, Dinov2Config, Dinov2ForImageClassification, Dinov2Model
-from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dinov2_config(model_name, image_classifier=False):
-    config = Dinov2Config(image_size=518, patch_size=14)
-
-    # size of the architecture
-    if "vits" in model_name:
-        config.hidden_size = 384
-        config.num_attention_heads = 6
-    elif "vitb" in model_name:
-        pass
-    elif "vitl" in model_name:
-        config.hidden_size = 1024
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-    elif "vitg" in model_name:
-        config.use_swiglu_ffn = True
-        config.hidden_size = 1536
-        config.num_hidden_layers = 40
-        config.num_attention_heads = 24
-    else:
-        raise ValueError("Model not supported")
-
-    if image_classifier:
-        repo_id = "huggingface/label-files"
-        filename = "imagenet-1k-id2label.json"
-        config.num_labels = 1000
-        config.id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        config.id2label = {int(k): v for k, v in config.id2label.items()}
-
-    return config
-
-
-def create_rename_keys(config):
-    rename_keys = []
-    # fmt: off
-
-    # patch embedding layer
-    rename_keys.append(("cls_token", "embeddings.cls_token"))
-    rename_keys.append(("mask_token", "embeddings.mask_token"))
-    rename_keys.append(("pos_embed", "embeddings.position_embeddings"))
-    rename_keys.append(("patch_embed.proj.weight", "embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("patch_embed.proj.bias", "embeddings.patch_embeddings.projection.bias"))
-
-    for i in range(config.num_hidden_layers):
-        # layernorms
-        rename_keys.append((f"blocks.{i}.norm1.weight", f"encoder.layer.{i}.norm1.weight"))
-        rename_keys.append((f"blocks.{i}.norm1.bias", f"encoder.layer.{i}.norm1.bias"))
-        rename_keys.append((f"blocks.{i}.norm2.weight", f"encoder.layer.{i}.norm2.weight"))
-        rename_keys.append((f"blocks.{i}.norm2.bias", f"encoder.layer.{i}.norm2.bias"))
-        # MLP
-        if config.use_swiglu_ffn:
-            rename_keys.append((f"blocks.{i}.mlp.w12.weight", f"encoder.layer.{i}.mlp.w12.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.w12.bias", f"encoder.layer.{i}.mlp.w12.bias"))
-            rename_keys.append((f"blocks.{i}.mlp.w3.weight", f"encoder.layer.{i}.mlp.w3.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.w3.bias", f"encoder.layer.{i}.mlp.w3.bias"))
-        else:
-            rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"encoder.layer.{i}.mlp.fc1.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"encoder.layer.{i}.mlp.fc1.bias"))
-            rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"encoder.layer.{i}.mlp.fc2.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"encoder.layer.{i}.mlp.fc2.bias"))
-        # layerscale
-        rename_keys.append((f"blocks.{i}.ls1.gamma", f"encoder.layer.{i}.layer_scale1.lambda1"))
-        rename_keys.append((f"blocks.{i}.ls2.gamma", f"encoder.layer.{i}.layer_scale2.lambda1"))
-        # attention projection layer
-        rename_keys.append((f"blocks.{i}.attn.proj.weight", f"encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.attn.proj.bias", f"encoder.layer.{i}.attention.output.dense.bias"))
-
-    # final layernorm
-    rename_keys.append(("norm.weight", "layernorm.weight"))
-    rename_keys.append(("norm.bias", "layernorm.bias"))
-
-    # fmt: on
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    for i in range(config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[: config.hidden_size, :]
-        state_dict[f"encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[-config.hidden_size :, :]
-        state_dict[f"encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-    return image
-
-
-@torch.no_grad()
-def convert_dinov2_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our DINOv2 structure.
-    """
-
-    # define default Dinov2 configuration
-    image_classifier = "1layer" in model_name
-    config = get_dinov2_config(model_name, image_classifier=image_classifier)
-
-    # load original model from torch hub
-    original_model = torch.hub.load("facebookresearch/dinov2", model_name.replace("_1layer", ""))
-    original_model.eval()
-
-    # load state_dict of original model, remove and rename some keys
-    state_dict = original_model.state_dict()
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config)
-
-    for key, val in state_dict.copy().items():
-        val = state_dict.pop(key)
-        if "w12" in key:
-            key = key.replace("w12", "weights_in")
-        if "w3" in key:
-            key = key.replace("w3", "weights_out")
-        state_dict[key] = val
-
-    # load HuggingFace model
-    if image_classifier:
-        model = Dinov2ForImageClassification(config).eval()
-        model.dinov2.load_state_dict(state_dict)
-        model_name_to_classifier_dict_url = {
-            "dinov2_vits14_1layer": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_linear_head.pth",
-            "dinov2_vitb14_1layer": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitb14/dinov2_vitb14_linear_head.pth",
-            "dinov2_vitl14_1layer": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitl14/dinov2_vitl14_linear_head.pth",
-            "dinov2_vitg14_1layer": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_linear_head.pth",
-        }
-        url = model_name_to_classifier_dict_url[model_name]
-        classifier_state_dict = torch.hub.load_state_dict_from_url(url, map_location="cpu")
-        model.classifier.weight = nn.Parameter(classifier_state_dict["weight"])
-        model.classifier.bias = nn.Parameter(classifier_state_dict["bias"])
-    else:
-        model = Dinov2Model(config).eval()
-        model.load_state_dict(state_dict)
-
-    # load image
-    image = prepare_img()
-
-    # preprocess image
-    transformations = transforms.Compose(
-        [
-            transforms.Resize(256, interpolation=transforms.InterpolationMode.BICUBIC),
-            transforms.CenterCrop(224),
-            transforms.ToTensor(),
-            transforms.Normalize(
-                mean=IMAGENET_DEFAULT_MEAN,  # these are RGB mean+std values
-                std=IMAGENET_DEFAULT_STD,  # across a large photo dataset.
-            ),
-        ]
-    )
-
-    original_pixel_values = transformations(image).unsqueeze(0)  # insert batch dimension
-
-    processor = BitImageProcessor(
-        size={"shortest_edge": 256},
-        resample=PILImageResampling.BICUBIC,
-        image_mean=IMAGENET_DEFAULT_MEAN,
-        image_std=IMAGENET_DEFAULT_STD,
-    )
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    assert torch.allclose(original_pixel_values, pixel_values)
-
-    with torch.no_grad():
-        outputs = model(pixel_values, output_hidden_states=True)
-        original_outputs = original_model(pixel_values)
-
-    # assert values
-    if image_classifier:
-        print("Predicted class:")
-        class_idx = outputs.logits.argmax(-1).item()
-        print(model.config.id2label[class_idx])
-    else:
-        assert outputs.last_hidden_state[:, 0].shape == original_outputs.shape
-        assert torch.allclose(outputs.last_hidden_state[:, 0], original_outputs, atol=1e-3)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving image processor to {pytorch_dump_folder_path}")
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model_name_to_hf_name = {
-            "dinov2_vits14": "dinov2-small",
-            "dinov2_vitb14": "dinov2-base",
-            "dinov2_vitl14": "dinov2-large",
-            "dinov2_vitg14": "dinov2-giant",
-            "dinov2_vits14_1layer": "dinov2-small-imagenet1k-1-layer",
-            "dinov2_vitb14_1layer": "dinov2-base-imagenet1k-1-layer",
-            "dinov2_vitl14_1layer": "dinov2-large-imagenet1k-1-layer",
-            "dinov2_vitg14_1layer": "dinov2-giant-imagenet1k-1-layer",
-        }
-
-        name = model_name_to_hf_name[model_name]
-        model.push_to_hub(f"facebook/{name}")
-        processor.push_to_hub(f"facebook/{name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="dinov2_vitb14",
-        type=str,
-        choices=[
-            "dinov2_vits14",
-            "dinov2_vitb14",
-            "dinov2_vitl14",
-            "dinov2_vitg14",
-            "dinov2_vits14_1layer",
-            "dinov2_vitb14_1layer",
-            "dinov2_vitl14_1layer",
-            "dinov2_vitg14_1layer",
-        ],
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_dinov2_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/dinov2_with_registers/convert_dinov2_with_registers_to_hf.py b/src/transformers/models/dinov2_with_registers/convert_dinov2_with_registers_to_hf.py
deleted file mode 100644
index 0ff2697f7466..000000000000
--- a/src/transformers/models/dinov2_with_registers/convert_dinov2_with_registers_to_hf.py
+++ /dev/null
@@ -1,291 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DINOv2 with Registers checkpoints from the original repository.
-
-URL: https://github.com/facebookresearch/dinov2/tree/main
-"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-import torch.nn as nn
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision import transforms
-
-from transformers import (
-    BitImageProcessor,
-    Dinov2WithRegistersConfig,
-    Dinov2WithRegistersForImageClassification,
-    Dinov2WithRegistersModel,
-)
-from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dinov2_with_registers_config(model_name, image_classifier=False):
-    config = Dinov2WithRegistersConfig(image_size=518, patch_size=14)
-
-    # size of the architecture
-    if "vits" in model_name:
-        config.hidden_size = 384
-        config.num_attention_heads = 6
-    elif "vitb" in model_name:
-        pass
-    elif "vitl" in model_name:
-        config.hidden_size = 1024
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-    elif "vitg" in model_name:
-        config.use_swiglu_ffn = True
-        config.hidden_size = 1536
-        config.num_hidden_layers = 40
-        config.num_attention_heads = 24
-    else:
-        raise ValueError("Model not supported")
-
-    if image_classifier:
-        repo_id = "huggingface/label-files"
-        filename = "imagenet-1k-id2label.json"
-        config.num_labels = 1000
-        config.id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        config.id2label = {int(k): v for k, v in config.id2label.items()}
-
-    return config
-
-
-def create_rename_keys(config):
-    rename_keys = []
-    # fmt: off
-
-    # patch embedding layer
-    rename_keys.append(("cls_token", "embeddings.cls_token"))
-    rename_keys.append(("mask_token", "embeddings.mask_token"))
-    rename_keys.append(("pos_embed", "embeddings.position_embeddings"))
-    rename_keys.append(("register_tokens", "embeddings.register_tokens"))
-    rename_keys.append(("patch_embed.proj.weight", "embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("patch_embed.proj.bias", "embeddings.patch_embeddings.projection.bias"))
-
-    for i in range(config.num_hidden_layers):
-        # layernorms
-        rename_keys.append((f"blocks.{i}.norm1.weight", f"encoder.layer.{i}.norm1.weight"))
-        rename_keys.append((f"blocks.{i}.norm1.bias", f"encoder.layer.{i}.norm1.bias"))
-        rename_keys.append((f"blocks.{i}.norm2.weight", f"encoder.layer.{i}.norm2.weight"))
-        rename_keys.append((f"blocks.{i}.norm2.bias", f"encoder.layer.{i}.norm2.bias"))
-        # MLP
-        if config.use_swiglu_ffn:
-            rename_keys.append((f"blocks.{i}.mlp.w12.weight", f"encoder.layer.{i}.mlp.w12.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.w12.bias", f"encoder.layer.{i}.mlp.w12.bias"))
-            rename_keys.append((f"blocks.{i}.mlp.w3.weight", f"encoder.layer.{i}.mlp.w3.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.w3.bias", f"encoder.layer.{i}.mlp.w3.bias"))
-        else:
-            rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"encoder.layer.{i}.mlp.fc1.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"encoder.layer.{i}.mlp.fc1.bias"))
-            rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"encoder.layer.{i}.mlp.fc2.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"encoder.layer.{i}.mlp.fc2.bias"))
-        # layerscale
-        rename_keys.append((f"blocks.{i}.ls1.gamma", f"encoder.layer.{i}.layer_scale1.lambda1"))
-        rename_keys.append((f"blocks.{i}.ls2.gamma", f"encoder.layer.{i}.layer_scale2.lambda1"))
-        # attention projection layer
-        rename_keys.append((f"blocks.{i}.attn.proj.weight", f"encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.attn.proj.bias", f"encoder.layer.{i}.attention.output.dense.bias"))
-
-    # final layernorm
-    rename_keys.append(("norm.weight", "layernorm.weight"))
-    rename_keys.append(("norm.bias", "layernorm.bias"))
-
-    # fmt: on
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    for i in range(config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[: config.hidden_size, :]
-        state_dict[f"encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[-config.hidden_size :, :]
-        state_dict[f"encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-    return image
-
-
-@torch.no_grad()
-def convert_dinov2_with_registers_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our Dinov2WithRegisters structure.
-    """
-
-    # define default Dinov2WithRegisters configuration
-    image_classifier = "1layer" in model_name
-    config = get_dinov2_with_registers_config(model_name, image_classifier=image_classifier)
-
-    # load original model from torch hub
-    original_model = torch.hub.load("facebookresearch/dinov2", model_name.replace("_1layer", ""))
-    original_model.eval()
-
-    # load state_dict of original model, remove and rename some keys
-    state_dict = original_model.state_dict()
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config)
-
-    for key, val in state_dict.copy().items():
-        val = state_dict.pop(key)
-        if "w12" in key:
-            key = key.replace("w12", "weights_in")
-        if "w3" in key:
-            key = key.replace("w3", "weights_out")
-        state_dict[key] = val
-
-    # load HuggingFace model
-    if image_classifier:
-        model = Dinov2WithRegistersForImageClassification(config).eval()
-        model.dinov2_with_registers.load_state_dict(state_dict)
-        model_name_to_classifier_dict_url = {
-            "dinov2_vits14_reg_1layer": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_reg4_linear_head.pth",
-            "dinov2_vitb14_reg_1layer": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitb14/dinov2_vitb14_reg4_linear_head.pth",
-            "dinov2_vitl14_reg_1layer": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitl14/dinov2_vitl14_reg4_linear_head.pth",
-            "dinov2_vitg14_reg_1layer": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_reg4_linear_head.pth",
-        }
-        url = model_name_to_classifier_dict_url[model_name]
-        classifier_state_dict = torch.hub.load_state_dict_from_url(url, map_location="cpu")
-        model.classifier.weight = nn.Parameter(classifier_state_dict["weight"])
-        model.classifier.bias = nn.Parameter(classifier_state_dict["bias"])
-    else:
-        model = Dinov2WithRegistersModel(config).eval()
-        model.load_state_dict(state_dict)
-
-    # load image
-    image = prepare_img()
-
-    # preprocess image
-    transformations = transforms.Compose(
-        [
-            transforms.Resize(256, interpolation=transforms.InterpolationMode.BICUBIC),
-            transforms.CenterCrop(224),
-            transforms.ToTensor(),
-            transforms.Normalize(
-                mean=IMAGENET_DEFAULT_MEAN,  # these are RGB mean+std values
-                std=IMAGENET_DEFAULT_STD,  # across a large photo dataset.
-            ),
-        ]
-    )
-
-    original_pixel_values = transformations(image).unsqueeze(0)  # insert batch dimension
-
-    processor = BitImageProcessor(
-        size={"shortest_edge": 256},
-        resample=PILImageResampling.BICUBIC,
-        image_mean=IMAGENET_DEFAULT_MEAN,
-        image_std=IMAGENET_DEFAULT_STD,
-    )
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    assert torch.allclose(original_pixel_values, pixel_values)
-
-    with torch.no_grad():
-        outputs = model(pixel_values, output_hidden_states=True)
-        original_outputs = original_model(pixel_values)
-
-    # assert values
-    if image_classifier:
-        print("Predicted class:")
-        class_idx = outputs.logits.argmax(-1).item()
-        print(model.config.id2label[class_idx])
-    else:
-        assert outputs.last_hidden_state[:, 0].shape == original_outputs.shape
-        assert torch.allclose(outputs.last_hidden_state[:, 0], original_outputs, atol=1e-3)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving image processor to {pytorch_dump_folder_path}")
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model_name_to_hf_name = {
-            "dinov2_vits14_reg": "dinov2-with-registers-small",
-            "dinov2_vitb14_reg": "dinov2-with-registers-base",
-            "dinov2_vitl14_reg": "dinov2-with-registers-large",
-            "dinov2_vitg14_reg": "dinov2-with-registers-giant",
-            "dinov2_vits14_reg_1layer": "dinov2-with-registers-small-imagenet1k-1-layer",
-            "dinov2_vitb14_reg_1layer": "dinov2-with-registers-base-imagenet1k-1-layer",
-            "dinov2_vitl14_reg_1layer": "dinov2-with-registers-large-imagenet1k-1-layer",
-            "dinov2_vitg14_reg_1layer": "dinov2-with-registers-giant-imagenet1k-1-layer",
-        }
-
-        name = model_name_to_hf_name[model_name]
-        model.push_to_hub(f"nielsr/{name}")
-        processor.push_to_hub(f"nielsr/{name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="dinov2_vits14_reg",
-        type=str,
-        choices=[
-            "dinov2_vits14_reg",
-            "dinov2_vitb14_reg",
-            "dinov2_vitl14_reg",
-            "dinov2_vitg14_reg",
-            "dinov2_vits14_reg_1layer",
-            "dinov2_vitb14_reg_1layer",
-            "dinov2_vitl14_reg_1layer",
-            "dinov2_vitg14_reg_1layer",
-        ],
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_dinov2_with_registers_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/dit/convert_dit_unilm_to_pytorch.py b/src/transformers/models/dit/convert_dit_unilm_to_pytorch.py
deleted file mode 100644
index 40c5b22e3b9a..000000000000
--- a/src/transformers/models/dit/convert_dit_unilm_to_pytorch.py
+++ /dev/null
@@ -1,230 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DiT checkpoints from the unilm repository."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor
-from transformers.image_utils import PILImageResampling
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, has_lm_head=False, is_semantic=False):
-    prefix = "backbone." if is_semantic else ""
-
-    rename_keys = []
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"{prefix}blocks.{i}.norm1.weight", f"beit.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.norm1.bias", f"beit.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.attn.proj.weight", f"beit.encoder.layer.{i}.attention.output.dense.weight")
-        )
-        rename_keys.append(
-            (f"{prefix}blocks.{i}.attn.proj.bias", f"beit.encoder.layer.{i}.attention.output.dense.bias")
-        )
-        rename_keys.append((f"{prefix}blocks.{i}.norm2.weight", f"beit.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.norm2.bias", f"beit.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc1.weight", f"beit.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc1.bias", f"beit.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc2.weight", f"beit.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"{prefix}blocks.{i}.mlp.fc2.bias", f"beit.encoder.layer.{i}.output.dense.bias"))
-
-    # projection layer + position embeddings
-    rename_keys.extend(
-        [
-            (f"{prefix}cls_token", "beit.embeddings.cls_token"),
-            (f"{prefix}patch_embed.proj.weight", "beit.embeddings.patch_embeddings.projection.weight"),
-            (f"{prefix}patch_embed.proj.bias", "beit.embeddings.patch_embeddings.projection.bias"),
-            (f"{prefix}pos_embed", "beit.embeddings.position_embeddings"),
-        ]
-    )
-
-    if has_lm_head:
-        # mask token + layernorm
-        rename_keys.extend(
-            [
-                ("mask_token", "beit.embeddings.mask_token"),
-                ("norm.weight", "layernorm.weight"),
-                ("norm.bias", "layernorm.bias"),
-            ]
-        )
-    else:
-        # layernorm + classification head
-        rename_keys.extend(
-            [
-                ("fc_norm.weight", "beit.pooler.layernorm.weight"),
-                ("fc_norm.bias", "beit.pooler.layernorm.bias"),
-                ("head.weight", "classifier.weight"),
-                ("head.bias", "classifier.bias"),
-            ]
-        )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, has_lm_head=False, is_semantic=False):
-    for i in range(config.num_hidden_layers):
-        prefix = "backbone." if is_semantic else ""
-        # queries, keys and values
-        in_proj_weight = state_dict.pop(f"{prefix}blocks.{i}.attn.qkv.weight")
-        q_bias = state_dict.pop(f"{prefix}blocks.{i}.attn.q_bias")
-        v_bias = state_dict.pop(f"{prefix}blocks.{i}.attn.v_bias")
-
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.query.bias"] = q_bias
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"beit.encoder.layer.{i}.attention.attention.value.bias"] = v_bias
-
-        # gamma_1 and gamma_2
-        # we call them lambda because otherwise they are renamed when using .from_pretrained
-        gamma_1 = state_dict.pop(f"{prefix}blocks.{i}.gamma_1")
-        gamma_2 = state_dict.pop(f"{prefix}blocks.{i}.gamma_2")
-
-        state_dict[f"beit.encoder.layer.{i}.lambda_1"] = gamma_1
-        state_dict[f"beit.encoder.layer.{i}.lambda_2"] = gamma_2
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_dit_checkpoint(checkpoint_url, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our BEiT structure.
-    """
-
-    # define default BEiT configuration
-    has_lm_head = False if "rvlcdip" in checkpoint_url else True
-    config = BeitConfig(use_absolute_position_embeddings=True, use_mask_token=has_lm_head)
-
-    # size of the architecture
-    if "large" in checkpoint_url or "dit-l" in checkpoint_url:
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-
-    # labels
-    if "rvlcdip" in checkpoint_url:
-        config.num_labels = 16
-        repo_id = "huggingface/label-files"
-        filename = "rvlcdip-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    # load state_dict of original model, remove and rename some keys
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["model"]
-
-    rename_keys = create_rename_keys(config, has_lm_head=has_lm_head)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config, has_lm_head=has_lm_head)
-
-    # load HuggingFace model
-    model = BeitForMaskedImageModeling(config) if has_lm_head else BeitForImageClassification(config)
-    model.eval()
-    model.load_state_dict(state_dict)
-
-    # Check outputs on an image
-    image_processor = BeitImageProcessor(
-        size=config.image_size, resample=PILImageResampling.BILINEAR, do_center_crop=False
-    )
-    image = prepare_img()
-
-    encoding = image_processor(images=image, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    outputs = model(pixel_values)
-    logits = outputs.logits
-
-    # verify logits
-    expected_shape = [1, 16] if "rvlcdip" in checkpoint_url else [1, 196, 8192]
-    assert logits.shape == torch.Size(expected_shape), "Shape of logits not as expected"
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        if has_lm_head:
-            model_name = "dit-base" if "base" in checkpoint_url else "dit-large"
-        else:
-            model_name = "dit-base-finetuned-rvlcdip" if "dit-b" in checkpoint_url else "dit-large-finetuned-rvlcdip"
-        image_processor.push_to_hub(
-            repo_path_or_name=Path(pytorch_dump_folder_path, model_name),
-            organization="nielsr",
-            commit_message="Add image processor",
-            use_temp_dir=True,
-        )
-        model.push_to_hub(
-            repo_path_or_name=Path(pytorch_dump_folder_path, model_name),
-            organization="nielsr",
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth",
-        type=str,
-        help="URL to the original PyTorch checkpoint (.pth file).",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-    )
-    args = parser.parse_args()
-    convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/donut/convert_donut_to_pytorch.py b/src/transformers/models/donut/convert_donut_to_pytorch.py
deleted file mode 100644
index f6f14f6d08e3..000000000000
--- a/src/transformers/models/donut/convert_donut_to_pytorch.py
+++ /dev/null
@@ -1,234 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Donut checkpoints using the original `donut-python` library. URL: https://github.com/clovaai/donut"""
-
-import argparse
-
-import torch
-from datasets import load_dataset
-from donut import DonutModel
-
-from transformers import (
-    DonutImageProcessor,
-    DonutProcessor,
-    DonutSwinConfig,
-    DonutSwinModel,
-    MBartConfig,
-    MBartForCausalLM,
-    VisionEncoderDecoderModel,
-    XLMRobertaTokenizerFast,
-)
-
-
-def get_configs(model):
-    original_config = model.config
-
-    encoder_config = DonutSwinConfig(
-        image_size=original_config.input_size,
-        patch_size=4,
-        depths=original_config.encoder_layer,
-        num_heads=[4, 8, 16, 32],
-        window_size=original_config.window_size,
-        embed_dim=128,
-    )
-    decoder_config = MBartConfig(
-        is_decoder=True,
-        is_encoder_decoder=False,
-        add_cross_attention=True,
-        decoder_layers=original_config.decoder_layer,
-        max_position_embeddings=original_config.max_position_embeddings,
-        vocab_size=len(
-            model.decoder.tokenizer
-        ),  # several special tokens are added to the vocab of XLMRobertaTokenizer, see repo on the hub (added_tokens.json)
-        scale_embedding=True,
-        add_final_layer_norm=True,
-    )
-
-    return encoder_config, decoder_config
-
-
-def rename_key(name):
-    if "encoder.model" in name:
-        name = name.replace("encoder.model", "encoder")
-    if "decoder.model" in name:
-        name = name.replace("decoder.model", "decoder")
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "embeddings.norm")
-    if name.startswith("encoder"):
-        if "layers" in name:
-            name = "encoder." + name
-        if "attn.proj" in name:
-            name = name.replace("attn.proj", "attention.output.dense")
-        if "attn" in name and "mask" not in name:
-            name = name.replace("attn", "attention.self")
-        if "norm1" in name:
-            name = name.replace("norm1", "layernorm_before")
-        if "norm2" in name:
-            name = name.replace("norm2", "layernorm_after")
-        if "mlp.fc1" in name:
-            name = name.replace("mlp.fc1", "intermediate.dense")
-        if "mlp.fc2" in name:
-            name = name.replace("mlp.fc2", "output.dense")
-
-        if name == "encoder.norm.weight":
-            name = "encoder.layernorm.weight"
-        if name == "encoder.norm.bias":
-            name = "encoder.layernorm.bias"
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, model):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[3])
-            block_num = int(key_split[5])
-            dim = model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size
-
-            if "weight" in key:
-                orig_state_dict[
-                    f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.weight"
-                ] = val[:dim, :]
-                orig_state_dict[f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.weight"] = (
-                    val[dim : dim * 2, :]
-                )
-                orig_state_dict[
-                    f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.weight"
-                ] = val[-dim:, :]
-            else:
-                orig_state_dict[f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.bias"] = (
-                    val[:dim]
-                )
-                orig_state_dict[f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.bias"] = (
-                    val[dim : dim * 2]
-                )
-                orig_state_dict[f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.bias"] = (
-                    val[-dim:]
-                )
-        elif "attn_mask" in key or key in ["encoder.model.norm.weight", "encoder.model.norm.bias"]:
-            # HuggingFace implementation doesn't use attn_mask buffer
-            # and model doesn't use final LayerNorms for the encoder
-            pass
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-def convert_donut_checkpoint(model_name, pytorch_dump_folder_path=None, push_to_hub=False):
-    # load original model
-    original_model = DonutModel.from_pretrained(model_name).eval()
-
-    # load HuggingFace model
-    encoder_config, decoder_config = get_configs(original_model)
-    encoder = DonutSwinModel(encoder_config)
-    decoder = MBartForCausalLM(decoder_config)
-    model = VisionEncoderDecoderModel(encoder=encoder, decoder=decoder)
-    model.eval()
-
-    state_dict = original_model.state_dict()
-    new_state_dict = convert_state_dict(state_dict, model)
-    model.load_state_dict(new_state_dict)
-
-    # verify results on scanned document
-    dataset = load_dataset("hf-internal-testing/example-documents")  # no-script
-    image = dataset["test"][0]["image"].convert("RGB")
-
-    tokenizer = XLMRobertaTokenizerFast.from_pretrained(model_name, from_slow=True)
-    image_processor = DonutImageProcessor(
-        do_align_long_axis=original_model.config.align_long_axis, size=original_model.config.input_size[::-1]
-    )
-    processor = DonutProcessor(image_processor, tokenizer)
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    if model_name == "naver-clova-ix/donut-base-finetuned-docvqa":
-        task_prompt = "<s_docvqa><s_question>{user_input}</s_question><s_answer>"
-        question = "When is the coffee break?"
-        task_prompt = task_prompt.replace("{user_input}", question)
-    elif model_name == "naver-clova-ix/donut-base-finetuned-rvlcdip":
-        task_prompt = "<s_rvlcdip>"
-    elif model_name in [
-        "naver-clova-ix/donut-base-finetuned-cord-v1",
-        "naver-clova-ix/donut-base-finetuned-cord-v1-2560",
-    ]:
-        task_prompt = "<s_cord>"
-    elif model_name == "naver-clova-ix/donut-base-finetuned-cord-v2":
-        task_prompt = "s_cord-v2>"
-    elif model_name == "naver-clova-ix/donut-base-finetuned-zhtrainticket":
-        task_prompt = "<s_zhtrainticket>"
-    elif model_name in ["naver-clova-ix/donut-proto", "naver-clova-ix/donut-base"]:
-        # use a random prompt
-        task_prompt = "hello world"
-    else:
-        raise ValueError("Model name not supported")
-    prompt_tensors = original_model.decoder.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt")[
-        "input_ids"
-    ]
-
-    original_patch_embed = original_model.encoder.model.patch_embed(pixel_values)
-    patch_embeddings, _ = model.encoder.embeddings(pixel_values)
-    assert torch.allclose(original_patch_embed, patch_embeddings, atol=1e-3)
-
-    # verify encoder hidden states
-    original_last_hidden_state = original_model.encoder(pixel_values)
-    last_hidden_state = model.encoder(pixel_values).last_hidden_state
-    assert torch.allclose(original_last_hidden_state, last_hidden_state, atol=1e-2)
-
-    # verify decoder hidden states
-    original_logits = original_model(pixel_values, prompt_tensors, None).logits
-    logits = model(pixel_values, decoder_input_ids=prompt_tensors).logits
-    assert torch.allclose(original_logits, logits, atol=1e-3)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub("nielsr/" + model_name.split("/")[-1], commit_message="Update model")
-        processor.push_to_hub("nielsr/" + model_name.split("/")[-1], commit_message="Update model")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="naver-clova-ix/donut-base-finetuned-docvqa",
-        required=False,
-        type=str,
-        help="Name of the original model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        required=False,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether or not to push the converted model and processor to the 🤗 hub.",
-    )
-
-    args = parser.parse_args()
-    convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/dpr/convert_dpr_original_checkpoint_to_pytorch.py b/src/transformers/models/dpr/convert_dpr_original_checkpoint_to_pytorch.py
deleted file mode 100644
index d24c2f01db4e..000000000000
--- a/src/transformers/models/dpr/convert_dpr_original_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,143 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import collections
-from pathlib import Path
-
-import torch
-from torch.serialization import default_restore_location
-
-from transformers import BertConfig, DPRConfig, DPRContextEncoder, DPRQuestionEncoder, DPRReader
-
-
-CheckpointState = collections.namedtuple(
-    "CheckpointState", ["model_dict", "optimizer_dict", "scheduler_dict", "offset", "epoch", "encoder_params"]
-)
-
-
-def load_states_from_checkpoint(model_file: str) -> CheckpointState:
-    print(f"Reading saved model from {model_file}")
-    state_dict = torch.load(model_file, map_location=lambda s, l: default_restore_location(s, "cpu"))
-    return CheckpointState(**state_dict)
-
-
-class DPRState:
-    def __init__(self, src_file: Path):
-        self.src_file = src_file
-
-    def load_dpr_model(self):
-        raise NotImplementedError
-
-    @staticmethod
-    def from_type(comp_type: str, *args, **kwargs) -> "DPRState":
-        if comp_type.startswith("c"):
-            return DPRContextEncoderState(*args, **kwargs)
-        if comp_type.startswith("q"):
-            return DPRQuestionEncoderState(*args, **kwargs)
-        if comp_type.startswith("r"):
-            return DPRReaderState(*args, **kwargs)
-        else:
-            raise ValueError("Component type must be either 'ctx_encoder', 'question_encoder' or 'reader'.")
-
-
-class DPRContextEncoderState(DPRState):
-    def load_dpr_model(self):
-        model = DPRContextEncoder(DPRConfig(**BertConfig.get_config_dict("google-bert/bert-base-uncased")[0]))
-        print(f"Loading DPR biencoder from {self.src_file}")
-        saved_state = load_states_from_checkpoint(self.src_file)
-        encoder, prefix = model.ctx_encoder, "ctx_model."
-        # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
-        state_dict = {"bert_model.embeddings.position_ids": model.ctx_encoder.bert_model.embeddings.position_ids}
-        for key, value in saved_state.model_dict.items():
-            if key.startswith(prefix):
-                key = key[len(prefix) :]
-                if not key.startswith("encode_proj."):
-                    key = "bert_model." + key
-                state_dict[key] = value
-        encoder.load_state_dict(state_dict)
-        return model
-
-
-class DPRQuestionEncoderState(DPRState):
-    def load_dpr_model(self):
-        model = DPRQuestionEncoder(DPRConfig(**BertConfig.get_config_dict("google-bert/bert-base-uncased")[0]))
-        print(f"Loading DPR biencoder from {self.src_file}")
-        saved_state = load_states_from_checkpoint(self.src_file)
-        encoder, prefix = model.question_encoder, "question_model."
-        # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
-        state_dict = {"bert_model.embeddings.position_ids": model.question_encoder.bert_model.embeddings.position_ids}
-        for key, value in saved_state.model_dict.items():
-            if key.startswith(prefix):
-                key = key[len(prefix) :]
-                if not key.startswith("encode_proj."):
-                    key = "bert_model." + key
-                state_dict[key] = value
-        encoder.load_state_dict(state_dict)
-        return model
-
-
-class DPRReaderState(DPRState):
-    def load_dpr_model(self):
-        model = DPRReader(DPRConfig(**BertConfig.get_config_dict("google-bert/bert-base-uncased")[0]))
-        print(f"Loading DPR reader from {self.src_file}")
-        saved_state = load_states_from_checkpoint(self.src_file)
-        # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
-        state_dict = {
-            "encoder.bert_model.embeddings.position_ids": model.span_predictor.encoder.bert_model.embeddings.position_ids
-        }
-        for key, value in saved_state.model_dict.items():
-            if key.startswith("encoder.") and not key.startswith("encoder.encode_proj"):
-                key = "encoder.bert_model." + key[len("encoder.") :]
-            state_dict[key] = value
-        model.span_predictor.load_state_dict(state_dict)
-        return model
-
-
-def convert(comp_type: str, src_file: Path, dest_dir: Path):
-    dest_dir = Path(dest_dir)
-    dest_dir.mkdir(exist_ok=True)
-
-    dpr_state = DPRState.from_type(comp_type, src_file=src_file)
-    model = dpr_state.load_dpr_model()
-    model.save_pretrained(dest_dir)
-    model.from_pretrained(dest_dir)  # sanity check
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--type", type=str, help="Type of the component to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
-    )
-    parser.add_argument(
-        "--src",
-        type=str,
-        help=(
-            "Path to the dpr checkpoint file. They can be downloaded from the official DPR repo"
-            " https://github.com/facebookresearch/DPR. Note that in the official repo, both encoders are stored in the"
-            " 'retriever' checkpoints."
-        ),
-    )
-    parser.add_argument("--dest", type=str, default=None, help="Path to the output PyTorch model directory.")
-    args = parser.parse_args()
-
-    src_file = Path(args.src)
-    dest_dir = f"converted-{src_file.name}" if args.dest is None else args.dest
-    dest_dir = Path(dest_dir)
-    assert src_file.exists()
-    assert args.type is not None, (
-        "Please specify the component type of the DPR model to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
-    )
-    convert(args.type, src_file, dest_dir)
diff --git a/src/transformers/models/dpt/convert_dinov2_depth_to_hf.py b/src/transformers/models/dpt/convert_dinov2_depth_to_hf.py
deleted file mode 100644
index 367aff7f90e1..000000000000
--- a/src/transformers/models/dpt/convert_dinov2_depth_to_hf.py
+++ /dev/null
@@ -1,383 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DINOv2 + DPT checkpoints from the original repository. URL:
-https://github.com/facebookresearch/dinov2/tree/main"""
-
-import argparse
-import itertools
-import math
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-from torchvision import transforms
-
-from transformers import Dinov2Config, DPTConfig, DPTForDepthEstimation, DPTImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dpt_config(model_name):
-    if "small" in model_name:
-        # equivalent to stage 3, stage 6, stage 9, stage 12
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-small", out_indices=[3, 6, 9, 12], apply_layernorm=False, reshape_hidden_states=False
-        )
-        neck_hidden_sizes = [48, 96, 192, 384]
-    elif "base" in model_name:
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-base", out_indices=[3, 6, 9, 12], apply_layernorm=False, reshape_hidden_states=False
-        )
-        neck_hidden_sizes = [96, 192, 384, 768]
-    elif "large" in model_name:
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-large", out_indices=[5, 12, 18, 24], apply_layernorm=False, reshape_hidden_states=False
-        )
-        neck_hidden_sizes = [128, 256, 512, 1024]
-    elif "giant" in model_name:
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-giant", out_indices=[10, 20, 30, 40], apply_layernorm=False, reshape_hidden_states=False
-        )
-        neck_hidden_sizes = [192, 384, 768, 1536]
-    else:
-        raise NotImplementedError("To do")
-
-    config = DPTConfig(
-        backbone_config=backbone_config,
-        neck_hidden_sizes=neck_hidden_sizes,
-        use_bias_in_fusion_residual=False,
-        add_projection=True,
-    )
-
-    return config
-
-
-# here we list all DPT keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys_dpt(config):
-    rename_keys = []
-
-    # fmt: off
-    # activation postprocessing (projections, readout projections + resize blocks)
-    for i in range(4):
-        rename_keys.append((f"decode_head.reassemble_blocks.projects.{i}.conv.weight", f"neck.reassemble_stage.layers.{i}.projection.weight"))
-        rename_keys.append((f"decode_head.reassemble_blocks.projects.{i}.conv.bias", f"neck.reassemble_stage.layers.{i}.projection.bias"))
-
-        rename_keys.append((f"decode_head.reassemble_blocks.readout_projects.{i}.0.weight", f"neck.reassemble_stage.readout_projects.{i}.0.weight"))
-        rename_keys.append((f"decode_head.reassemble_blocks.readout_projects.{i}.0.bias", f"neck.reassemble_stage.readout_projects.{i}.0.bias"))
-
-        if i != 2:
-            rename_keys.append((f"decode_head.reassemble_blocks.resize_layers.{i}.weight", f"neck.reassemble_stage.layers.{i}.resize.weight"))
-            rename_keys.append((f"decode_head.reassemble_blocks.resize_layers.{i}.bias", f"neck.reassemble_stage.layers.{i}.resize.bias"))
-
-    # fusion layers
-    for i in range(4):
-        rename_keys.append((f"decode_head.fusion_blocks.{i}.project.conv.weight", f"neck.fusion_stage.layers.{i}.projection.weight"))
-        rename_keys.append((f"decode_head.fusion_blocks.{i}.project.conv.bias", f"neck.fusion_stage.layers.{i}.projection.bias"))
-        if i != 0:
-            rename_keys.append((f"decode_head.fusion_blocks.{i}.res_conv_unit1.conv1.conv.weight", f"neck.fusion_stage.layers.{i}.residual_layer1.convolution1.weight"))
-            rename_keys.append((f"decode_head.fusion_blocks.{i}.res_conv_unit1.conv2.conv.weight", f"neck.fusion_stage.layers.{i}.residual_layer1.convolution2.weight"))
-        rename_keys.append((f"decode_head.fusion_blocks.{i}.res_conv_unit2.conv1.conv.weight", f"neck.fusion_stage.layers.{i}.residual_layer2.convolution1.weight"))
-        rename_keys.append((f"decode_head.fusion_blocks.{i}.res_conv_unit2.conv2.conv.weight", f"neck.fusion_stage.layers.{i}.residual_layer2.convolution2.weight"))
-
-    # neck convolutions
-    for i in range(4):
-        rename_keys.append((f"decode_head.convs.{i}.conv.weight", f"neck.convs.{i}.weight"))
-
-    # head
-    rename_keys.append(("decode_head.project.conv.weight", "head.projection.weight"))
-    rename_keys.append(("decode_head.project.conv.bias", "head.projection.bias"))
-
-    for i in range(0, 5, 2):
-        rename_keys.append((f"decode_head.conv_depth.head.{i}.weight", f"head.head.{i}.weight"))
-        rename_keys.append((f"decode_head.conv_depth.head.{i}.bias", f"head.head.{i}.bias"))
-    # fmt: on
-
-    return rename_keys
-
-
-# here we list all backbone keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys_backbone(config):
-    rename_keys = []
-
-    # fmt: off
-    # patch embedding layer
-    rename_keys.append(("cls_token", "backbone.embeddings.cls_token"))
-    rename_keys.append(("mask_token", "backbone.embeddings.mask_token"))
-    rename_keys.append(("pos_embed", "backbone.embeddings.position_embeddings"))
-    rename_keys.append(("patch_embed.proj.weight", "backbone.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("patch_embed.proj.bias", "backbone.embeddings.patch_embeddings.projection.bias"))
-
-    # Transfomer encoder
-    for i in range(config.backbone_config.num_hidden_layers):
-        # layernorms
-        rename_keys.append((f"blocks.{i}.norm1.weight", f"backbone.encoder.layer.{i}.norm1.weight"))
-        rename_keys.append((f"blocks.{i}.norm1.bias", f"backbone.encoder.layer.{i}.norm1.bias"))
-        rename_keys.append((f"blocks.{i}.norm2.weight", f"backbone.encoder.layer.{i}.norm2.weight"))
-        rename_keys.append((f"blocks.{i}.norm2.bias", f"backbone.encoder.layer.{i}.norm2.bias"))
-        # MLP
-        if config.backbone_config.use_swiglu_ffn:
-            rename_keys.append((f"blocks.{i}.mlp.w12.weight", f"backbone.encoder.layer.{i}.mlp.w12.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.w12.bias", f"backbone.encoder.layer.{i}.mlp.w12.bias"))
-            rename_keys.append((f"blocks.{i}.mlp.w3.weight", f"backbone.encoder.layer.{i}.mlp.w3.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.w3.bias", f"backbone.encoder.layer.{i}.mlp.w3.bias"))
-        else:
-            rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"backbone.encoder.layer.{i}.mlp.fc1.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"backbone.encoder.layer.{i}.mlp.fc1.bias"))
-            rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"backbone.encoder.layer.{i}.mlp.fc2.weight"))
-            rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"backbone.encoder.layer.{i}.mlp.fc2.bias"))
-        # layerscale
-        rename_keys.append((f"blocks.{i}.ls1.gamma", f"backbone.encoder.layer.{i}.layer_scale1.lambda1"))
-        rename_keys.append((f"blocks.{i}.ls2.gamma", f"backbone.encoder.layer.{i}.layer_scale2.lambda1"))
-        # attention projection layer
-        rename_keys.append((f"blocks.{i}.attn.proj.weight", f"backbone.encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.attn.proj.bias", f"backbone.encoder.layer.{i}.attention.output.dense.bias"))
-    # fmt: on
-
-    rename_keys.append(("norm.weight", "backbone.layernorm.weight"))
-    rename_keys.append(("norm.bias", "backbone.layernorm.bias"))
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    for i in range(config.backbone_config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        hidden_size = config.backbone_config.hidden_size
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[:hidden_size, :]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[:hidden_size]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            hidden_size : hidden_size * 2
-        ]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[-hidden_size:, :]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-hidden_size:]
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "https://dl.fbaipublicfiles.com/dinov2/images/example.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-name_to_url = {
-    "dpt-dinov2-small-nyu": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_nyu_dpt_head.pth",
-    "dpt-dinov2-small-kitti": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_kitti_dpt_head.pth",
-    "dpt-dinov2-base-nyu": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitb14/dinov2_vitb14_nyu_dpt_head.pth",
-    "dpt-dinov2-base-kitti": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitb14/dinov2_vitb14_kitti_dpt_head.pth",
-    "dpt-dinov2-large-nyu": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitl14/dinov2_vitl14_nyu_dpt_head.pth",
-    "dpt-dinov2-large-kitti": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitl14/dinov2_vitl14_kitti_dpt_head.pth",
-    "dpt-dinov2-giant-nyu": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_nyu_dpt_head.pth",
-    "dpt-dinov2-giant-kitti": "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_kitti_dpt_head.pth",
-}
-
-
-def get_original_pixel_values(image):
-    class CenterPadding:
-        def __init__(self, multiple):
-            super().__init__()
-            self.multiple = multiple
-
-        def _get_pad(self, size):
-            new_size = math.ceil(size / self.multiple) * self.multiple
-            pad_size = new_size - size
-            pad_size_left = pad_size // 2
-            pad_size_right = pad_size - pad_size_left
-            return pad_size_left, pad_size_right
-
-        def __call__(self, img):
-            pads = list(itertools.chain.from_iterable(self._get_pad(m) for m in img.shape[-2:][::-1]))
-            output = torch.nn.functional.pad(img, pads)
-            return output
-
-        def __repr__(self):
-            return self.__class__.__name__ + "()"
-
-    def make_depth_transform() -> transforms.Compose:
-        return transforms.Compose(
-            [
-                transforms.ToTensor(),
-                lambda x: 255.0 * x[:3],  # Discard alpha component and scale by 255
-                transforms.Normalize(
-                    mean=(123.675, 116.28, 103.53),
-                    std=(58.395, 57.12, 57.375),
-                ),
-                CenterPadding(multiple=14),
-            ]
-        )
-
-    transform = make_depth_transform()
-    original_pixel_values = transform(image).unsqueeze(0)
-
-    return original_pixel_values
-
-
-@torch.no_grad()
-def convert_dpt_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub, verify_logits):
-    """
-    Copy/paste/tweak model's weights to our DPT structure.
-    """
-
-    # define DPT configuration based on URL
-    checkpoint_url = name_to_url[model_name]
-    config = get_dpt_config(model_name)
-
-    # load original DPT state_dict from URL
-    print("URL:", checkpoint_url)
-    dpt_state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["state_dict"]
-    # rename keys
-    rename_keys = create_rename_keys_dpt(config)
-    for src, dest in rename_keys:
-        rename_key(dpt_state_dict, src, dest)
-
-    # load original backbone state_dict from URL
-    if "small" in model_name:
-        original_model = torch.hub.load("facebookresearch/dinov2", "dinov2_vits14")
-    elif "base" in model_name:
-        original_model = torch.hub.load("facebookresearch/dinov2", "dinov2_vitb14")
-    elif "large" in model_name:
-        original_model = torch.hub.load("facebookresearch/dinov2", "dinov2_vitl14")
-    elif "giant" in model_name:
-        original_model = torch.hub.load("facebookresearch/dinov2", "dinov2_vitg14")
-    else:
-        raise NotImplementedError("To do")
-    original_model.eval()
-    backbone_state_dict = original_model.state_dict()
-
-    # rename keys
-    rename_keys = create_rename_keys_backbone(config)
-    for src, dest in rename_keys:
-        rename_key(backbone_state_dict, src, dest)
-
-    # read in qkv matrices
-    read_in_q_k_v(backbone_state_dict, config)
-
-    for key, val in backbone_state_dict.copy().items():
-        val = backbone_state_dict.pop(key)
-        if "w12" in key:
-            key = key.replace("w12", "weights_in")
-        if "w3" in key:
-            key = key.replace("w3", "weights_out")
-        backbone_state_dict[key] = val
-
-    # merge state_dicts
-    state_dict = {**backbone_state_dict, **dpt_state_dict}
-
-    # load HuggingFace model
-    model = DPTForDepthEstimation(config)
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-    assert missing_keys == [
-        "neck.fusion_stage.layers.0.residual_layer1.convolution1.weight",
-        "neck.fusion_stage.layers.0.residual_layer1.convolution2.weight",
-    ]
-    model.eval()
-
-    # Verify image processor
-    processor = DPTImageProcessor(
-        do_resize=False,
-        do_rescale=False,
-        do_pad=True,
-        size_divisor=14,
-        do_normalize=True,
-        image_mean=(123.675, 116.28, 103.53),
-        image_std=(58.395, 57.12, 57.375),
-    )
-
-    image = prepare_img()
-    pixel_values = processor(image, return_tensors="pt").pixel_values.float()
-    original_pixel_values = get_original_pixel_values(image)
-
-    assert torch.allclose(pixel_values, original_pixel_values)
-
-    # Verify forward pass
-    with torch.no_grad():
-        outputs = model(pixel_values)
-
-    predicted_depth = outputs.predicted_depth
-
-    print("Shape of predicted depth:", predicted_depth.shape)
-    print("First values of predicted depth:", predicted_depth[0, :3, :3])
-
-    # assert logits
-    if verify_logits:
-        if model_name == "dpt-dinov2-small-nyu":
-            expected_shape = torch.Size([1, 576, 736])
-            expected_slice = torch.tensor(
-                [[3.3576, 3.4741, 3.4345], [3.4324, 3.5012, 3.2775], [3.2560, 3.3563, 3.2354]]
-            )
-
-        assert predicted_depth.shape == torch.Size(expected_shape)
-        assert torch.allclose(predicted_depth[0, :3, :3], expected_slice, atol=1e-5)
-        print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model and processor to hub...")
-        model.push_to_hub(repo_id=f"facebook/{model_name}")
-        processor.push_to_hub(repo_id=f"facebook/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="dpt-dinov2-small-nyu",
-        type=str,
-        choices=name_to_url.keys(),
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model to the hub after conversion.",
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_true",
-        required=False,
-        help="Path to the output PyTorch model directory.",
-    )
-
-    args = parser.parse_args()
-    convert_dpt_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.verify_logits)
diff --git a/src/transformers/models/dpt/convert_dpt_beit_to_hf.py b/src/transformers/models/dpt/convert_dpt_beit_to_hf.py
deleted file mode 100644
index 3a576d772f57..000000000000
--- a/src/transformers/models/dpt/convert_dpt_beit_to_hf.py
+++ /dev/null
@@ -1,305 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DPT 3.1 checkpoints from the MiDaS repository. URL: https://github.com/isl-org/MiDaS"""
-
-import argparse
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import BeitConfig, DPTConfig, DPTForDepthEstimation, DPTImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dpt_config(model_name):
-    hidden_size = 768
-    num_hidden_layers = 12
-    num_attention_heads = 12
-    intermediate_size = 3072
-    out_features = ["stage3", "stage6", "stage9", "stage12"]  # beit-base-384 uses [2, 5, 8, 11]
-
-    if "large" in model_name:
-        hidden_size = 1024
-        num_hidden_layers = 24
-        num_attention_heads = 16
-        intermediate_size = 4096
-        out_features = ["stage6", "stage12", "stage18", "stage24"]  # beit-large-512 uses [5, 11, 17, 23]
-
-    if "512" in model_name:
-        image_size = 512
-    elif "384" in model_name:
-        image_size = 384
-    else:
-        raise ValueError("Model not supported")
-
-    backbone_config = BeitConfig(
-        image_size=image_size,
-        num_hidden_layers=num_hidden_layers,
-        hidden_size=hidden_size,
-        intermediate_size=intermediate_size,
-        num_attention_heads=num_attention_heads,
-        use_relative_position_bias=True,
-        reshape_hidden_states=False,
-        out_features=out_features,
-    )
-
-    neck_hidden_sizes = [256, 512, 1024, 1024] if "large" in model_name else [96, 192, 384, 768]
-    config = DPTConfig(backbone_config=backbone_config, neck_hidden_sizes=neck_hidden_sizes)
-
-    return config, image_size
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-
-    # fmt: off
-    # stem
-    rename_keys.append(("pretrained.model.cls_token", "backbone.embeddings.cls_token"))
-    rename_keys.append(("pretrained.model.patch_embed.proj.weight", "backbone.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("pretrained.model.patch_embed.proj.bias", "backbone.embeddings.patch_embeddings.projection.bias"))
-
-    # Transfomer encoder
-    for i in range(config.backbone_config.num_hidden_layers):
-        rename_keys.append((f"pretrained.model.blocks.{i}.gamma_1", f"backbone.encoder.layer.{i}.lambda_1"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.gamma_2", f"backbone.encoder.layer.{i}.lambda_2"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.norm1.weight", f"backbone.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.norm1.bias", f"backbone.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.norm2.weight", f"backbone.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.norm2.bias", f"backbone.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.mlp.fc1.weight", f"backbone.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.mlp.fc1.bias", f"backbone.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.mlp.fc2.weight", f"backbone.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.mlp.fc2.bias", f"backbone.encoder.layer.{i}.output.dense.bias"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.attn.proj.weight", f"backbone.encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.attn.proj.bias", f"backbone.encoder.layer.{i}.attention.output.dense.bias"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.attn.relative_position_bias_table", f"backbone.encoder.layer.{i}.attention.attention.relative_position_bias.relative_position_bias_table"))
-        rename_keys.append((f"pretrained.model.blocks.{i}.attn.relative_position_index", f"backbone.encoder.layer.{i}.attention.attention.relative_position_bias.relative_position_index"))
-
-    # activation postprocessing (readout projections + resize blocks)
-    for i in range(4):
-        rename_keys.append((f"pretrained.act_postprocess{i+1}.0.project.0.weight", f"neck.reassemble_stage.readout_projects.{i}.0.weight"))
-        rename_keys.append((f"pretrained.act_postprocess{i+1}.0.project.0.bias", f"neck.reassemble_stage.readout_projects.{i}.0.bias"))
-
-        rename_keys.append((f"pretrained.act_postprocess{i+1}.3.weight", f"neck.reassemble_stage.layers.{i}.projection.weight"))
-        rename_keys.append((f"pretrained.act_postprocess{i+1}.3.bias", f"neck.reassemble_stage.layers.{i}.projection.bias"))
-
-        if i != 2:
-            rename_keys.append((f"pretrained.act_postprocess{i+1}.4.weight", f"neck.reassemble_stage.layers.{i}.resize.weight"))
-            rename_keys.append((f"pretrained.act_postprocess{i+1}.4.bias", f"neck.reassemble_stage.layers.{i}.resize.bias"))
-
-    # refinenet (tricky here)
-    mapping = {1:3, 2:2, 3:1, 4:0}
-
-    for i in range(1, 5):
-        j = mapping[i]
-        rename_keys.append((f"scratch.refinenet{i}.out_conv.weight", f"neck.fusion_stage.layers.{j}.projection.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.out_conv.bias", f"neck.fusion_stage.layers.{j}.projection.bias"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit1.conv1.weight", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution1.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit1.conv1.bias", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution1.bias"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit1.conv2.weight", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution2.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit1.conv2.bias", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution2.bias"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit2.conv1.weight", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution1.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit2.conv1.bias", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution1.bias"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit2.conv2.weight", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution2.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit2.conv2.bias", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution2.bias"))
-
-    # scratch convolutions
-    for i in range(4):
-        rename_keys.append((f"scratch.layer{i+1}_rn.weight", f"neck.convs.{i}.weight"))
-
-    # head
-    for i in range(0, 5, 2):
-        rename_keys.append((f"scratch.output_conv.{i}.weight", f"head.head.{i}.weight"))
-        rename_keys.append((f"scratch.output_conv.{i}.bias", f"head.head.{i}.bias"))
-
-    return rename_keys
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = ["pretrained.model.head.weight", "pretrained.model.head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    hidden_size = config.backbone_config.hidden_size
-    for i in range(config.backbone_config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"pretrained.model.blocks.{i}.attn.qkv.weight")
-        q_bias = state_dict.pop(f"pretrained.model.blocks.{i}.attn.q_bias")
-        v_bias = state_dict.pop(f"pretrained.model.blocks.{i}.attn.v_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[:hidden_size, :]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.query.bias"] = q_bias
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[-hidden_size:, :]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.value.bias"] = v_bias
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_dpt_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our DPT structure.
-    """
-
-    name_to_url = {
-        "dpt-beit-large-512": "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_beit_large_512.pt",
-        "dpt-beit-large-384": "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_beit_large_384.pt",
-        "dpt-beit-base-384": "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_beit_base_384.pt",
-    }
-
-    # define DPT configuration based on URL
-    checkpoint_url = name_to_url[model_name]
-    config, image_size = get_dpt_config(model_name)
-    # load original state_dict from URL
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
-    # remove certain keys
-    remove_ignore_keys_(state_dict)
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    # read in qkv matrices
-    read_in_q_k_v(state_dict, config)
-
-    # load HuggingFace model
-    model = DPTForDepthEstimation(config)
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-    assert missing_keys == []
-    # assert unexpected_keys == ["pretrained.model.fc_norm.weight", "pretrained.model.fc_norm.bias"]
-    model.eval()
-
-    # Check outputs on an image
-    # We set `keep_aspect_ratio=False` as our current BEiT does not support arbitrary window sizes
-    processor = DPTImageProcessor(
-        size={"height": image_size, "width": image_size}, keep_aspect_ratio=False, ensure_multiple_of=32
-    )
-
-    image = prepare_img()
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    print("First values of pixel values:", pixel_values[0, 0, :3, :3])
-    print("Mean of pixel values:", pixel_values.mean().item())
-    print("Shape of pixel values:", pixel_values.shape)
-
-    import requests
-    from PIL import Image
-    from torchvision import transforms
-
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-
-    transforms = transforms.Compose(
-        [
-            transforms.Resize((image_size, image_size)),
-            transforms.ToTensor(),
-        ]
-    )
-    pixel_values = transforms(image).unsqueeze(0)
-
-    # forward pass
-    with torch.no_grad():
-        outputs = model(pixel_values)
-
-    predicted_depth = outputs.predicted_depth
-
-    print("Shape of predicted depth:", predicted_depth.shape)
-    print("First values of predicted depth:", predicted_depth[0, :3, :3])
-
-    # assert logits
-    # TODO there's still a small difference with the original logits
-    if model_name == "dpt-beit-large-512":
-        # OK, checked
-        expected_shape = torch.Size([1, 512, 512])
-        expected_slice = torch.tensor(
-            [[2804.6260, 2792.5708, 2812.9263], [2772.0288, 2780.1118, 2796.2529], [2748.1094, 2766.6558, 2766.9834]]
-        )
-    elif model_name == "dpt-beit-large-384":
-        # OK, checked
-        expected_shape = torch.Size([1, 384, 384])
-        expected_slice = torch.tensor(
-            [[1783.2273, 1780.5729, 1792.6453], [1759.9817, 1765.5359, 1778.5002], [1739.1633, 1754.7903, 1757.1990]],
-        )
-    elif model_name == "dpt-beit-base-384":
-        # OK, checked
-        expected_shape = torch.Size([1, 384, 384])
-        expected_slice = torch.tensor(
-            [[2898.4482, 2891.3750, 2904.8079], [2858.6685, 2877.2615, 2894.4507], [2842.1235, 2854.1023, 2861.6328]],
-        )
-
-    assert predicted_depth.shape == torch.Size(expected_shape)
-    assert torch.allclose(predicted_depth[0, :3, :3], expected_slice)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model and processor to hub...")
-        model.push_to_hub(repo_id=f"nielsr/{model_name}")
-        processor.push_to_hub(repo_id=f"nielsr/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="dpt-beit-large-512",
-        type=str,
-        choices=["dpt-beit-large-512", "dpt-beit-large-384", "dpt-beit-base-384"],
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model to the hub after conversion.",
-    )
-
-    args = parser.parse_args()
-    convert_dpt_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/dpt/convert_dpt_hybrid_to_pytorch.py b/src/transformers/models/dpt/convert_dpt_hybrid_to_pytorch.py
deleted file mode 100644
index d7dc6d104f40..000000000000
--- a/src/transformers/models/dpt/convert_dpt_hybrid_to_pytorch.py
+++ /dev/null
@@ -1,315 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DPT checkpoints from the original repository. URL: https://github.com/isl-org/DPT"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DPTConfig, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dpt_config(checkpoint_url):
-    config = DPTConfig(embedding_type="hybrid")
-
-    if "large" in checkpoint_url:
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-        config.backbone_out_indices = [5, 11, 17, 23]
-        config.neck_hidden_sizes = [256, 512, 1024, 1024]
-        expected_shape = (1, 384, 384)
-
-    if "nyu" in checkpoint_url or "midas" in checkpoint_url:
-        config.hidden_size = 768
-        config.reassemble_factors = [1, 1, 1, 0.5]
-        config.neck_hidden_sizes = [256, 512, 768, 768]
-        config.num_labels = 150
-        config.patch_size = 16
-        expected_shape = (1, 384, 384)
-        config.use_batch_norm_in_fusion_residual = False
-        config.readout_type = "project"
-
-    if "ade" in checkpoint_url:
-        config.use_batch_norm_in_fusion_residual = True
-        config.hidden_size = 768
-        config.reassemble_stage = [1, 1, 1, 0.5]
-        config.num_labels = 150
-        config.patch_size = 16
-        repo_id = "huggingface/label-files"
-        filename = "ade20k-id2label.json"
-        id2label = json.loads(Path(hf_hub_download(repo_id, filename, repo_type="dataset")).read_text())
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-        expected_shape = [1, 150, 480, 480]
-
-    return config, expected_shape
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = ["pretrained.model.head.weight", "pretrained.model.head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(name):
-    if (
-        "pretrained.model" in name
-        and "cls_token" not in name
-        and "pos_embed" not in name
-        and "patch_embed" not in name
-    ):
-        name = name.replace("pretrained.model", "dpt.encoder")
-    if "pretrained.model" in name:
-        name = name.replace("pretrained.model", "dpt.embeddings")
-    if "patch_embed" in name:
-        name = name.replace("patch_embed", "")
-    if "pos_embed" in name:
-        name = name.replace("pos_embed", "position_embeddings")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "proj" in name and "project" not in name:
-        name = name.replace("proj", "projection")
-    if "blocks" in name:
-        name = name.replace("blocks", "layer")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "norm1" in name and "backbone" not in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name and "backbone" not in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "scratch.output_conv" in name:
-        name = name.replace("scratch.output_conv", "head")
-    if "scratch" in name:
-        name = name.replace("scratch", "neck")
-    if "layer1_rn" in name:
-        name = name.replace("layer1_rn", "convs.0")
-    if "layer2_rn" in name:
-        name = name.replace("layer2_rn", "convs.1")
-    if "layer3_rn" in name:
-        name = name.replace("layer3_rn", "convs.2")
-    if "layer4_rn" in name:
-        name = name.replace("layer4_rn", "convs.3")
-    if "refinenet" in name:
-        layer_idx = int(name[len("neck.refinenet") : len("neck.refinenet") + 1])
-        # tricky here: we need to map 4 to 0, 3 to 1, 2 to 2 and 1 to 3
-        name = name.replace(f"refinenet{layer_idx}", f"fusion_stage.layers.{abs(layer_idx - 4)}")
-    if "out_conv" in name:
-        name = name.replace("out_conv", "projection")
-    if "resConfUnit1" in name:
-        name = name.replace("resConfUnit1", "residual_layer1")
-    if "resConfUnit2" in name:
-        name = name.replace("resConfUnit2", "residual_layer2")
-    if "conv1" in name:
-        name = name.replace("conv1", "convolution1")
-    if "conv2" in name:
-        name = name.replace("conv2", "convolution2")
-    # readout blocks
-    if "pretrained.act_postprocess1.0.project.0" in name:
-        name = name.replace("pretrained.act_postprocess1.0.project.0", "neck.reassemble_stage.readout_projects.0.0")
-    if "pretrained.act_postprocess2.0.project.0" in name:
-        name = name.replace("pretrained.act_postprocess2.0.project.0", "neck.reassemble_stage.readout_projects.1.0")
-    if "pretrained.act_postprocess3.0.project.0" in name:
-        name = name.replace("pretrained.act_postprocess3.0.project.0", "neck.reassemble_stage.readout_projects.2.0")
-    if "pretrained.act_postprocess4.0.project.0" in name:
-        name = name.replace("pretrained.act_postprocess4.0.project.0", "neck.reassemble_stage.readout_projects.3.0")
-
-    # resize blocks
-    if "pretrained.act_postprocess1.3" in name:
-        name = name.replace("pretrained.act_postprocess1.3", "neck.reassemble_stage.layers.0.projection")
-    if "pretrained.act_postprocess1.4" in name:
-        name = name.replace("pretrained.act_postprocess1.4", "neck.reassemble_stage.layers.0.resize")
-    if "pretrained.act_postprocess2.3" in name:
-        name = name.replace("pretrained.act_postprocess2.3", "neck.reassemble_stage.layers.1.projection")
-    if "pretrained.act_postprocess2.4" in name:
-        name = name.replace("pretrained.act_postprocess2.4", "neck.reassemble_stage.layers.1.resize")
-    if "pretrained.act_postprocess3.3" in name:
-        name = name.replace("pretrained.act_postprocess3.3", "neck.reassemble_stage.layers.2.projection")
-    if "pretrained.act_postprocess4.3" in name:
-        name = name.replace("pretrained.act_postprocess4.3", "neck.reassemble_stage.layers.3.projection")
-    if "pretrained.act_postprocess4.4" in name:
-        name = name.replace("pretrained.act_postprocess4.4", "neck.reassemble_stage.layers.3.resize")
-    if "pretrained" in name:
-        name = name.replace("pretrained", "dpt")
-    if "bn" in name:
-        name = name.replace("bn", "batch_norm")
-    if "head" in name:
-        name = name.replace("head", "head.head")
-    if "encoder.norm" in name:
-        name = name.replace("encoder.norm", "layernorm")
-    if "auxlayer" in name:
-        name = name.replace("auxlayer", "auxiliary_head.head")
-    if "backbone" in name:
-        name = name.replace("backbone", "backbone.bit.encoder")
-
-    if ".." in name:
-        name = name.replace("..", ".")
-
-    if "stem.conv" in name:
-        name = name.replace("stem.conv", "bit.embedder.convolution")
-    if "blocks" in name:
-        name = name.replace("blocks", "layers")
-    if "convolution" in name and "backbone" in name:
-        name = name.replace("convolution", "conv")
-    if "layer" in name and "backbone" in name:
-        name = name.replace("layer", "layers")
-    if "backbone.bit.encoder.bit" in name:
-        name = name.replace("backbone.bit.encoder.bit", "backbone.bit")
-    if "embedder.conv" in name:
-        name = name.replace("embedder.conv", "embedder.convolution")
-    if "backbone.bit.encoder.stem.norm" in name:
-        name = name.replace("backbone.bit.encoder.stem.norm", "backbone.bit.embedder.norm")
-    return name
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    for i in range(config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"dpt.encoder.layer.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"dpt.encoder.layer.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[: config.hidden_size, :]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_dpt_checkpoint(checkpoint_url, pytorch_dump_folder_path, push_to_hub, model_name, show_prediction):
-    """
-    Copy/paste/tweak model's weights to our DPT structure.
-    """
-
-    # define DPT configuration based on URL
-    config, expected_shape = get_dpt_config(checkpoint_url)
-    # load original state_dict from URL
-    # state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
-    state_dict = torch.load(checkpoint_url, map_location="cpu")
-    # remove certain keys
-    remove_ignore_keys_(state_dict)
-    # rename keys
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        state_dict[rename_key(key)] = val
-    # read in qkv matrices
-    read_in_q_k_v(state_dict, config)
-
-    # load HuggingFace model
-    model = DPTForSemanticSegmentation(config) if "ade" in checkpoint_url else DPTForDepthEstimation(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # Check outputs on an image
-    size = 480 if "ade" in checkpoint_url else 384
-    image_processor = DPTImageProcessor(size=size)
-
-    image = prepare_img()
-    encoding = image_processor(image, return_tensors="pt")
-
-    # forward pass
-    outputs = model(**encoding).logits if "ade" in checkpoint_url else model(**encoding).predicted_depth
-
-    if show_prediction:
-        prediction = (
-            torch.nn.functional.interpolate(
-                outputs.unsqueeze(1),
-                size=(image.size[1], image.size[0]),
-                mode="bicubic",
-                align_corners=False,
-            )
-            .squeeze()
-            .cpu()
-            .numpy()
-        )
-
-        Image.fromarray((prediction / prediction.max()) * 255).show()
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving image processor to {pytorch_dump_folder_path}")
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub("ybelkada/dpt-hybrid-midas")
-        image_processor.push_to_hub("ybelkada/dpt-hybrid-midas")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://github.com/intel-isl/DPT/releases/download/1_0/dpt_large-midas-2f21e586.pt",
-        type=str,
-        help="URL of the original DPT checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=False,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-    )
-    parser.add_argument(
-        "--model_name",
-        default="dpt-large",
-        type=str,
-        help="Name of the model, in case you're pushing to the hub.",
-    )
-    parser.add_argument(
-        "--show_prediction",
-        action="store_true",
-    )
-
-    args = parser.parse_args()
-    convert_dpt_checkpoint(
-        args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name, args.show_prediction
-    )
diff --git a/src/transformers/models/dpt/convert_dpt_swinv2_to_hf.py b/src/transformers/models/dpt/convert_dpt_swinv2_to_hf.py
deleted file mode 100644
index 0feebe72d474..000000000000
--- a/src/transformers/models/dpt/convert_dpt_swinv2_to_hf.py
+++ /dev/null
@@ -1,321 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DPT 3.1 checkpoints from the MiDaS repository. URL: https://github.com/isl-org/MiDaS"""
-
-import argparse
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import DPTConfig, DPTForDepthEstimation, DPTImageProcessor, Swinv2Config
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dpt_config(model_name):
-    if "tiny" in model_name:
-        embed_dim = 96
-        depths = (2, 2, 6, 2)
-        num_heads = (3, 6, 12, 24)
-        window_size = 16
-        # note: for Swinv2-tiny authors used the window_size = 16 variant
-        # as seen here: https://github.com/isl-org/MiDaS/blob/bdc4ed64c095e026dc0a2f17cabb14d58263decb/midas/backbones/swin2.py#L26
-        pretrained_window_sizes = (0, 0, 0, 0)
-    elif "base" in model_name:
-        embed_dim = 128
-        depths = (2, 2, 18, 2)
-        num_heads = (4, 8, 16, 32)
-        window_size = 24
-        pretrained_window_sizes = (12, 12, 12, 6)
-    elif "large" in model_name:
-        embed_dim = 192
-        depths = (2, 2, 18, 2)
-        num_heads = (6, 12, 24, 48)
-        window_size = 24
-        pretrained_window_sizes = (12, 12, 12, 6)
-
-    if "384" in model_name:
-        image_size = 384
-    elif "256" in model_name:
-        image_size = 256
-    else:
-        raise ValueError("Model not supported, to do")
-
-    backbone_config = Swinv2Config(
-        image_size=image_size,
-        embed_dim=embed_dim,
-        depths=depths,
-        window_size=window_size,
-        pretrained_window_sizes=pretrained_window_sizes,
-        num_heads=num_heads,
-        out_features=["stage1", "stage2", "stage3", "stage4"],
-    )
-
-    if model_name == "dpt-swinv2-tiny-256":
-        neck_hidden_sizes = [96, 192, 384, 768]
-    elif model_name == "dpt-swinv2-base-384":
-        neck_hidden_sizes = [128, 256, 512, 1024]
-    elif model_name == "dpt-swinv2-large-384":
-        neck_hidden_sizes = [192, 384, 768, 1536]
-
-    config = DPTConfig(backbone_config=backbone_config, neck_hidden_sizes=neck_hidden_sizes)
-
-    return config, image_size
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-
-    # fmt: off
-    # stem
-    rename_keys.append(("pretrained.model.patch_embed.proj.weight", "backbone.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("pretrained.model.patch_embed.proj.bias", "backbone.embeddings.patch_embeddings.projection.bias"))
-    rename_keys.append(("pretrained.model.patch_embed.norm.weight", "backbone.embeddings.norm.weight"))
-    rename_keys.append(("pretrained.model.patch_embed.norm.bias", "backbone.embeddings.norm.bias"))
-
-    # transformer encoder
-    for i in range(len(config.backbone_config.depths)):
-        for j in range(config.backbone_config.depths[i]):
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.attn.logit_scale", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.logit_scale"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.attn.cpb_mlp.0.weight", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.continuous_position_bias_mlp.0.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.attn.cpb_mlp.0.bias", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.continuous_position_bias_mlp.0.bias"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.attn.cpb_mlp.2.weight", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.continuous_position_bias_mlp.2.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.attn.q_bias", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.query.bias"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.attn.v_bias", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.value.bias"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.attn.proj.weight", f"backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.attn.proj.bias", f"backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.norm1.weight", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.norm1.bias", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.mlp.fc1.weight", f"backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.mlp.fc1.bias", f"backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.mlp.fc2.weight", f"backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.mlp.fc2.bias", f"backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.norm2.weight", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.blocks.{j}.norm2.bias", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias"))
-
-        # downsample parameters
-        if i in [0,1,2]:
-            rename_keys.append((f"pretrained.model.layers.{i}.downsample.reduction.weight", f"backbone.encoder.layers.{i}.downsample.reduction.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.downsample.norm.weight", f"backbone.encoder.layers.{i}.downsample.norm.weight"))
-            rename_keys.append((f"pretrained.model.layers.{i}.downsample.norm.bias", f"backbone.encoder.layers.{i}.downsample.norm.bias"))
-
-    # note: non-Transformer backbones like Swinv2, LeViT et al don't require activation postprocessing (readout projections + resize blocks)
-
-    # refinenet (tricky here)
-    mapping = {1:3, 2:2, 3:1, 4:0}
-
-    for i in range(1, 5):
-        j = mapping[i]
-        rename_keys.append((f"scratch.refinenet{i}.out_conv.weight", f"neck.fusion_stage.layers.{j}.projection.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.out_conv.bias", f"neck.fusion_stage.layers.{j}.projection.bias"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit1.conv1.weight", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution1.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit1.conv1.bias", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution1.bias"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit1.conv2.weight", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution2.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit1.conv2.bias", f"neck.fusion_stage.layers.{j}.residual_layer1.convolution2.bias"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit2.conv1.weight", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution1.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit2.conv1.bias", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution1.bias"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit2.conv2.weight", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution2.weight"))
-        rename_keys.append((f"scratch.refinenet{i}.resConfUnit2.conv2.bias", f"neck.fusion_stage.layers.{j}.residual_layer2.convolution2.bias"))
-
-    # scratch convolutions
-    for i in range(4):
-        rename_keys.append((f"scratch.layer{i+1}_rn.weight", f"neck.convs.{i}.weight"))
-
-    # head
-    for i in range(0, 5, 2):
-        rename_keys.append((f"scratch.output_conv.{i}.weight", f"head.head.{i}.weight"))
-        rename_keys.append((f"scratch.output_conv.{i}.bias", f"head.head.{i}.bias"))
-
-    return rename_keys
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = ["pretrained.model.head.weight", "pretrained.model.head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, model):
-    for i in range(len(config.backbone_config.depths)):
-        for j in range(config.backbone_config.depths[i]):
-            dim = model.backbone.encoder.layers[i].blocks[j].attention.self.all_head_size
-            # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-            in_proj_weight = state_dict.pop(f"pretrained.model.layers.{i}.blocks.{j}.attn.qkv.weight")
-            # next, add query, keys and values (in that order) to the state dict
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.query.weight"] = in_proj_weight[:dim, :]
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.key.weight"] = in_proj_weight[
-                dim : dim * 2, :
-            ]
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.value.weight"] = in_proj_weight[
-                -dim:, :
-            ]
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_dpt_checkpoint(model_name, pytorch_dump_folder_path, verify_logits, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our DPT structure.
-    """
-
-    name_to_url = {
-        "dpt-swinv2-tiny-256": "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_swin2_tiny_256.pt",
-        "dpt-swinv2-base-384": "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_swin2_base_384.pt",
-        "dpt-swinv2-large-384": "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_swin2_large_384.pt",
-    }
-
-    # define DPT configuration based on URL
-    checkpoint_url = name_to_url[model_name]
-    config, image_size = get_dpt_config(model_name)
-    # load original state_dict from URL
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
-
-    # load HuggingFace model
-    model = DPTForDepthEstimation(config)
-
-    # remove certain keys
-    remove_ignore_keys_(state_dict)
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    # read in qkv matrices
-    read_in_q_k_v(state_dict, config, model)
-
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-    model.eval()
-
-    # Check outputs on an image
-    processor = DPTImageProcessor(size={"height": image_size, "width": image_size})
-
-    image = prepare_img()
-    processor(image, return_tensors="pt")
-
-    if verify_logits:
-        from torchvision import transforms
-
-        url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-        image = Image.open(requests.get(url, stream=True).raw)
-
-        transforms = transforms.Compose(
-            [
-                transforms.Resize((image_size, image_size)),
-                transforms.ToTensor(),
-            ]
-        )
-        pixel_values = transforms(image).unsqueeze(0)
-
-        # forward pass
-        with torch.no_grad():
-            outputs = model(pixel_values)
-
-        predicted_depth = outputs.predicted_depth
-
-        print("Shape of predicted depth:", predicted_depth.shape)
-        print("First values of predicted depth:", predicted_depth[0, :3, :3])
-
-        # assert logits
-        if model_name == "dpt-swinv2-base-384":
-            # OK, checked
-            expected_shape = torch.Size([1, 384, 384])
-            expected_slice = torch.tensor(
-                [
-                    [1998.5575, 1997.3887, 2009.2981],
-                    [1952.8607, 1979.6488, 2001.0854],
-                    [1953.7697, 1961.7711, 1968.8904],
-                ],
-            )
-        elif model_name == "dpt-swinv2-tiny-256":
-            # OK, checked
-            expected_shape = torch.Size([1, 256, 256])
-            expected_slice = torch.tensor(
-                [[978.9163, 976.5215, 978.5349], [974.1859, 971.7249, 975.8046], [971.3419, 970.3118, 971.6830]],
-            )
-        elif model_name == "dpt-swinv2-large-384":
-            # OK, checked
-            expected_shape = torch.Size([1, 384, 384])
-            expected_slice = torch.tensor(
-                [
-                    [1203.7206, 1200.1495, 1197.8234],
-                    [1196.2484, 1183.5033, 1186.4640],
-                    [1178.8131, 1182.3260, 1174.3975],
-                ],
-            )
-
-        assert predicted_depth.shape == torch.Size(expected_shape)
-        assert torch.allclose(predicted_depth[0, :3, :3], expected_slice)
-        print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model and processor to hub...")
-        model.push_to_hub(repo_id=f"Intel/{model_name}")
-        processor.push_to_hub(repo_id=f"Intel/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="dpt-swinv2-base-384",
-        type=str,
-        choices=["dpt-swinv2-tiny-256", "dpt-swinv2-base-384", "dpt-swinv2-large-384"],
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_true",
-        help="Whether to verify logits after conversion.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model to the hub after conversion.",
-    )
-
-    args = parser.parse_args()
-    convert_dpt_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.verify_logits, args.push_to_hub)
diff --git a/src/transformers/models/dpt/convert_dpt_to_pytorch.py b/src/transformers/models/dpt/convert_dpt_to_pytorch.py
deleted file mode 100644
index 55e0a444e857..000000000000
--- a/src/transformers/models/dpt/convert_dpt_to_pytorch.py
+++ /dev/null
@@ -1,285 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert DPT checkpoints from the original repository. URL: https://github.com/isl-org/DPT"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import DPTConfig, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dpt_config(checkpoint_url):
-    config = DPTConfig()
-
-    if "large" in checkpoint_url:
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-        config.backbone_out_indices = [5, 11, 17, 23]
-        config.neck_hidden_sizes = [256, 512, 1024, 1024]
-        expected_shape = (1, 384, 384)
-
-    if "ade" in checkpoint_url:
-        config.use_batch_norm_in_fusion_residual = True
-
-        config.num_labels = 150
-        repo_id = "huggingface/label-files"
-        filename = "ade20k-id2label.json"
-        id2label = json.loads(Path(hf_hub_download(repo_id, filename, repo_type="dataset")).read_text())
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-        expected_shape = [1, 150, 480, 480]
-
-    return config, expected_shape
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = ["pretrained.model.head.weight", "pretrained.model.head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(name):
-    if (
-        "pretrained.model" in name
-        and "cls_token" not in name
-        and "pos_embed" not in name
-        and "patch_embed" not in name
-    ):
-        name = name.replace("pretrained.model", "dpt.encoder")
-    if "pretrained.model" in name:
-        name = name.replace("pretrained.model", "dpt.embeddings")
-    if "patch_embed" in name:
-        name = name.replace("patch_embed", "patch_embeddings")
-    if "pos_embed" in name:
-        name = name.replace("pos_embed", "position_embeddings")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "proj" in name and "project" not in name:
-        name = name.replace("proj", "projection")
-    if "blocks" in name:
-        name = name.replace("blocks", "layer")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "scratch.output_conv" in name:
-        name = name.replace("scratch.output_conv", "head")
-    if "scratch" in name:
-        name = name.replace("scratch", "neck")
-    if "layer1_rn" in name:
-        name = name.replace("layer1_rn", "convs.0")
-    if "layer2_rn" in name:
-        name = name.replace("layer2_rn", "convs.1")
-    if "layer3_rn" in name:
-        name = name.replace("layer3_rn", "convs.2")
-    if "layer4_rn" in name:
-        name = name.replace("layer4_rn", "convs.3")
-    if "refinenet" in name:
-        layer_idx = int(name[len("neck.refinenet") : len("neck.refinenet") + 1])
-        # tricky here: we need to map 4 to 0, 3 to 1, 2 to 2 and 1 to 3
-        name = name.replace(f"refinenet{layer_idx}", f"fusion_stage.layers.{abs(layer_idx - 4)}")
-    if "out_conv" in name:
-        name = name.replace("out_conv", "projection")
-    if "resConfUnit1" in name:
-        name = name.replace("resConfUnit1", "residual_layer1")
-    if "resConfUnit2" in name:
-        name = name.replace("resConfUnit2", "residual_layer2")
-    if "conv1" in name:
-        name = name.replace("conv1", "convolution1")
-    if "conv2" in name:
-        name = name.replace("conv2", "convolution2")
-    # readout blocks
-    if "pretrained.act_postprocess1.0.project.0" in name:
-        name = name.replace("pretrained.act_postprocess1.0.project.0", "neck.reassemble_stage.readout_projects.0.0")
-    if "pretrained.act_postprocess2.0.project.0" in name:
-        name = name.replace("pretrained.act_postprocess2.0.project.0", "neck.reassemble_stage.readout_projects.1.0")
-    if "pretrained.act_postprocess3.0.project.0" in name:
-        name = name.replace("pretrained.act_postprocess3.0.project.0", "neck.reassemble_stage.readout_projects.2.0")
-    if "pretrained.act_postprocess4.0.project.0" in name:
-        name = name.replace("pretrained.act_postprocess4.0.project.0", "neck.reassemble_stage.readout_projects.3.0")
-    # resize blocks
-    if "pretrained.act_postprocess1.3" in name:
-        name = name.replace("pretrained.act_postprocess1.3", "neck.reassemble_stage.layers.0.projection")
-    if "pretrained.act_postprocess1.4" in name:
-        name = name.replace("pretrained.act_postprocess1.4", "neck.reassemble_stage.layers.0.resize")
-    if "pretrained.act_postprocess2.3" in name:
-        name = name.replace("pretrained.act_postprocess2.3", "neck.reassemble_stage.layers.1.projection")
-    if "pretrained.act_postprocess2.4" in name:
-        name = name.replace("pretrained.act_postprocess2.4", "neck.reassemble_stage.layers.1.resize")
-    if "pretrained.act_postprocess3.3" in name:
-        name = name.replace("pretrained.act_postprocess3.3", "neck.reassemble_stage.layers.2.projection")
-    if "pretrained.act_postprocess4.3" in name:
-        name = name.replace("pretrained.act_postprocess4.3", "neck.reassemble_stage.layers.3.projection")
-    if "pretrained.act_postprocess4.4" in name:
-        name = name.replace("pretrained.act_postprocess4.4", "neck.reassemble_stage.layers.3.resize")
-    if "pretrained" in name:
-        name = name.replace("pretrained", "dpt")
-    if "bn" in name:
-        name = name.replace("bn", "batch_norm")
-    if "head" in name:
-        name = name.replace("head", "head.head")
-    if "encoder.norm" in name:
-        name = name.replace("encoder.norm", "layernorm")
-    if "auxlayer" in name:
-        name = name.replace("auxlayer", "auxiliary_head.head")
-
-    return name
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    for i in range(config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"dpt.encoder.layer.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"dpt.encoder.layer.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[: config.hidden_size, :]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"dpt.encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_dpt_checkpoint(checkpoint_url, pytorch_dump_folder_path, push_to_hub, model_name):
-    """
-    Copy/paste/tweak model's weights to our DPT structure.
-    """
-
-    # define DPT configuration based on URL
-    config, expected_shape = get_dpt_config(checkpoint_url)
-    # load original state_dict from URL
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
-    # remove certain keys
-    remove_ignore_keys_(state_dict)
-    # rename keys
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        state_dict[rename_key(key)] = val
-    # read in qkv matrices
-    read_in_q_k_v(state_dict, config)
-
-    # load HuggingFace model
-    model = DPTForSemanticSegmentation(config) if "ade" in checkpoint_url else DPTForDepthEstimation(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # Check outputs on an image
-    size = 480 if "ade" in checkpoint_url else 384
-    image_processor = DPTImageProcessor(size=size)
-
-    image = prepare_img()
-    encoding = image_processor(image, return_tensors="pt")
-
-    # forward pass
-    outputs = model(**encoding).logits if "ade" in checkpoint_url else model(**encoding).predicted_depth
-
-    # Assert logits
-    expected_slice = torch.tensor([[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]])
-    if "ade" in checkpoint_url:
-        expected_slice = torch.tensor([[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]])
-    assert outputs.shape == torch.Size(expected_shape)
-    assert (
-        torch.allclose(outputs[0, 0, :3, :3], expected_slice, atol=1e-4)
-        if "ade" in checkpoint_url
-        else torch.allclose(outputs[0, :3, :3], expected_slice)
-    )
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving image processor to {pytorch_dump_folder_path}")
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model to hub...")
-        model.push_to_hub(
-            repo_path_or_name=Path(pytorch_dump_folder_path, model_name),
-            organization="nielsr",
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
-        image_processor.push_to_hub(
-            repo_path_or_name=Path(pytorch_dump_folder_path, model_name),
-            organization="nielsr",
-            commit_message="Add image processor",
-            use_temp_dir=True,
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://github.com/intel-isl/DPT/releases/download/1_0/dpt_large-midas-2f21e586.pt",
-        type=str,
-        help="URL of the original DPT checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=False,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-    )
-    parser.add_argument(
-        "--model_name",
-        default="dpt-large",
-        type=str,
-        required=False,
-        help="Name of the model, in case you're pushing to the hub.",
-    )
-
-    args = parser.parse_args()
-    convert_dpt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)
diff --git a/src/transformers/models/efficientnet/convert_efficientnet_to_pytorch.py b/src/transformers/models/efficientnet/convert_efficientnet_to_pytorch.py
deleted file mode 100644
index e9988524aca0..000000000000
--- a/src/transformers/models/efficientnet/convert_efficientnet_to_pytorch.py
+++ /dev/null
@@ -1,339 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert EfficientNet checkpoints from the original repository.
-
-URL: https://github.com/keras-team/keras/blob/v2.11.0/keras/applications/efficientnet.py"""
-
-import argparse
-import json
-import os
-
-import numpy as np
-import PIL
-import requests
-import tensorflow.keras.applications.efficientnet as efficientnet
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from tensorflow.keras.preprocessing import image
-
-from transformers import (
-    EfficientNetConfig,
-    EfficientNetForImageClassification,
-    EfficientNetImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-model_classes = {
-    "b0": efficientnet.EfficientNetB0,
-    "b1": efficientnet.EfficientNetB1,
-    "b2": efficientnet.EfficientNetB2,
-    "b3": efficientnet.EfficientNetB3,
-    "b4": efficientnet.EfficientNetB4,
-    "b5": efficientnet.EfficientNetB5,
-    "b6": efficientnet.EfficientNetB6,
-    "b7": efficientnet.EfficientNetB7,
-}
-
-CONFIG_MAP = {
-    "b0": {
-        "hidden_dim": 1280,
-        "width_coef": 1.0,
-        "depth_coef": 1.0,
-        "image_size": 224,
-        "dropout_rate": 0.2,
-        "dw_padding": [],
-    },
-    "b1": {
-        "hidden_dim": 1280,
-        "width_coef": 1.0,
-        "depth_coef": 1.1,
-        "image_size": 240,
-        "dropout_rate": 0.2,
-        "dw_padding": [16],
-    },
-    "b2": {
-        "hidden_dim": 1408,
-        "width_coef": 1.1,
-        "depth_coef": 1.2,
-        "image_size": 260,
-        "dropout_rate": 0.3,
-        "dw_padding": [5, 8, 16],
-    },
-    "b3": {
-        "hidden_dim": 1536,
-        "width_coef": 1.2,
-        "depth_coef": 1.4,
-        "image_size": 300,
-        "dropout_rate": 0.3,
-        "dw_padding": [5, 18],
-    },
-    "b4": {
-        "hidden_dim": 1792,
-        "width_coef": 1.4,
-        "depth_coef": 1.8,
-        "image_size": 380,
-        "dropout_rate": 0.4,
-        "dw_padding": [6],
-    },
-    "b5": {
-        "hidden_dim": 2048,
-        "width_coef": 1.6,
-        "depth_coef": 2.2,
-        "image_size": 456,
-        "dropout_rate": 0.4,
-        "dw_padding": [13, 27],
-    },
-    "b6": {
-        "hidden_dim": 2304,
-        "width_coef": 1.8,
-        "depth_coef": 2.6,
-        "image_size": 528,
-        "dropout_rate": 0.5,
-        "dw_padding": [31],
-    },
-    "b7": {
-        "hidden_dim": 2560,
-        "width_coef": 2.0,
-        "depth_coef": 3.1,
-        "image_size": 600,
-        "dropout_rate": 0.5,
-        "dw_padding": [18],
-    },
-}
-
-
-def get_efficientnet_config(model_name):
-    config = EfficientNetConfig()
-    config.hidden_dim = CONFIG_MAP[model_name]["hidden_dim"]
-    config.width_coefficient = CONFIG_MAP[model_name]["width_coef"]
-    config.depth_coefficient = CONFIG_MAP[model_name]["depth_coef"]
-    config.image_size = CONFIG_MAP[model_name]["image_size"]
-    config.dropout_rate = CONFIG_MAP[model_name]["dropout_rate"]
-    config.depthwise_padding = CONFIG_MAP[model_name]["dw_padding"]
-
-    repo_id = "huggingface/label-files"
-    filename = "imagenet-1k-id2label.json"
-    config.num_labels = 1000
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-    return config
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-def convert_image_processor(model_name):
-    size = CONFIG_MAP[model_name]["image_size"]
-    preprocessor = EfficientNetImageProcessor(
-        size={"height": size, "width": size},
-        image_mean=[0.485, 0.456, 0.406],
-        image_std=[0.47853944, 0.4732864, 0.47434163],
-        do_center_crop=False,
-    )
-    return preprocessor
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def rename_keys(original_param_names):
-    block_names = [v.split("_")[0].split("block")[1] for v in original_param_names if v.startswith("block")]
-    block_names = sorted(set(block_names))
-    num_blocks = len(block_names)
-    block_name_mapping = {b: str(i) for b, i in zip(block_names, range(num_blocks))}
-
-    rename_keys = []
-    rename_keys.append(("stem_conv/kernel:0", "embeddings.convolution.weight"))
-    rename_keys.append(("stem_bn/gamma:0", "embeddings.batchnorm.weight"))
-    rename_keys.append(("stem_bn/beta:0", "embeddings.batchnorm.bias"))
-    rename_keys.append(("stem_bn/moving_mean:0", "embeddings.batchnorm.running_mean"))
-    rename_keys.append(("stem_bn/moving_variance:0", "embeddings.batchnorm.running_var"))
-
-    for b in block_names:
-        hf_b = block_name_mapping[b]
-        rename_keys.append((f"block{b}_expand_conv/kernel:0", f"encoder.blocks.{hf_b}.expansion.expand_conv.weight"))
-        rename_keys.append((f"block{b}_expand_bn/gamma:0", f"encoder.blocks.{hf_b}.expansion.expand_bn.weight"))
-        rename_keys.append((f"block{b}_expand_bn/beta:0", f"encoder.blocks.{hf_b}.expansion.expand_bn.bias"))
-        rename_keys.append(
-            (f"block{b}_expand_bn/moving_mean:0", f"encoder.blocks.{hf_b}.expansion.expand_bn.running_mean")
-        )
-        rename_keys.append(
-            (f"block{b}_expand_bn/moving_variance:0", f"encoder.blocks.{hf_b}.expansion.expand_bn.running_var")
-        )
-        rename_keys.append(
-            (f"block{b}_dwconv/depthwise_kernel:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight")
-        )
-        rename_keys.append((f"block{b}_bn/gamma:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight"))
-        rename_keys.append((f"block{b}_bn/beta:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias"))
-        rename_keys.append(
-            (f"block{b}_bn/moving_mean:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean")
-        )
-        rename_keys.append(
-            (f"block{b}_bn/moving_variance:0", f"encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var")
-        )
-
-        rename_keys.append((f"block{b}_se_reduce/kernel:0", f"encoder.blocks.{hf_b}.squeeze_excite.reduce.weight"))
-        rename_keys.append((f"block{b}_se_reduce/bias:0", f"encoder.blocks.{hf_b}.squeeze_excite.reduce.bias"))
-        rename_keys.append((f"block{b}_se_expand/kernel:0", f"encoder.blocks.{hf_b}.squeeze_excite.expand.weight"))
-        rename_keys.append((f"block{b}_se_expand/bias:0", f"encoder.blocks.{hf_b}.squeeze_excite.expand.bias"))
-        rename_keys.append(
-            (f"block{b}_project_conv/kernel:0", f"encoder.blocks.{hf_b}.projection.project_conv.weight")
-        )
-        rename_keys.append((f"block{b}_project_bn/gamma:0", f"encoder.blocks.{hf_b}.projection.project_bn.weight"))
-        rename_keys.append((f"block{b}_project_bn/beta:0", f"encoder.blocks.{hf_b}.projection.project_bn.bias"))
-        rename_keys.append(
-            (f"block{b}_project_bn/moving_mean:0", f"encoder.blocks.{hf_b}.projection.project_bn.running_mean")
-        )
-        rename_keys.append(
-            (f"block{b}_project_bn/moving_variance:0", f"encoder.blocks.{hf_b}.projection.project_bn.running_var")
-        )
-
-    rename_keys.append(("top_conv/kernel:0", "encoder.top_conv.weight"))
-    rename_keys.append(("top_bn/gamma:0", "encoder.top_bn.weight"))
-    rename_keys.append(("top_bn/beta:0", "encoder.top_bn.bias"))
-    rename_keys.append(("top_bn/moving_mean:0", "encoder.top_bn.running_mean"))
-    rename_keys.append(("top_bn/moving_variance:0", "encoder.top_bn.running_var"))
-
-    key_mapping = {}
-    for item in rename_keys:
-        if item[0] in original_param_names:
-            key_mapping[item[0]] = "efficientnet." + item[1]
-
-    key_mapping["predictions/kernel:0"] = "classifier.weight"
-    key_mapping["predictions/bias:0"] = "classifier.bias"
-    return key_mapping
-
-
-def replace_params(hf_params, tf_params, key_mapping):
-    for key, value in tf_params.items():
-        if "normalization" in key:
-            continue
-
-        hf_key = key_mapping[key]
-        if "_conv" in key and "kernel" in key:
-            new_hf_value = torch.from_numpy(value).permute(3, 2, 0, 1)
-        elif "depthwise_kernel" in key:
-            new_hf_value = torch.from_numpy(value).permute(2, 3, 0, 1)
-        elif "kernel" in key:
-            new_hf_value = torch.from_numpy(np.transpose(value))
-        else:
-            new_hf_value = torch.from_numpy(value)
-
-        # Replace HF parameters with original TF model parameters
-        assert hf_params[hf_key].shape == new_hf_value.shape
-        hf_params[hf_key].copy_(new_hf_value)
-
-
-@torch.no_grad()
-def convert_efficientnet_checkpoint(model_name, pytorch_dump_folder_path, save_model, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our EfficientNet structure.
-    """
-    # Load original model
-    original_model = model_classes[model_name](
-        include_top=True,
-        weights="imagenet",
-        input_tensor=None,
-        input_shape=None,
-        pooling=None,
-        classes=1000,
-        classifier_activation="softmax",
-    )
-
-    tf_params = original_model.trainable_variables
-    tf_non_train_params = original_model.non_trainable_variables
-    tf_params = {param.name: param.numpy() for param in tf_params}
-    for param in tf_non_train_params:
-        tf_params[param.name] = param.numpy()
-    tf_param_names = list(tf_params.keys())
-
-    # Load HuggingFace model
-    config = get_efficientnet_config(model_name)
-    hf_model = EfficientNetForImageClassification(config).eval()
-    hf_params = hf_model.state_dict()
-
-    # Create src-to-dst parameter name mapping dictionary
-    print("Converting parameters...")
-    key_mapping = rename_keys(tf_param_names)
-    replace_params(hf_params, tf_params, key_mapping)
-
-    # Initialize preprocessor and preprocess input image
-    preprocessor = convert_image_processor(model_name)
-    inputs = preprocessor(images=prepare_img(), return_tensors="pt")
-
-    # HF model inference
-    hf_model.eval()
-    with torch.no_grad():
-        outputs = hf_model(**inputs)
-    hf_logits = outputs.logits.detach().numpy()
-
-    # Original model inference
-    original_model.trainable = False
-    image_size = CONFIG_MAP[model_name]["image_size"]
-    img = prepare_img().resize((image_size, image_size), resample=PIL.Image.NEAREST)
-    x = image.img_to_array(img)
-    x = np.expand_dims(x, axis=0)
-    original_logits = original_model.predict(x)
-
-    # Check whether original and HF model outputs match  -> np.allclose
-    assert np.allclose(original_logits, hf_logits, atol=1e-3), "The predicted logits are not the same."
-    print("Model outputs match!")
-
-    if save_model:
-        # Create folder to save model
-        if not os.path.isdir(pytorch_dump_folder_path):
-            os.mkdir(pytorch_dump_folder_path)
-        # Save converted model and image processor
-        hf_model.save_pretrained(pytorch_dump_folder_path)
-        preprocessor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        # Push model and image processor to hub
-        print(f"Pushing converted {model_name} to the hub...")
-        model_name = f"efficientnet-{model_name}"
-        preprocessor.push_to_hub(model_name)
-        hf_model.push_to_hub(model_name)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="b0",
-        type=str,
-        help="Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="hf_model",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--save_model", action="store_true", help="Save model to local")
-    parser.add_argument("--push_to_hub", action="store_true", help="Push model and image processor to the hub")
-
-    args = parser.parse_args()
-    convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)
diff --git a/src/transformers/models/electra/convert_electra_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/electra/convert_electra_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index b0abc30cd758..000000000000
--- a/src/transformers/models/electra/convert_electra_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,79 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ELECTRA checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path, discriminator_or_generator):
-    # Initialise PyTorch model
-    config = ElectraConfig.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-
-    if discriminator_or_generator == "discriminator":
-        model = ElectraForPreTraining(config)
-    elif discriminator_or_generator == "generator":
-        model = ElectraForMaskedLM(config)
-    else:
-        raise ValueError("The discriminator_or_generator argument should be either 'discriminator' or 'generator'")
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_electra(
-        model, config, tf_checkpoint_path, discriminator_or_generator=discriminator_or_generator
-    )
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--discriminator_or_generator",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "Whether to export the generator or the discriminator. Should be a string, either 'discriminator' or "
-            "'generator'."
-        ),
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(
-        args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
-    )
diff --git a/src/transformers/models/emu3/convert_emu3_weights_to_hf.py b/src/transformers/models/emu3/convert_emu3_weights_to_hf.py
deleted file mode 100644
index 8ac8db7e4290..000000000000
--- a/src/transformers/models/emu3/convert_emu3_weights_to_hf.py
+++ /dev/null
@@ -1,448 +0,0 @@
-# Copyright 2024 The Emu team, BAAI and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import json
-import os
-import re
-from typing import Dict, Optional
-
-import requests
-import torch
-from accelerate import init_empty_weights
-from PIL import Image
-
-from transformers import (
-    AutoModel,
-    AutoModelForCausalLM,
-    AutoTokenizer,
-    Emu3Config,
-    Emu3ForConditionalGeneration,
-    Emu3ImageProcessor,
-    Emu3Processor,
-    Emu3TextConfig,
-    GenerationConfig,
-)
-from transformers.models.gpt2.tokenization_gpt2 import bytes_to_unicode
-
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/emu3/convert_emu3_weights_to_hf.py \
-    --vq_model_id BAAI/Emu3-VisionTokenizer --llm_model_id BAAI/Emu3-Chat --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import Emu3ForConditionalGeneration, Emu3Processor
-
-model = Emu3ForConditionalGeneration.from_pretrained("/output/path")
-processor = Emu3Processor.from_pretrained("/output/path")
-```
-
-"""
-
-
-byte_encoder = bytes_to_unicode()
-CHAT_TEMPLATE = "{% for message in messages %}{% if message['role'] != 'system' %}{{ message['role'].upper() + ': '}}{% endif %}{# Render all images first #}{% for content in message['content'] | selectattr('type', 'equalto', 'image') %}{{ '<image>' }}{% endfor %}{# Render all text next #}{% if message['role'] != 'assistant' %}{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}{{ content['text'] + ' '}}{% endfor %}{% else %}{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}{% generation %}{{ content['text'] + ' '}}{% endgeneration %}{% endfor %}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ 'ASSISTANT:' }}{% endif %}"
-
-
-# Tiktoken to HF conversion, thanks for Xenova
-def token_bytes_to_string(b):
-    return "".join([byte_encoder[ord(char)] for char in b.decode("latin-1")])
-
-
-# Adapted from https://github.com/openai/tiktoken/issues/60#issuecomment-1499977960
-def bpe(mergeable_ranks: Dict[bytes, int], token: bytes, max_rank: Optional[int] = None):
-    parts = [bytes([b]) for b in token]
-    while True:
-        min_idx = None
-        min_rank = None
-        for i, pair in enumerate(zip(parts[:-1], parts[1:])):
-            rank = mergeable_ranks.get(pair[0] + pair[1])
-            if rank is not None and (min_rank is None or rank < min_rank):
-                min_idx = i
-                min_rank = rank
-        if min_rank is None or (max_rank is not None and min_rank >= max_rank):
-            break
-        assert min_idx is not None
-        parts = parts[:min_idx] + [parts[min_idx] + parts[min_idx + 1]] + parts[min_idx + 2 :]
-    return parts
-
-
-def generate_vocab_and_merges(encoder):
-    mergeable_ranks = encoder._mergeable_ranks
-
-    merges = []
-    vocab = {}
-    for token, rank in mergeable_ranks.items():
-        vocab[token_bytes_to_string(token)] = rank
-
-        if len(token) == 1:
-            continue
-        merged = tuple(bpe(mergeable_ranks, token, max_rank=rank))
-        assert len(merged) == 2
-        merges.append(" ".join(map(token_bytes_to_string, merged)))
-
-    # Also add special tokens
-    vocab.update(encoder._special_tokens)
-    return vocab, merges
-
-
-def convert_tiktoken(tokenizer, output_dir):
-    encoder = tokenizer.tokenizer
-    vocab, merges = generate_vocab_and_merges(encoder)
-    added_tokens = [
-        {
-            "id": id,
-            "content": content,
-            "single_word": False,
-            "lstrip": False,
-            "rstrip": False,
-            "normalized": False,
-            "special": True,
-        }
-        for content, id in encoder._special_tokens.items()
-        if content != "<|extra_0|>"
-    ]
-
-    # https://huggingface.co/Xenova/gpt2/raw/main/tokenizer_config.json
-    tokenizer_config_template = {
-        "add_prefix_space": False,
-        "bos_token": "<|extra_203|>",
-        "clean_up_tokenization_spaces": False,
-        "eos_token": "<|extra_204|>",
-        "pad_token": "<|endoftext|>",
-    }
-    tokenizer_config_template.update({"tokenizer_class": "GPT2Tokenizer"})
-    tokenizer_config_template = dict(sorted(tokenizer_config_template.items(), key=lambda x: x[0]))
-
-    # add placeholder image token by taking one of the reserved tokens
-    reserved_token_id = vocab["<|extra_0|>"]
-    vocab["<image>"] = reserved_token_id
-    del vocab["<|extra_0|>"]
-    added_tokens.append(
-        {
-            "id": reserved_token_id,
-            "content": "<image>",
-            "single_word": False,
-            "lstrip": False,
-            "rstrip": False,
-            "normalized": False,
-            "special": True,
-        }
-    )
-
-    os.makedirs(output_dir, exist_ok=True)
-
-    pre_tokenizer = {
-        "type": "ByteLevel",
-        "add_prefix_space": False,
-        "trim_offsets": True,
-        "use_regex": True,
-    }
-
-    # https://huggingface.co/Xenova/gpt2/raw/main/tokenizer.json
-    tokenizer_template = {
-        "version": "1.0",
-        "truncation": None,
-        "padding": None,
-        "added_tokens": added_tokens,
-        "normalizer": None,
-        "pre_tokenizer": pre_tokenizer,
-        "post_processor": None,
-        "decoder": {
-            "type": "ByteLevel",
-            "add_prefix_space": True,
-            "trim_offsets": True,
-            "use_regex": True,
-        },
-        "model": {
-            "type": "BPE",
-            "dropout": None,
-            "unk_token": None,
-            "continuing_subword_prefix": "",
-            "end_of_word_suffix": "",
-            "fuse_unk": False,
-            "byte_fallback": False,
-            "vocab": vocab,
-            "merges": merges,
-        },
-    }
-
-    # Save to files
-    with open(os.path.join(output_dir, "vocab.json"), "w", encoding="utf-8") as fp:
-        json.dump(vocab, fp, indent=2, ensure_ascii=False)
-
-    with open(os.path.join(output_dir, "tokenizer.json"), "w", encoding="utf-8") as fp:
-        json.dump(tokenizer_template, fp, indent=2, ensure_ascii=False)
-
-    with open(os.path.join(output_dir, "tokenizer_config.json"), "w", encoding="utf-8") as fp:
-        json.dump(tokenizer_config_template, fp, indent=2, ensure_ascii=False)
-
-    with open(os.path.join(output_dir, "special_tokens_map.json"), "w", encoding="utf-8") as fp:
-        json.dump(
-            {
-                "bos_token": "<|extra_203|>",
-                "eos_token": "<|extra_204|>",
-                "pad_token": "<|endoftext|>",
-            },
-            fp,
-            indent=2,
-            ensure_ascii=False,
-        )
-
-    with open(os.path.join(output_dir, "merges.txt"), "w", encoding="utf-8") as fp:
-        fp.write("#version: 0.2\n")
-        fp.write("\n".join(merges))
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "^encoder": "model.vqmodel.encoder",
-    "^decoder": "model.vqmodel.decoder",
-    "^post_quant_conv": "model.vqmodel.post_quant_conv",
-    "^quant_conv": "model.vqmodel.quant_conv",
-    "^quantize": "model.vqmodel.quantize",
-    "^model": "text_model.model",
-    r"lm_head\.weight": "text_model.lm_head.weight",
-    r"^text_model\.model\.vqmodel": "vqmodel",
-    # rename QKV proj for the VQ-VAE model because we use SiglipAttention
-    r"\.q\.": ".q_proj.",
-    r"\.k\.": ".k_proj.",
-    r"\.v\.": ".v_proj.",
-    r"\.proj_out\.": ".out_proj.",
-    # move the attention norms outside of attention modules
-    r"mid\.attn_1\.norm\.": "mid.attn_norm.",
-    r"attn\.0\.norm\.": "attn_norms.0.",
-    r"attn\.1\.norm\.": "attn_norms.1.",
-    r"attn\.2\.norm\.": "attn_norms.2.",
-    r"attn\.3\.norm\.": "attn_norms.3.",
-    # isolate down/mid/up into separate classes for readability
-    r"\.down\.": ".down_block.down.",
-    r"\.up\.": ".up_block.up.",
-    r"\.mid\.": ".middle_block.",
-}
-
-
-def convert_state_dict_to_hf(old_state_dict, new_state_dict):
-    for key, value in old_state_dict.items():
-        # convert conv layers in attn to linear
-        if (
-            any(key.endswith(name) for name in ["q.weight", "k.weight", "v.weight", "proj_out.weight"])
-            and value.ndim == 4
-        ):
-            value = value.squeeze()
-
-        for old_pattern, new_pattern in KEYS_TO_MODIFY_MAPPING.items():
-            key = re.sub(old_pattern, new_pattern, key)
-
-        new_state_dict[key] = value
-    return new_state_dict
-
-
-def convert_model(vq_model_id, llm_model_id, output_dir, hub_model_id=None, test_inference=False):
-    os.makedirs(output_dir, exist_ok=True)
-
-    # Convert and save processor
-    tokenizer_tiktoken = AutoTokenizer.from_pretrained(llm_model_id, trust_remote_code=True)
-    convert_tiktoken(tokenizer_tiktoken, output_dir)
-    extra_special_tokens = extra_special_tokens = {
-        "image_token": "<image>",
-        "boi_token": "<|image start|>",
-        "eoi_token": "<|image end|>",
-        "image_wrapper_token": "<|image token|>",
-        "eof_token": "<|extra_201|>",
-    }
-    tokenizer_converted = AutoTokenizer.from_pretrained(output_dir, extra_special_tokens=extra_special_tokens)
-    tokenizer_converted.padding_side = "left"
-
-    image_processor = Emu3ImageProcessor.from_pretrained(vq_model_id)
-    processor = Emu3Processor(image_processor, tokenizer_converted, chat_template=CHAT_TEMPLATE)
-    processor.save_pretrained(output_dir)
-
-    # load models
-    model_llm = AutoModelForCausalLM.from_pretrained(
-        llm_model_id,
-        trust_remote_code=True,
-    )
-    model_vqgan = AutoModel.from_pretrained(vq_model_id, trust_remote_code=True)
-    with open(f"{output_dir}/tokenizer.json", "r") as file:
-        tokenizer_config = json.load(file)
-    vocabulary_map = tokenizer_config["model"]["vocab"]
-
-    text_config = Emu3TextConfig(
-        max_position_embeddings=model_llm.config.max_position_embeddings,
-        rope_scaling={"rope_type": "default"},
-    )
-    config = Emu3Config(text_config=text_config, vocabulary_map=vocabulary_map)
-
-    with init_empty_weights():
-        model = Emu3ForConditionalGeneration(config=config)
-        model.generation_config = GenerationConfig(
-            do_sample=True,
-            top_k=2048,
-            max_new_tokens=50_000,
-            pad_token_id=processor.tokenizer.pad_token_id,
-            eos_token_id=processor.tokenizer.eos_token_id,
-        )
-
-    state_dict = {}
-    state_dict = convert_state_dict_to_hf(model_llm.state_dict(), state_dict)
-    state_dict = convert_state_dict_to_hf(model_vqgan.state_dict(), state_dict)
-
-    model.load_state_dict(state_dict, assign=True, strict=True)
-    model.save_pretrained(output_dir, safe_serialization=True)
-
-    if hub_model_id is not None:
-        model.push_to_hub(hub_model_id)
-        processor.push_to_hub(hub_model_id)
-
-    if test_inference and llm_model_id.endswith("Chat"):
-        # Short inference on a few examples to check if generation makes sense
-        print("Loading the checkpoint in a Emu3 model...")
-        print("*" * 100)
-        model = Emu3ForConditionalGeneration.from_pretrained(output_dir, torch_dtype=torch.bfloat16, device_map="auto")
-        processor = Emu3Processor.from_pretrained(output_dir)
-
-        conversation = [
-            {
-                "role": "system",
-                "content": [
-                    {"type": "text", "text": "You are a helpful assistant."},
-                ],
-            },
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": "Please tell me about this art work and its artist."},
-                    {"type": "image"},
-                ],
-            },
-        ]
-        prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
-
-        image = Image.open(
-            requests.get(
-                "https://uploads4.wikiart.org/images/paul-klee/death-for-the-idea-1915.jpg!Large.jpg", stream=True
-            ).raw
-        )
-        inputs = processor(images=image, text=prompt, return_tensors="pt").to(model.device, torch.bfloat16)
-        length = inputs.input_ids.shape[1]
-
-        out = model.generate(**inputs, max_new_tokens=40, do_sample=False)
-        generated_text = processor.batch_decode(out[:, length:], skip_special_tokens=True)[0]
-
-        print(f"Generation for single-image: {generated_text}")
-        print("*" * 100)
-    elif test_inference and llm_model_id.endswith("Gen"):
-        processor = Emu3Processor.from_pretrained(output_dir)
-        model = Emu3ForConditionalGeneration.from_pretrained(output_dir, torch_dtype=torch.bfloat16, device_map="auto")
-
-        inputs = processor(
-            text=[
-                "a portrait of young girl. masterpiece, film grained, best quality.",
-                "a dog running under the rain",
-            ],
-            padding=True,
-            return_tensors="pt",
-            return_for_image_generation=True,
-        )
-        inputs = inputs.to(device="cuda:0", dtype=torch.bfloat16)
-
-        neg_prompt = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry."
-        neg_inputs = processor(text=[neg_prompt] * 2, return_tensors="pt").to(device="cuda:0")
-
-        image_sizes = inputs.pop("image_sizes")
-        HEIGHT, WIDTH = image_sizes[0]
-        VISUAL_TOKENS = model.vocabulary_mapping.image_tokens
-
-        def prefix_allowed_tokens_fn(batch_id, input_ids):
-            height, width = HEIGHT, WIDTH
-            visual_tokens = VISUAL_TOKENS
-            image_token_id = processor.tokenizer.encode("<|image token|>", return_tensors="pt")[0].to(model.device)
-            eoi_token_id = processor.tokenizer.encode("<|image end|>", return_tensors="pt")[0]
-            eos_token_id = processor.tokenizer.encode("<|extra_204|>", return_tensors="pt")[0]
-            pad_token_id = processor.tokenizer.encode("<|endoftext|>", return_tensors="pt")[0]
-            eol_token_id = processor.tokenizer.encode("<|extra_200|>", return_tensors="pt")[0]
-            eof_token_id = processor.tokenizer.encode("<|extra_201|>", return_tensors="pt")[0]
-
-            position = torch.nonzero(input_ids == image_token_id, as_tuple=True)[0][0]
-            offset = input_ids.shape[0] - position
-            if offset % (width + 1) == 0:
-                return (eol_token_id,)
-            elif offset == (width + 1) * height + 1:
-                return (eof_token_id,)
-            elif offset == (width + 1) * height + 2:
-                return (eoi_token_id,)
-            elif offset == (width + 1) * height + 3:
-                return (eos_token_id,)
-            elif offset > (width + 1) * height + 3:
-                return (pad_token_id,)
-            else:
-                return visual_tokens
-
-        out = model.generate(
-            **inputs,
-            prefix_allowed_tokens_fn=prefix_allowed_tokens_fn,
-            negative_prompt_ids=neg_inputs.input_ids,
-            negative_prompt_attention_mask=neg_inputs.attention_mask,
-        )
-
-        image = model.decode_image_tokens(out[:, inputs.input_ids.shape[1] :], height=HEIGHT, width=WIDTH)
-        images = processor.postprocess(
-            list(image.float()), return_tensors="PIL.Image.Image"
-        )  # internally we convert to np but it's not supported in bf16 precision
-        for i, image in enumerate(images["pixel_values"]):
-            image.save(f"result_{i}.png")
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--vq_model_id",
-        help="Model ID of Emu3 VQ-VAE on the hub",
-        default="BAAI/Emu3-VisionTokenizer",
-    )
-    parser.add_argument(
-        "--llm_model_id",
-        help="Model ID of Emu3 bacbone LLM on the hub",
-        default="BAAI/Emu3-Chat",
-    )
-    parser.add_argument(
-        "--output_dir",
-        help="Location to write HF model",
-    )
-    parser.add_argument(
-        "--hub_model_id",
-        help="Model ID in the hub where to push the model.",
-    )
-    parser.add_argument(
-        "--test_inference",
-        action="store_true",
-        help="Whether to load the model for generation to test it's converted correctly.",
-    )
-    args = parser.parse_args()
-    convert_model(
-        vq_model_id=args.vq_model_id,
-        llm_model_id=args.llm_model_id,
-        output_dir=args.output_dir,
-        hub_model_id=args.hub_model_id,
-        test_inference=args.test_inference,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/encodec/convert_encodec_checkpoint_to_pytorch.py b/src/transformers/models/encodec/convert_encodec_checkpoint_to_pytorch.py
deleted file mode 100644
index 4db97bd68836..000000000000
--- a/src/transformers/models/encodec/convert_encodec_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,365 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert EnCodec checkpoints."""
-
-import argparse
-
-import torch
-
-from transformers import (
-    EncodecConfig,
-    EncodecFeatureExtractor,
-    EncodecModel,
-    logging,
-)
-
-
-# checkpoints downloaded from:
-# https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th
-# https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin
-# https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.encodec")
-
-MAPPING_QUANTIZER = {
-    "quantizer.vq.layers.*._codebook.inited": "quantizer.layers.*.codebook.inited",
-    "quantizer.vq.layers.*._codebook.cluster_size": "quantizer.layers.*.codebook.cluster_size",
-    "quantizer.vq.layers.*._codebook.embed": "quantizer.layers.*.codebook.embed",
-    "quantizer.vq.layers.*._codebook.embed_avg": "quantizer.layers.*.codebook.embed_avg",
-}
-MAPPING_ENCODER = {
-    "encoder.model.0.conv.conv": "encoder.layers.0.conv",
-    "encoder.model.1.block.1.conv.conv": "encoder.layers.1.block.1.conv",
-    "encoder.model.1.block.3.conv.conv": "encoder.layers.1.block.3.conv",
-    "encoder.model.1.shortcut.conv.conv": "encoder.layers.1.shortcut.conv",
-    "encoder.model.3.conv.conv": "encoder.layers.3.conv",
-    "encoder.model.4.block.1.conv.conv": "encoder.layers.4.block.1.conv",
-    "encoder.model.4.block.3.conv.conv": "encoder.layers.4.block.3.conv",
-    "encoder.model.4.shortcut.conv.conv": "encoder.layers.4.shortcut.conv",
-    "encoder.model.6.conv.conv": "encoder.layers.6.conv",
-    "encoder.model.7.block.1.conv.conv": "encoder.layers.7.block.1.conv",
-    "encoder.model.7.block.3.conv.conv": "encoder.layers.7.block.3.conv",
-    "encoder.model.7.shortcut.conv.conv": "encoder.layers.7.shortcut.conv",
-    "encoder.model.9.conv.conv": "encoder.layers.9.conv",
-    "encoder.model.10.block.1.conv.conv": "encoder.layers.10.block.1.conv",
-    "encoder.model.10.block.3.conv.conv": "encoder.layers.10.block.3.conv",
-    "encoder.model.10.shortcut.conv.conv": "encoder.layers.10.shortcut.conv",
-    "encoder.model.12.conv.conv": "encoder.layers.12.conv",
-    "encoder.model.13.lstm": "encoder.layers.13.lstm",
-    "encoder.model.15.conv.conv": "encoder.layers.15.conv",
-}
-MAPPING_ENCODER_48K = {
-    "encoder.model.0.conv.norm": "encoder.layers.0.norm",
-    "encoder.model.1.block.1.conv.norm": "encoder.layers.1.block.1.norm",
-    "encoder.model.1.block.3.conv.norm": "encoder.layers.1.block.3.norm",
-    "encoder.model.1.shortcut.conv.norm": "encoder.layers.1.shortcut.norm",
-    "encoder.model.3.conv.norm": "encoder.layers.3.norm",
-    "encoder.model.4.block.1.conv.norm": "encoder.layers.4.block.1.norm",
-    "encoder.model.4.block.3.conv.norm": "encoder.layers.4.block.3.norm",
-    "encoder.model.4.shortcut.conv.norm": "encoder.layers.4.shortcut.norm",
-    "encoder.model.6.conv.norm": "encoder.layers.6.norm",
-    "encoder.model.7.block.1.conv.norm": "encoder.layers.7.block.1.norm",
-    "encoder.model.7.block.3.conv.norm": "encoder.layers.7.block.3.norm",
-    "encoder.model.7.shortcut.conv.norm": "encoder.layers.7.shortcut.norm",
-    "encoder.model.9.conv.norm": "encoder.layers.9.norm",
-    "encoder.model.10.block.1.conv.norm": "encoder.layers.10.block.1.norm",
-    "encoder.model.10.block.3.conv.norm": "encoder.layers.10.block.3.norm",
-    "encoder.model.10.shortcut.conv.norm": "encoder.layers.10.shortcut.norm",
-    "encoder.model.12.conv.norm": "encoder.layers.12.norm",
-    "encoder.model.15.conv.norm": "encoder.layers.15.norm",
-}
-MAPPING_DECODER = {
-    "decoder.model.0.conv.conv": "decoder.layers.0.conv",
-    "decoder.model.1.lstm": "decoder.layers.1.lstm",
-    "decoder.model.3.convtr.convtr": "decoder.layers.3.conv",
-    "decoder.model.4.block.1.conv.conv": "decoder.layers.4.block.1.conv",
-    "decoder.model.4.block.3.conv.conv": "decoder.layers.4.block.3.conv",
-    "decoder.model.4.shortcut.conv.conv": "decoder.layers.4.shortcut.conv",
-    "decoder.model.6.convtr.convtr": "decoder.layers.6.conv",
-    "decoder.model.7.block.1.conv.conv": "decoder.layers.7.block.1.conv",
-    "decoder.model.7.block.3.conv.conv": "decoder.layers.7.block.3.conv",
-    "decoder.model.7.shortcut.conv.conv": "decoder.layers.7.shortcut.conv",
-    "decoder.model.9.convtr.convtr": "decoder.layers.9.conv",
-    "decoder.model.10.block.1.conv.conv": "decoder.layers.10.block.1.conv",
-    "decoder.model.10.block.3.conv.conv": "decoder.layers.10.block.3.conv",
-    "decoder.model.10.shortcut.conv.conv": "decoder.layers.10.shortcut.conv",
-    "decoder.model.12.convtr.convtr": "decoder.layers.12.conv",
-    "decoder.model.13.block.1.conv.conv": "decoder.layers.13.block.1.conv",
-    "decoder.model.13.block.3.conv.conv": "decoder.layers.13.block.3.conv",
-    "decoder.model.13.shortcut.conv.conv": "decoder.layers.13.shortcut.conv",
-    "decoder.model.15.conv.conv": "decoder.layers.15.conv",
-}
-MAPPING_DECODER_48K = {
-    "decoder.model.0.conv.norm": "decoder.layers.0.norm",
-    "decoder.model.3.convtr.norm": "decoder.layers.3.norm",
-    "decoder.model.4.block.1.conv.norm": "decoder.layers.4.block.1.norm",
-    "decoder.model.4.block.3.conv.norm": "decoder.layers.4.block.3.norm",
-    "decoder.model.4.shortcut.conv.norm": "decoder.layers.4.shortcut.norm",
-    "decoder.model.6.convtr.norm": "decoder.layers.6.norm",
-    "decoder.model.7.block.1.conv.norm": "decoder.layers.7.block.1.norm",
-    "decoder.model.7.block.3.conv.norm": "decoder.layers.7.block.3.norm",
-    "decoder.model.7.shortcut.conv.norm": "decoder.layers.7.shortcut.norm",
-    "decoder.model.9.convtr.norm": "decoder.layers.9.norm",
-    "decoder.model.10.block.1.conv.norm": "decoder.layers.10.block.1.norm",
-    "decoder.model.10.block.3.conv.norm": "decoder.layers.10.block.3.norm",
-    "decoder.model.10.shortcut.conv.norm": "decoder.layers.10.shortcut.norm",
-    "decoder.model.12.convtr.norm": "decoder.layers.12.norm",
-    "decoder.model.13.block.1.conv.norm": "decoder.layers.13.block.1.norm",
-    "decoder.model.13.block.3.conv.norm": "decoder.layers.13.block.3.norm",
-    "decoder.model.13.shortcut.conv.norm": "decoder.layers.13.shortcut.norm",
-    "decoder.model.15.conv.norm": "decoder.layers.15.norm",
-}
-MAPPING_24K = {
-    **MAPPING_QUANTIZER,
-    **MAPPING_ENCODER,
-    **MAPPING_DECODER,
-}
-MAPPING_48K = {
-    **MAPPING_QUANTIZER,
-    **MAPPING_ENCODER,
-    **MAPPING_ENCODER_48K,
-    **MAPPING_DECODER,
-    **MAPPING_DECODER_48K,
-}
-TOP_LEVEL_KEYS = []
-IGNORE_KEYS = []
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    if hf_shape != value.shape:
-        raise ValueError(
-            f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-            f" {value.shape} for {full_name}"
-        )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    elif weight_type == "running_mean":
-        hf_pointer.running_mean.data = value
-    elif weight_type == "running_var":
-        hf_pointer.running_var.data = value
-    elif weight_type == "num_batches_tracked":
-        hf_pointer.num_batches_tracked.data = value
-    elif weight_type == "weight_ih_l0":
-        hf_pointer.weight_ih_l0.data = value
-    elif weight_type == "weight_hh_l0":
-        hf_pointer.weight_hh_l0.data = value
-    elif weight_type == "bias_ih_l0":
-        hf_pointer.bias_ih_l0.data = value
-    elif weight_type == "bias_hh_l0":
-        hf_pointer.bias_hh_l0.data = value
-    elif weight_type == "weight_ih_l1":
-        hf_pointer.weight_ih_l1.data = value
-    elif weight_type == "weight_hh_l1":
-        hf_pointer.weight_hh_l1.data = value
-    elif weight_type == "bias_ih_l1":
-        hf_pointer.bias_ih_l1.data = value
-    elif weight_type == "bias_hh_l1":
-        hf_pointer.bias_hh_l1.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}.")
-
-
-def should_ignore(name, ignore_keys):
-    for key in ignore_keys:
-        if key.endswith(".*"):
-            if name.startswith(key[:-1]):
-                return True
-        elif ".*." in key:
-            prefix, suffix = key.split(".*.")
-            if prefix in name and suffix in name:
-                return True
-        elif key in name:
-            return True
-    return False
-
-
-def recursively_load_weights(orig_dict, hf_model, model_name):
-    unused_weights = []
-
-    if model_name in ["encodec_24khz", "encodec_32khz"]:
-        MAPPING = MAPPING_24K
-    elif model_name == "encodec_48khz":
-        MAPPING = MAPPING_48K
-    else:
-        raise ValueError(f"Unsupported model: {model_name}")
-
-    for name, value in orig_dict.items():
-        if should_ignore(name, IGNORE_KEYS):
-            logger.info(f"{name} was ignored")
-            continue
-
-        is_used = False
-        for key, mapped_key in MAPPING.items():
-            if "*" in key:
-                prefix, suffix = key.split(".*.")
-                if prefix in name and suffix in name:
-                    key = suffix
-
-            if key in name:
-                # HACK otherwise .embed gets initialized with .embed_avg too
-                if key.endswith("embed") and name.endswith("embed_avg"):
-                    continue
-
-                is_used = True
-                if "*" in mapped_key:
-                    layer_index = name.split(key)[0].split(".")[-2]
-                    mapped_key = mapped_key.replace("*", layer_index)
-                if "weight_g" in name:
-                    weight_type = "weight_g"
-                elif "weight_v" in name:
-                    weight_type = "weight_v"
-                elif "weight_ih_l0" in name:
-                    weight_type = "weight_ih_l0"
-                elif "weight_hh_l0" in name:
-                    weight_type = "weight_hh_l0"
-                elif "bias_ih_l0" in name:
-                    weight_type = "bias_ih_l0"
-                elif "bias_hh_l0" in name:
-                    weight_type = "bias_hh_l0"
-                elif "weight_ih_l1" in name:
-                    weight_type = "weight_ih_l1"
-                elif "weight_hh_l1" in name:
-                    weight_type = "weight_hh_l1"
-                elif "bias_ih_l1" in name:
-                    weight_type = "bias_ih_l1"
-                elif "bias_hh_l1" in name:
-                    weight_type = "bias_hh_l1"
-                elif "bias" in name:
-                    weight_type = "bias"
-                elif "weight" in name:
-                    weight_type = "weight"
-                elif "running_mean" in name:
-                    weight_type = "running_mean"
-                elif "running_var" in name:
-                    weight_type = "running_var"
-                elif "num_batches_tracked" in name:
-                    weight_type = "num_batches_tracked"
-                else:
-                    weight_type = None
-                set_recursively(hf_model, mapped_key, value, name, weight_type)
-            continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-@torch.no_grad()
-def convert_checkpoint(
-    model_name,
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    config_path=None,
-    repo_id=None,
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = EncodecConfig.from_pretrained(config_path)
-    else:
-        config = EncodecConfig()
-
-    if model_name == "encodec_24khz":
-        pass  # config is already correct
-    elif model_name == "encodec_32khz":
-        config.upsampling_ratios = [8, 5, 4, 4]
-        config.target_bandwidths = [2.2]
-        config.num_filters = 64
-        config.sampling_rate = 32_000
-        config.codebook_size = 2048
-        config.use_causal_conv = False
-        config.normalize = False
-        config.use_conv_shortcut = False
-    elif model_name == "encodec_48khz":
-        config.upsampling_ratios = [8, 5, 4, 2]
-        config.target_bandwidths = [3.0, 6.0, 12.0, 24.0]
-        config.sampling_rate = 48_000
-        config.audio_channels = 2
-        config.use_causal_conv = False
-        config.norm_type = "time_group_norm"
-        config.normalize = True
-        config.chunk_length_s = 1.0
-        config.overlap = 0.01
-    else:
-        raise ValueError(f"Unknown model name: {model_name}")
-
-    model = EncodecModel(config)
-
-    feature_extractor = EncodecFeatureExtractor(
-        feature_size=config.audio_channels,
-        sampling_rate=config.sampling_rate,
-        chunk_length_s=config.chunk_length_s,
-        overlap=config.overlap,
-    )
-    feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-    original_checkpoint = torch.load(checkpoint_path)
-    if "best_state" in original_checkpoint:
-        # we might have a training state saved, in which case discard the yaml results and just retain the weights
-        original_checkpoint = original_checkpoint["best_state"]
-    recursively_load_weights(original_checkpoint, model, model_name)
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        feature_extractor.push_to_hub(repo_id)
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model",
-        default="encodec_24khz",
-        type=str,
-        help="The model to convert. Should be one of 'encodec_24khz', 'encodec_32khz', 'encodec_48khz'.",
-    )
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_checkpoint(
-        args.model,
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.config_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/esm/convert_esm.py b/src/transformers/models/esm/convert_esm.py
deleted file mode 100644
index 020dd4e57663..000000000000
--- a/src/transformers/models/esm/convert_esm.py
+++ /dev/null
@@ -1,399 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ESM checkpoint."""
-
-import argparse
-import pathlib
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-import esm as esm_module
-import torch
-from esm.esmfold.v1.misc import batch_encode_sequences as esmfold_encode_sequences
-from esm.esmfold.v1.pretrained import esmfold_v1
-
-from transformers.models.esm.configuration_esm import EsmConfig, EsmFoldConfig
-from transformers.models.esm.modeling_esm import (
-    EsmForMaskedLM,
-    EsmForSequenceClassification,
-    EsmIntermediate,
-    EsmLayer,
-    EsmOutput,
-    EsmSelfAttention,
-    EsmSelfOutput,
-)
-from transformers.models.esm.modeling_esmfold import EsmForProteinFolding
-from transformers.models.esm.tokenization_esm import EsmTokenizer
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-SAMPLE_DATA = [
-    (
-        "protein1",
-        "MNGTEGPNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQHKKLRTPLNYILLNLAVADLFMVLGGFTSTLYTSLHGYFVFGPTGCNLEGFFATLGGEIALWSLVVLAIERYVVVCKPMSNFRFGENHAIMGVAFTWVMALACAAPPLAGWSRYIPEGLQCSCGIDYYTLKPEVNNESFVIYMFVVHFTIPMIIIFFCYGQLVFTVKEAAAQQQESATTQKAEKEVTRMVIIMVIAFLICWVPYASVAFYIFTHQGSNFGPIFMTIPAFFAKSAAIYNPVIYIMMNKQFRNCMLTTICCGKNPLGDDEASATVSKTETSQVAPA",
-    ),
-    ("protein2", "MKTVRQERLKSIVRILERSKEPVSGAQLAEELSVSRQVIVQDIAYLRSLGYNIVATPRGYVLA"),
-    ("protein3", "MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLAGG"),
-    ("protein4", "MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLA"),
-]
-
-MODEL_MAPPING = {
-    "esm1b_t33_650M_UR50S": esm_module.pretrained.esm1b_t33_650M_UR50S,
-    "esm1v_t33_650M_UR90S_1": esm_module.pretrained.esm1v_t33_650M_UR90S_1,
-    "esm1v_t33_650M_UR90S_2": esm_module.pretrained.esm1v_t33_650M_UR90S_2,
-    "esm1v_t33_650M_UR90S_3": esm_module.pretrained.esm1v_t33_650M_UR90S_3,
-    "esm1v_t33_650M_UR90S_4": esm_module.pretrained.esm1v_t33_650M_UR90S_4,
-    "esm1v_t33_650M_UR90S_5": esm_module.pretrained.esm1v_t33_650M_UR90S_5,
-    "esm2_t48_15B_UR50D": esm_module.pretrained.esm2_t48_15B_UR50D,
-    "esm2_t36_3B_UR50D": esm_module.pretrained.esm2_t36_3B_UR50D,
-    "esm2_t33_650M_UR50D": esm_module.pretrained.esm2_t33_650M_UR50D,
-    "esm2_t30_150M_UR50D": esm_module.pretrained.esm2_t30_150M_UR50D,
-    "esm2_t12_35M_UR50D": esm_module.pretrained.esm2_t12_35M_UR50D,
-    "esm2_t6_8M_UR50D": esm_module.pretrained.esm2_t6_8M_UR50D,
-    "esmfold_v1": esmfold_v1,
-}
-
-restypes = list("ARNDCQEGHILKMFPSTWYV")
-
-restypes_with_x = restypes + ["X"]
-restypes_with_extras = restypes_with_x + ["<pad>", "<mask>", "<cls>", "<sep>", "<eos>"]
-
-
-def get_esmfold_tokenizer():
-    with TemporaryDirectory() as tempdir:
-        vocab = "\n".join(restypes_with_extras)
-        vocab_file = Path(tempdir) / "vocab.txt"
-        vocab_file.write_text(vocab)
-        hf_tokenizer = EsmTokenizer(vocab_file=str(vocab_file))
-    hf_tokenizer.pad_token_id = 0  # Overlaps with 'A' but that seems to be what they want
-    return hf_tokenizer
-
-
-def transfer_and_check_weights(original_module, our_module):
-    status = our_module.load_state_dict(original_module.state_dict())
-    if status.missing_keys:
-        raise ValueError(f"Missing keys: {status.missing_keys}")
-    if status.unexpected_keys:
-        raise ValueError(f"Unexpected keys: {status.unexpected_keys}")
-
-
-def convert_esm_checkpoint_to_pytorch(
-    model: str, pytorch_dump_folder_path: str, classification_head: bool, push_to_repo: str, auth_token: str
-):
-    """
-    Copy/paste/tweak esm's weights to our BERT structure.
-    """
-    if model.startswith("esmfold"):
-        esm = MODEL_MAPPING[model]()
-    else:
-        esm, alphabet = MODEL_MAPPING[model]()
-    esm.eval()  # disable dropout
-
-    if model.startswith("esmfold"):
-        embed_dim = esm.esm.embed_dim
-        num_layers = esm.esm.num_layers
-        num_attention_heads = esm.esm.attention_heads
-        intermediate_size = 4 * embed_dim
-        token_dropout = esm.esm.token_dropout
-        emb_layer_norm_before = False  # This code path does not exist in ESM-2
-        position_embedding_type = "rotary"
-        is_folding_model = True
-        esmfold_config = EsmFoldConfig()
-        for key, val in esm.cfg.items():
-            if hasattr(esmfold_config, key) and key != "trunk":
-                setattr(esmfold_config, key, val)
-        for key, val in esm.cfg.trunk.items():
-            if hasattr(esmfold_config.trunk, key) and key != "structure_module":
-                setattr(esmfold_config.trunk, key, val)
-        for key, val in esm.cfg.trunk.structure_module.items():
-            if hasattr(esmfold_config.trunk.structure_module, key):
-                setattr(esmfold_config.trunk.structure_module, key, val)
-    elif hasattr(esm, "args"):
-        # Indicates an ESM-1b or ESM-1v model
-        embed_dim = esm.args.embed_dim
-        num_layers = esm.args.layers
-        num_attention_heads = esm.args.attention_heads
-        intermediate_size = esm.args.ffn_embed_dim
-        token_dropout = esm.args.token_dropout
-        emb_layer_norm_before = True if esm.emb_layer_norm_before else False
-        position_embedding_type = "absolute"
-        is_folding_model = False
-        esmfold_config = None
-    else:
-        # Indicates an ESM-2 model
-        embed_dim = esm.embed_dim
-        num_layers = esm.num_layers
-        num_attention_heads = esm.attention_heads
-        intermediate_size = 4 * embed_dim  # This is hardcoded in ESM-2
-        token_dropout = esm.token_dropout
-        emb_layer_norm_before = False  # This code path does not exist in ESM-2
-        position_embedding_type = "rotary"
-        is_folding_model = False
-        esmfold_config = None
-
-    if is_folding_model:
-        alphabet = esm.esm.alphabet
-    vocab_list = tuple(alphabet.all_toks)
-    mask_token_id = alphabet.mask_idx
-    pad_token_id = alphabet.padding_idx
-
-    if is_folding_model:
-        original_esm_model = esm.esm
-    else:
-        original_esm_model = esm
-
-    config = EsmConfig(
-        vocab_size=original_esm_model.embed_tokens.num_embeddings,
-        mask_token_id=mask_token_id,
-        hidden_size=embed_dim,
-        num_hidden_layers=num_layers,
-        num_attention_heads=num_attention_heads,
-        intermediate_size=intermediate_size,
-        max_position_embeddings=1026,
-        layer_norm_eps=1e-5,  # PyTorch default used in fairseq
-        attention_probs_dropout_prob=0.0,
-        hidden_dropout_prob=0.0,
-        pad_token_id=pad_token_id,
-        emb_layer_norm_before=emb_layer_norm_before,
-        token_dropout=token_dropout,
-        position_embedding_type=position_embedding_type,
-        is_folding_model=is_folding_model,
-        esmfold_config=esmfold_config,
-        vocab_list=vocab_list,
-    )
-    if classification_head:
-        config.num_labels = esm.classification_heads["mnli"].out_proj.weight.shape[0]
-    print("Our ESM config:", config)
-
-    if model.startswith("esmfold"):
-        model_class = EsmForProteinFolding
-    elif classification_head:
-        model_class = EsmForSequenceClassification
-    else:
-        model_class = EsmForMaskedLM
-    model = model_class(config)
-    model.eval()
-
-    # Now let's copy all the weights.
-    # Embeddings
-    model.esm.embeddings.word_embeddings.weight = original_esm_model.embed_tokens.weight
-    if position_embedding_type == "absolute":
-        model.esm.embeddings.position_embeddings.weight = original_esm_model.embed_positions.weight
-
-    if config.emb_layer_norm_before:
-        model.esm.embeddings.layer_norm.weight = original_esm_model.emb_layer_norm_before.weight
-        model.esm.embeddings.layer_norm.bias = original_esm_model.emb_layer_norm_before.bias
-
-    model.esm.encoder.emb_layer_norm_after.weight = original_esm_model.emb_layer_norm_after.weight
-    model.esm.encoder.emb_layer_norm_after.bias = original_esm_model.emb_layer_norm_after.bias
-
-    for i in range(config.num_hidden_layers):
-        # Encoder: start of layer
-        layer: EsmLayer = model.esm.encoder.layer[i]
-        # esm_layer: TransformerSentenceEncoderLayer = original_esm_model.layers[i]
-        esm_layer = original_esm_model.layers[i]
-
-        # self attention
-        self_attn: EsmSelfAttention = layer.attention.self
-        assert (
-            esm_layer.self_attn.k_proj.weight.data.shape
-            == esm_layer.self_attn.q_proj.weight.data.shape
-            == esm_layer.self_attn.v_proj.weight.data.shape
-            == torch.Size((config.hidden_size, config.hidden_size))
-        )
-
-        self_attn.query.weight.data = esm_layer.self_attn.q_proj.weight
-        self_attn.query.bias.data = esm_layer.self_attn.q_proj.bias
-        self_attn.key.weight.data = esm_layer.self_attn.k_proj.weight
-        self_attn.key.bias.data = esm_layer.self_attn.k_proj.bias
-        self_attn.value.weight.data = esm_layer.self_attn.v_proj.weight
-        self_attn.value.bias.data = esm_layer.self_attn.v_proj.bias
-
-        if getattr(esm_layer.self_attn, "rot_emb", None) is not None:
-            # Matt: Although inv_freq is not a trainable weight, it is computed at model init and cached.
-            # During the training of ESM-2 the model was converted to float16 precision, which also converts
-            # the inv_freq tensor, and the loss of precision remains even if the model is loaded later as float32.
-            # If we recompute inv_freq without this loss of precision then we will get subtly different rotary
-            # embeddings, which are enough to cause significant discrepancies in model outputs. To avoid this,
-            # we make sure the new model copies the data from the old inv_freq.
-            self_attn.rotary_embeddings.inv_freq.data = esm_layer.self_attn.rot_emb.inv_freq
-
-        # LayerNorm changes for pre-activation
-        layer.attention.LayerNorm.weight = esm_layer.self_attn_layer_norm.weight
-        layer.attention.LayerNorm.bias = esm_layer.self_attn_layer_norm.bias
-        layer.LayerNorm.weight = esm_layer.final_layer_norm.weight
-        layer.LayerNorm.bias = esm_layer.final_layer_norm.bias
-
-        # self-attention output
-        self_output: EsmSelfOutput = layer.attention.output
-        assert self_output.dense.weight.shape == esm_layer.self_attn.out_proj.weight.shape
-        self_output.dense.weight = esm_layer.self_attn.out_proj.weight
-        self_output.dense.bias = esm_layer.self_attn.out_proj.bias
-
-        # intermediate
-        intermediate: EsmIntermediate = layer.intermediate
-        assert intermediate.dense.weight.shape == esm_layer.fc1.weight.shape
-        intermediate.dense.weight = esm_layer.fc1.weight
-        intermediate.dense.bias = esm_layer.fc1.bias
-
-        # output
-        bert_output: EsmOutput = layer.output
-        assert bert_output.dense.weight.shape == esm_layer.fc2.weight.shape
-        bert_output.dense.weight = esm_layer.fc2.weight
-        bert_output.dense.bias = esm_layer.fc2.bias
-        # end of layer
-
-    if is_folding_model:
-        model.esm_s_combine.data = esm.esm_s_combine.data
-        model.af2_to_esm.data = esm.af2_to_esm.data
-        transfer_and_check_weights(esm.embedding, model.embedding)
-        transfer_and_check_weights(esm.esm_s_mlp, model.esm_s_mlp)
-        transfer_and_check_weights(esm.trunk, model.trunk)
-        transfer_and_check_weights(esm.distogram_head, model.distogram_head)
-        transfer_and_check_weights(esm.ptm_head, model.ptm_head)
-        transfer_and_check_weights(esm.lm_head, model.lm_head)
-        transfer_and_check_weights(esm.lddt_head, model.lddt_head)
-
-    elif classification_head:
-        model.classifier.dense.weight = esm.esm.classification_heads["mnli"].dense.weight
-        model.classifier.dense.bias = esm.classification_heads["mnli"].dense.bias
-        model.classifier.out_proj.weight = esm.classification_heads["mnli"].out_proj.weight
-        model.classifier.out_proj.bias = esm.classification_heads["mnli"].out_proj.bias
-    else:
-        # LM Head
-        model.lm_head.dense.weight = esm.lm_head.dense.weight
-        model.lm_head.dense.bias = esm.lm_head.dense.bias
-        model.lm_head.layer_norm.weight = esm.lm_head.layer_norm.weight
-        model.lm_head.layer_norm.bias = esm.lm_head.layer_norm.bias
-        model.lm_head.decoder.weight = esm.lm_head.weight
-        model.lm_head.bias = esm.lm_head.bias
-
-    # Contact prediction head
-    transfer_and_check_weights(esm.contact_head, model.esm.contact_head)
-
-    # Prepare data (first 2 sequences from ESMStructuralSplitDataset superfamily / 4)
-    if is_folding_model:
-        # Folding models aren't trained on masked inputs and don't like mask tokens.
-        sample_data = SAMPLE_DATA[:2]
-    else:
-        sample_data = SAMPLE_DATA
-
-    if is_folding_model:
-        hf_tokenizer = get_esmfold_tokenizer()
-        hf_tokens = hf_tokenizer(
-            [row[1] for row in sample_data], return_tensors="pt", padding=True, add_special_tokens=False
-        )
-        esmfold_aas, esmfold_mask, _, _, _ = esmfold_encode_sequences([row[1] for row in sample_data])
-        success = torch.all(hf_tokens["input_ids"] == esmfold_aas) and torch.all(
-            hf_tokens["attention_mask"] == esmfold_mask
-        )
-    else:
-        # Let's check that we get the same results.
-        batch_converter = alphabet.get_batch_converter()
-        batch_labels, batch_strs, batch_tokens = batch_converter(sample_data)
-        # Prepare tokenizer and make sure it matches
-        with TemporaryDirectory() as tempdir:
-            vocab = "\n".join(alphabet.all_toks)
-            vocab_file = Path(tempdir) / "vocab.txt"
-            vocab_file.write_text(vocab)
-            hf_tokenizer = EsmTokenizer(vocab_file=str(vocab_file))
-
-        hf_tokens = hf_tokenizer([row[1] for row in sample_data], return_tensors="pt", padding=True)
-        success = torch.all(hf_tokens["input_ids"] == batch_tokens)
-
-    print("Do both models tokenizers output the same tokens?", "🔥" if success else "💩")
-    if not success:
-        raise Exception("Tokenization does not match!")
-
-    with torch.no_grad():
-        if is_folding_model:
-            # Let's test the model in parts
-            # ESMFold always converts the ESM stem to float16, which requires float16 ops
-            # that don't exist on CPU. Therefore, to test it we need to run it on GPU. However,
-            # ESMFold is what we in the community call a "big boy" and so we desperately avoid putting both the
-            # original and the converted model on the GPU at the same time.
-            their_output = esm.cuda().infer([row[1] for row in sample_data])
-            our_output = model.cuda()(
-                input_ids=hf_tokens["input_ids"].cuda(), attention_mask=hf_tokens["attention_mask"].cuda()
-            )
-        else:
-            our_output = model(**hf_tokens, output_hidden_states=True)
-            our_output = our_output["logits"]
-            if classification_head:
-                their_output = esm.model.classification_heads["mnli"](esm.extract_features(batch_tokens))
-            else:
-                their_output = esm(hf_tokens["input_ids"], repr_layers=list(range(999)))
-                their_output = their_output["logits"]
-
-        if is_folding_model:
-            max_absolute_diff = torch.max(torch.abs(our_output["positions"] - their_output["positions"])).item()
-            success = torch.allclose(our_output["positions"], their_output["positions"], atol=1e-5)
-        else:
-            max_absolute_diff = torch.max(torch.abs(our_output - their_output)).item()
-            success = torch.allclose(our_output, their_output, atol=1e-5)
-
-        print(f"max_absolute_diff = {max_absolute_diff}")  # ~ 1e-5
-        print("Do both models output the same tensors?", "🔥" if success else "💩")
-
-        if not success:
-            raise Exception("Something went wRoNg")
-
-        if not is_folding_model:
-            # Let's check contact prediction too
-            our_output = model.predict_contacts(hf_tokens["input_ids"], hf_tokens["attention_mask"])
-            their_output = esm.predict_contacts(hf_tokens["input_ids"])
-            max_absolute_diff = torch.max(torch.abs(our_output - their_output)).item()
-            success = torch.allclose(our_output, their_output, atol=1e-5)
-
-            print("Contact prediction testing:")
-            print(f"max_absolute_diff = {max_absolute_diff}")  # ~ 1e-5
-            print("Do both models output the same tensors?", "🔥" if success else "💩")
-
-            if not success:
-                raise Exception("Something went wRoNg")
-
-        pathlib.Path(pytorch_dump_folder_path).mkdir(parents=True, exist_ok=True)
-        print(f"Saving model to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-
-        del esm  # Free up some memory before continuing
-
-    print(f"Saving tokenizer to {pytorch_dump_folder_path}")
-    hf_tokenizer.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_repo:
-        model.push_to_hub(repo_id=push_to_repo, token_token=auth_token)
-        hf_tokenizer.push_to_hub(repo_id=push_to_repo, token_token=auth_token)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--pytorch_dump_folder_path", type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--classification_head", action="store_true", help="Whether to convert a final classification head."
-    )
-    parser.add_argument("--model", default=None, type=str, required=True, help="Name of model to convert.")
-    parser.add_argument("--push_to_repo", type=str, help="Repo to upload to (including username!).")
-    parser.add_argument("--auth_token", type=str, help="HuggingFace auth token.")
-    args = parser.parse_args()
-    convert_esm_checkpoint_to_pytorch(
-        args.model, args.pytorch_dump_folder_path, args.classification_head, args.push_to_repo, args.auth_token
-    )
diff --git a/src/transformers/models/falcon/convert_custom_code_checkpoint.py b/src/transformers/models/falcon/convert_custom_code_checkpoint.py
deleted file mode 100644
index 0da817c3ffa7..000000000000
--- a/src/transformers/models/falcon/convert_custom_code_checkpoint.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import json
-from argparse import ArgumentParser
-from pathlib import Path
-
-
-"""
-This script converts Falcon custom code checkpoints to modern Falcon checkpoints that use code in the Transformers
-library. After conversion, performance (especially for generation) should improve and the checkpoint can be loaded
-without needing trust_remote_code=True.
-"""
-
-if __name__ == "__main__":
-    parser = ArgumentParser()
-    parser.add_argument(
-        "--checkpoint_dir",
-        type=Path,
-        required=True,
-        help="Directory containing a custom code checkpoint to convert to a modern Falcon checkpoint.",
-    )
-    args = parser.parse_args()
-
-    if not args.checkpoint_dir.is_dir():
-        raise ValueError("--checkpoint_dir argument should be a directory!")
-
-    if (
-        not (args.checkpoint_dir / "configuration_RW.py").is_file()
-        or not (args.checkpoint_dir / "modelling_RW.py").is_file()
-    ):
-        raise ValueError(
-            "The model directory should contain configuration_RW.py and modelling_RW.py files! Are you sure this is a custom code checkpoint?"
-        )
-    (args.checkpoint_dir / "configuration_RW.py").unlink()
-    (args.checkpoint_dir / "modelling_RW.py").unlink()
-
-    config = args.checkpoint_dir / "config.json"
-    text = config.read_text()
-    text = text.replace("RWForCausalLM", "FalconForCausalLM")
-    text = text.replace("RefinedWebModel", "falcon")
-    text = text.replace("RefinedWeb", "falcon")
-    json_config = json.loads(text)
-    del json_config["auto_map"]
-
-    if "n_head" in json_config:
-        json_config["num_attention_heads"] = json_config.pop("n_head")
-    if "n_layer" in json_config:
-        json_config["num_hidden_layers"] = json_config.pop("n_layer")
-    if "n_head_kv" in json_config:
-        json_config["num_kv_heads"] = json_config.pop("n_head_kv")
-        json_config["new_decoder_architecture"] = True
-    else:
-        json_config["new_decoder_architecture"] = False
-    bos_token_id = json_config.get("bos_token_id", 1)
-    eos_token_id = json_config.get("eos_token_id", 2)
-    config.unlink()
-    config.write_text(json.dumps(json_config, indent=2, sort_keys=True))
-
-    tokenizer_config = args.checkpoint_dir / "tokenizer_config.json"
-    if tokenizer_config.is_file():
-        text = tokenizer_config.read_text()
-        json_config = json.loads(text)
-        if json_config["tokenizer_class"] == "PreTrainedTokenizerFast":
-            json_config["model_input_names"] = ["input_ids", "attention_mask"]
-            tokenizer_config.unlink()
-            tokenizer_config.write_text(json.dumps(json_config, indent=2, sort_keys=True))
-
-    generation_config_path = args.checkpoint_dir / "generation_config.json"
-    generation_dict = {
-        "_from_model_config": True,
-        "bos_token_id": bos_token_id,
-        "eos_token_id": eos_token_id,
-        "transformers_version": "4.33.0.dev0",
-    }
-    generation_config_path.write_text(json.dumps(generation_dict, indent=2, sort_keys=True))
-    print("Done! Please double-check that the new checkpoint works as expected.")
diff --git a/src/transformers/models/fastspeech2_conformer/convert_fastspeech2_conformer_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/fastspeech2_conformer/convert_fastspeech2_conformer_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index bb9c432f8229..000000000000
--- a/src/transformers/models/fastspeech2_conformer/convert_fastspeech2_conformer_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,210 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert FastSpeech2Conformer checkpoint."""
-
-import argparse
-import json
-import re
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-import torch
-import yaml
-
-from transformers import (
-    FastSpeech2ConformerConfig,
-    FastSpeech2ConformerModel,
-    FastSpeech2ConformerTokenizer,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.FastSpeech2Conformer")
-
-CONFIG_MAPPING = {
-    "adim": "hidden_size",
-    "aheads": "num_attention_heads",
-    "conformer_dec_kernel_size": "decoder_kernel_size",
-    "conformer_enc_kernel_size": "encoder_kernel_size",
-    "decoder_normalize_before": "decoder_normalize_before",
-    "dlayers": "decoder_layers",
-    "dunits": "decoder_linear_units",
-    "duration_predictor_chans": "duration_predictor_channels",
-    "duration_predictor_kernel_size": "duration_predictor_kernel_size",
-    "duration_predictor_layers": "duration_predictor_layers",
-    "elayers": "encoder_layers",
-    "encoder_normalize_before": "encoder_normalize_before",
-    "energy_embed_dropout": "energy_embed_dropout",
-    "energy_embed_kernel_size": "energy_embed_kernel_size",
-    "energy_predictor_chans": "energy_predictor_channels",
-    "energy_predictor_dropout": "energy_predictor_dropout",
-    "energy_predictor_kernel_size": "energy_predictor_kernel_size",
-    "energy_predictor_layers": "energy_predictor_layers",
-    "eunits": "encoder_linear_units",
-    "pitch_embed_dropout": "pitch_embed_dropout",
-    "pitch_embed_kernel_size": "pitch_embed_kernel_size",
-    "pitch_predictor_chans": "pitch_predictor_channels",
-    "pitch_predictor_dropout": "pitch_predictor_dropout",
-    "pitch_predictor_kernel_size": "pitch_predictor_kernel_size",
-    "pitch_predictor_layers": "pitch_predictor_layers",
-    "positionwise_conv_kernel_size": "positionwise_conv_kernel_size",
-    "postnet_chans": "speech_decoder_postnet_units",
-    "postnet_filts": "speech_decoder_postnet_kernel",
-    "postnet_layers": "speech_decoder_postnet_layers",
-    "reduction_factor": "reduction_factor",
-    "stop_gradient_from_energy_predictor": "stop_gradient_from_energy_predictor",
-    "stop_gradient_from_pitch_predictor": "stop_gradient_from_pitch_predictor",
-    "transformer_dec_attn_dropout_rate": "decoder_attention_dropout_rate",
-    "transformer_dec_dropout_rate": "decoder_dropout_rate",
-    "transformer_dec_positional_dropout_rate": "decoder_positional_dropout_rate",
-    "transformer_enc_attn_dropout_rate": "encoder_attention_dropout_rate",
-    "transformer_enc_dropout_rate": "encoder_dropout_rate",
-    "transformer_enc_positional_dropout_rate": "encoder_positional_dropout_rate",
-    "use_cnn_in_conformer": "use_cnn_in_conformer",
-    "use_macaron_style_in_conformer": "use_macaron_style_in_conformer",
-    "use_masking": "use_masking",
-    "use_weighted_masking": "use_weighted_masking",
-    "idim": "input_dim",
-    "odim": "num_mel_bins",
-    "spk_embed_dim": "speaker_embed_dim",
-    "langs": "num_languages",
-    "spks": "num_speakers",
-}
-
-
-def remap_model_yaml_config(yaml_config_path):
-    with Path(yaml_config_path).open("r", encoding="utf-8") as f:
-        args = yaml.safe_load(f)
-        args = argparse.Namespace(**args)
-
-    remapped_config = {}
-
-    model_params = args.tts_conf["text2mel_params"]
-    # espnet_config_key -> hf_config_key, any keys not included are ignored
-    for espnet_config_key, hf_config_key in CONFIG_MAPPING.items():
-        if espnet_config_key in model_params:
-            remapped_config[hf_config_key] = model_params[espnet_config_key]
-
-    return remapped_config, args.g2p, args.token_list
-
-
-def convert_espnet_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key in state_dict:
-        if "tts.generator.text2mel." in key:
-            new_key = key.replace("tts.generator.text2mel.", "")
-            if "postnet" in key:
-                new_key = new_key.replace("postnet.postnet", "speech_decoder_postnet.layers")
-                new_key = new_key.replace(".0.weight", ".conv.weight")
-                new_key = new_key.replace(".1.weight", ".batch_norm.weight")
-                new_key = new_key.replace(".1.bias", ".batch_norm.bias")
-                new_key = new_key.replace(".1.running_mean", ".batch_norm.running_mean")
-                new_key = new_key.replace(".1.running_var", ".batch_norm.running_var")
-                new_key = new_key.replace(".1.num_batches_tracked", ".batch_norm.num_batches_tracked")
-            if "feat_out" in key:
-                if "weight" in key:
-                    new_key = "speech_decoder_postnet.feat_out.weight"
-                if "bias" in key:
-                    new_key = "speech_decoder_postnet.feat_out.bias"
-            if "encoder.embed.0.weight" in key:
-                new_key = new_key.replace("0.", "")
-            if "w_1" in key:
-                new_key = new_key.replace("w_1", "conv1")
-            if "w_2" in key:
-                new_key = new_key.replace("w_2", "conv2")
-            if "predictor.conv" in key:
-                new_key = new_key.replace(".conv", ".conv_layers")
-                pattern = r"(\d)\.(\d)"
-                replacement = (
-                    r"\1.conv" if ("2.weight" not in new_key) and ("2.bias" not in new_key) else r"\1.layer_norm"
-                )
-                new_key = re.sub(pattern, replacement, new_key)
-            if "pitch_embed" in key or "energy_embed" in key:
-                new_key = new_key.replace("0", "conv")
-            if "encoders" in key:
-                new_key = new_key.replace("encoders", "conformer_layers")
-                new_key = new_key.replace("norm_final", "final_layer_norm")
-                new_key = new_key.replace("norm_mha", "self_attn_layer_norm")
-                new_key = new_key.replace("norm_ff_macaron", "ff_macaron_layer_norm")
-                new_key = new_key.replace("norm_ff", "ff_layer_norm")
-                new_key = new_key.replace("norm_conv", "conv_layer_norm")
-            if "lid_emb" in key:
-                new_key = new_key.replace("lid_emb", "language_id_embedding")
-            if "sid_emb" in key:
-                new_key = new_key.replace("sid_emb", "speaker_id_embedding")
-
-            new_state_dict[new_key] = state_dict[key]
-
-    return new_state_dict
-
-
-@torch.no_grad()
-def convert_FastSpeech2ConformerModel_checkpoint(
-    checkpoint_path,
-    yaml_config_path,
-    pytorch_dump_folder_path,
-    repo_id=None,
-):
-    model_params, tokenizer_name, vocab = remap_model_yaml_config(yaml_config_path)
-    config = FastSpeech2ConformerConfig(**model_params)
-
-    # Prepare the model
-    model = FastSpeech2ConformerModel(config)
-
-    espnet_checkpoint = torch.load(checkpoint_path)
-    hf_compatible_state_dict = convert_espnet_state_dict_to_hf(espnet_checkpoint)
-
-    model.load_state_dict(hf_compatible_state_dict)
-
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    # Prepare the tokenizer
-    with TemporaryDirectory() as tempdir:
-        vocab = {token: id for id, token in enumerate(vocab)}
-        vocab_file = Path(tempdir) / "vocab.json"
-        with open(vocab_file, "w") as f:
-            json.dump(vocab, f)
-        should_strip_spaces = "no_space" in tokenizer_name
-        tokenizer = FastSpeech2ConformerTokenizer(str(vocab_file), should_strip_spaces=should_strip_spaces)
-
-    tokenizer.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        model.push_to_hub(repo_id)
-        tokenizer.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument(
-        "--yaml_config_path", required=True, default=None, type=str, help="Path to config.yaml of model to convert"
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_FastSpeech2ConformerModel_checkpoint(
-        args.checkpoint_path,
-        args.yaml_config_path,
-        args.pytorch_dump_folder_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/fastspeech2_conformer/convert_hifigan.py b/src/transformers/models/fastspeech2_conformer/convert_hifigan.py
deleted file mode 100644
index ec9f57ce7142..000000000000
--- a/src/transformers/models/fastspeech2_conformer/convert_hifigan.py
+++ /dev/null
@@ -1,134 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert FastSpeech2Conformer HiFi-GAN checkpoint."""
-
-import argparse
-from pathlib import Path
-
-import torch
-import yaml
-
-from transformers import FastSpeech2ConformerHifiGan, FastSpeech2ConformerHifiGanConfig, logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.FastSpeech2Conformer")
-
-
-def load_weights(checkpoint, hf_model, config):
-    vocoder_key_prefix = "tts.generator.vocoder."
-    checkpoint = {k.replace(vocoder_key_prefix, ""): v for k, v in checkpoint.items() if vocoder_key_prefix in k}
-
-    hf_model.apply_weight_norm()
-
-    hf_model.conv_pre.weight_g.data = checkpoint["input_conv.weight_g"]
-    hf_model.conv_pre.weight_v.data = checkpoint["input_conv.weight_v"]
-    hf_model.conv_pre.bias.data = checkpoint["input_conv.bias"]
-
-    for i in range(len(config.upsample_rates)):
-        hf_model.upsampler[i].weight_g.data = checkpoint[f"upsamples.{i}.1.weight_g"]
-        hf_model.upsampler[i].weight_v.data = checkpoint[f"upsamples.{i}.1.weight_v"]
-        hf_model.upsampler[i].bias.data = checkpoint[f"upsamples.{i}.1.bias"]
-
-    for i in range(len(config.upsample_rates) * len(config.resblock_kernel_sizes)):
-        for j in range(len(config.resblock_dilation_sizes)):
-            hf_model.resblocks[i].convs1[j].weight_g.data = checkpoint[f"blocks.{i}.convs1.{j}.1.weight_g"]
-            hf_model.resblocks[i].convs1[j].weight_v.data = checkpoint[f"blocks.{i}.convs1.{j}.1.weight_v"]
-            hf_model.resblocks[i].convs1[j].bias.data = checkpoint[f"blocks.{i}.convs1.{j}.1.bias"]
-
-            hf_model.resblocks[i].convs2[j].weight_g.data = checkpoint[f"blocks.{i}.convs2.{j}.1.weight_g"]
-            hf_model.resblocks[i].convs2[j].weight_v.data = checkpoint[f"blocks.{i}.convs2.{j}.1.weight_v"]
-            hf_model.resblocks[i].convs2[j].bias.data = checkpoint[f"blocks.{i}.convs2.{j}.1.bias"]
-
-    hf_model.conv_post.weight_g.data = checkpoint["output_conv.1.weight_g"]
-    hf_model.conv_post.weight_v.data = checkpoint["output_conv.1.weight_v"]
-    hf_model.conv_post.bias.data = checkpoint["output_conv.1.bias"]
-
-    hf_model.remove_weight_norm()
-
-
-def remap_hifigan_yaml_config(yaml_config_path):
-    with Path(yaml_config_path).open("r", encoding="utf-8") as f:
-        args = yaml.safe_load(f)
-        args = argparse.Namespace(**args)
-
-    vocoder_type = args.tts_conf["vocoder_type"]
-    if vocoder_type != "hifigan_generator":
-        raise TypeError(f"Vocoder config must be for `hifigan_generator`, but got {vocoder_type}")
-
-    remapped_dict = {}
-    vocoder_params = args.tts_conf["vocoder_params"]
-
-    # espnet_config_key -> hf_config_key
-    key_mappings = {
-        "channels": "upsample_initial_channel",
-        "in_channels": "model_in_dim",
-        "resblock_dilations": "resblock_dilation_sizes",
-        "resblock_kernel_sizes": "resblock_kernel_sizes",
-        "upsample_kernel_sizes": "upsample_kernel_sizes",
-        "upsample_scales": "upsample_rates",
-    }
-    for espnet_config_key, hf_config_key in key_mappings.items():
-        remapped_dict[hf_config_key] = vocoder_params[espnet_config_key]
-    remapped_dict["sampling_rate"] = args.tts_conf["sampling_rate"]
-    remapped_dict["normalize_before"] = False
-    remapped_dict["leaky_relu_slope"] = vocoder_params["nonlinear_activation_params"]["negative_slope"]
-
-    return remapped_dict
-
-
-@torch.no_grad()
-def convert_hifigan_checkpoint(
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    yaml_config_path=None,
-    repo_id=None,
-):
-    if yaml_config_path is not None:
-        config_kwargs = remap_hifigan_yaml_config(yaml_config_path)
-        config = FastSpeech2ConformerHifiGanConfig(**config_kwargs)
-    else:
-        config = FastSpeech2ConformerHifiGanConfig()
-
-    model = FastSpeech2ConformerHifiGan(config)
-
-    orig_checkpoint = torch.load(checkpoint_path)
-    load_weights(orig_checkpoint, model, config)
-
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument("--yaml_config_path", default=None, type=str, help="Path to config.yaml of model to convert")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_hifigan_checkpoint(
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.yaml_config_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/fastspeech2_conformer/convert_model_with_hifigan.py b/src/transformers/models/fastspeech2_conformer/convert_model_with_hifigan.py
deleted file mode 100644
index 2a780d5cf0b8..000000000000
--- a/src/transformers/models/fastspeech2_conformer/convert_model_with_hifigan.py
+++ /dev/null
@@ -1,102 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert FastSpeech2Conformer checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import (
-    FastSpeech2ConformerConfig,
-    FastSpeech2ConformerHifiGan,
-    FastSpeech2ConformerHifiGanConfig,
-    FastSpeech2ConformerModel,
-    FastSpeech2ConformerWithHifiGan,
-    FastSpeech2ConformerWithHifiGanConfig,
-    logging,
-)
-
-from .convert_fastspeech2_conformer_original_pytorch_checkpoint_to_pytorch import (
-    convert_espnet_state_dict_to_hf,
-    remap_model_yaml_config,
-)
-from .convert_hifigan import load_weights, remap_hifigan_yaml_config
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.FastSpeech2Conformer")
-
-
-def convert_FastSpeech2ConformerWithHifiGan_checkpoint(
-    checkpoint_path,
-    yaml_config_path,
-    pytorch_dump_folder_path,
-    repo_id=None,
-):
-    # Prepare the model
-    model_params, *_ = remap_model_yaml_config(yaml_config_path)
-    model_config = FastSpeech2ConformerConfig(**model_params)
-
-    model = FastSpeech2ConformerModel(model_config)
-
-    espnet_checkpoint = torch.load(checkpoint_path)
-    hf_compatible_state_dict = convert_espnet_state_dict_to_hf(espnet_checkpoint)
-    model.load_state_dict(hf_compatible_state_dict)
-
-    # Prepare the vocoder
-    config_kwargs = remap_hifigan_yaml_config(yaml_config_path)
-    vocoder_config = FastSpeech2ConformerHifiGanConfig(**config_kwargs)
-
-    vocoder = FastSpeech2ConformerHifiGan(vocoder_config)
-    load_weights(espnet_checkpoint, vocoder, vocoder_config)
-
-    # Prepare the model + vocoder
-    config = FastSpeech2ConformerWithHifiGanConfig.from_sub_model_configs(model_config, vocoder_config)
-    with_hifigan_model = FastSpeech2ConformerWithHifiGan(config)
-    with_hifigan_model.model = model
-    with_hifigan_model.vocoder = vocoder
-
-    with_hifigan_model.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        with_hifigan_model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument(
-        "--yaml_config_path", required=True, default=None, type=str, help="Path to config.yaml of model to convert"
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        required=True,
-        default=None,
-        type=str,
-        help="Path to the output `FastSpeech2ConformerModel` PyTorch model.",
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-
-    convert_FastSpeech2ConformerWithHifiGan_checkpoint(
-        args.checkpoint_path,
-        args.yaml_config_path,
-        args.pytorch_dump_folder_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/flava/convert_dalle_to_flava_codebook.py b/src/transformers/models/flava/convert_dalle_to_flava_codebook.py
deleted file mode 100644
index 7b544125114c..000000000000
--- a/src/transformers/models/flava/convert_dalle_to_flava_codebook.py
+++ /dev/null
@@ -1,102 +0,0 @@
-# coding=utf-8
-# Copyright 2022 Meta Platforms authors and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import os
-
-import torch
-
-from transformers import FlavaImageCodebook, FlavaImageCodebookConfig
-
-
-def rreplace(s, old, new, occurrence):
-    li = s.rsplit(old, occurrence)
-    return new.join(li)
-
-
-def count_parameters(state_dict):
-    # encoder.embeddings are double copied in original FLAVA
-    return sum(param.float().sum() if "encoder.embeddings" not in key else 0 for key, param in state_dict.items())
-
-
-def upgrade_state_dict(state_dict):
-    upgrade = {}
-
-    group_keys = ["group_1", "group_2", "group_3", "group_4"]
-    for key, value in state_dict.items():
-        for group_key in group_keys:
-            if group_key in key:
-                key = key.replace(f"{group_key}.", f"{group_key}.group.")
-
-        if "res_path" in key:
-            key = key.replace("res_path.", "res_path.path.")
-
-        if key.endswith(".w"):
-            key = rreplace(key, ".w", ".weight", 1)
-        if key.endswith(".b"):
-            key = rreplace(key, ".b", ".bias", 1)
-
-        upgrade[key] = value.float()
-
-    return upgrade
-
-
-@torch.no_grad()
-def convert_dalle_checkpoint(checkpoint_path, pytorch_dump_folder_path, config_path=None, save_checkpoint=True):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    from dall_e import Encoder
-
-    encoder = Encoder()
-    if os.path.exists(checkpoint_path):
-        ckpt = torch.load(checkpoint_path)
-    else:
-        ckpt = torch.hub.load_state_dict_from_url(checkpoint_path)
-
-    if isinstance(ckpt, Encoder):
-        ckpt = ckpt.state_dict()
-    encoder.load_state_dict(ckpt)
-
-    if config_path is not None:
-        config = FlavaImageCodebookConfig.from_pretrained(config_path)
-    else:
-        config = FlavaImageCodebookConfig()
-
-    hf_model = FlavaImageCodebook(config).eval()
-    state_dict = encoder.state_dict()
-
-    hf_state_dict = upgrade_state_dict(state_dict)
-    hf_model.load_state_dict(hf_state_dict)
-    hf_state_dict = hf_model.state_dict()
-    hf_count = count_parameters(hf_state_dict)
-    state_dict_count = count_parameters(state_dict)
-
-    assert torch.allclose(hf_count, state_dict_count, atol=1e-3)
-
-    if save_checkpoint:
-        hf_model.save_pretrained(pytorch_dump_folder_path)
-    else:
-        return hf_state_dict
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to flava checkpoint")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    args = parser.parse_args()
-
-    convert_dalle_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
diff --git a/src/transformers/models/flava/convert_flava_original_pytorch_to_hf.py b/src/transformers/models/flava/convert_flava_original_pytorch_to_hf.py
deleted file mode 100644
index 95ebb2bfdb23..000000000000
--- a/src/transformers/models/flava/convert_flava_original_pytorch_to_hf.py
+++ /dev/null
@@ -1,99 +0,0 @@
-# coding=utf-8
-# Copyright 2022 Meta Platforms authors and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import os
-
-import torch
-
-from transformers import FlavaConfig, FlavaForPreTraining
-from transformers.models.flava.convert_dalle_to_flava_codebook import convert_dalle_checkpoint
-
-
-def count_parameters(state_dict):
-    # encoder.embeddings are double copied in original FLAVA
-    return sum(param.float().sum() if "encoder.embeddings" not in key else 0 for key, param in state_dict.items())
-
-
-def upgrade_state_dict(state_dict, codebook_state_dict):
-    upgrade = {}
-
-    for key, value in state_dict.items():
-        if "text_encoder.embeddings" in key or "image_encoder.embeddings" in key:
-            continue
-
-        key = key.replace("heads.cmd.mim_head.cls.predictions", "mmm_image_head")
-        key = key.replace("heads.cmd.mlm_head.cls.predictions", "mmm_text_head")
-        key = key.replace("heads.cmd.itm_head.cls", "itm_head")
-        key = key.replace("heads.cmd.itm_head.pooler", "itm_head.pooler")
-        key = key.replace("heads.cmd.clip_head.logit_scale", "flava.logit_scale")
-        key = key.replace("heads.fairseq_mlm.cls.predictions", "mlm_head")
-        key = key.replace("heads.imagenet.mim_head.cls.predictions", "mim_head")
-        key = key.replace("mm_text_projection", "flava.text_to_mm_projection")
-        key = key.replace("mm_image_projection", "flava.image_to_mm_projection")
-        key = key.replace("image_encoder.module", "flava.image_model")
-        key = key.replace("text_encoder.module", "flava.text_model")
-        key = key.replace("mm_encoder.module.encoder.cls_token", "flava.multimodal_model.cls_token")
-        key = key.replace("mm_encoder.module", "flava.multimodal_model")
-        key = key.replace("text_projection", "flava.text_projection")
-        key = key.replace("image_projection", "flava.image_projection")
-
-        upgrade[key] = value.float()
-
-    for key, value in codebook_state_dict.items():
-        upgrade[f"image_codebook.{key}"] = value
-
-    return upgrade
-
-
-@torch.no_grad()
-def convert_flava_checkpoint(checkpoint_path, codebook_path, pytorch_dump_folder_path, config_path=None):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = FlavaConfig.from_pretrained(config_path)
-    else:
-        config = FlavaConfig()
-
-    hf_model = FlavaForPreTraining(config).eval()
-
-    codebook_state_dict = convert_dalle_checkpoint(codebook_path, None, save_checkpoint=False)
-
-    if os.path.exists(checkpoint_path):
-        state_dict = torch.load(checkpoint_path, map_location="cpu")
-    else:
-        state_dict = torch.hub.load_state_dict_from_url(checkpoint_path, map_location="cpu")
-
-    hf_state_dict = upgrade_state_dict(state_dict, codebook_state_dict)
-    hf_model.load_state_dict(hf_state_dict)
-    hf_state_dict = hf_model.state_dict()
-    hf_count = count_parameters(hf_state_dict)
-    state_dict_count = count_parameters(state_dict) + count_parameters(codebook_state_dict)
-
-    assert torch.allclose(hf_count, state_dict_count, atol=1e-3)
-
-    hf_model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to flava checkpoint")
-    parser.add_argument("--codebook_path", default=None, type=str, help="Path to flava codebook checkpoint")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    args = parser.parse_args()
-
-    convert_flava_checkpoint(args.checkpoint_path, args.codebook_path, args.pytorch_dump_folder_path, args.config_path)
diff --git a/src/transformers/models/fnet/convert_fnet_original_flax_checkpoint_to_pytorch.py b/src/transformers/models/fnet/convert_fnet_original_flax_checkpoint_to_pytorch.py
deleted file mode 100644
index 71660354db14..000000000000
--- a/src/transformers/models/fnet/convert_fnet_original_flax_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,156 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert FNet checkpoint."""
-
-import argparse
-
-import torch
-from flax.training.checkpoints import restore_checkpoint
-
-from transformers import FNetConfig, FNetForPreTraining
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_flax_checkpoint_to_pytorch(flax_checkpoint_path, fnet_config_file, save_path):
-    # Initialise PyTorch model
-    config = FNetConfig.from_json_file(fnet_config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    fnet_pretraining_model = FNetForPreTraining(config)
-
-    checkpoint_dict = restore_checkpoint(flax_checkpoint_path, None)
-    pretrained_model_params = checkpoint_dict["target"]
-
-    # Embeddings
-    # Position IDs
-    state_dict = fnet_pretraining_model.state_dict()
-
-    position_ids = state_dict["fnet.embeddings.position_ids"]
-    new_state_dict = {"fnet.embeddings.position_ids": position_ids}
-    # Embedding Layers
-    new_state_dict["fnet.embeddings.word_embeddings.weight"] = torch.tensor(
-        pretrained_model_params["encoder"]["embedder"]["word"]["embedding"]
-    )
-    new_state_dict["fnet.embeddings.position_embeddings.weight"] = torch.tensor(
-        pretrained_model_params["encoder"]["embedder"]["position"]["embedding"][0]
-    )
-    new_state_dict["fnet.embeddings.token_type_embeddings.weight"] = torch.tensor(
-        pretrained_model_params["encoder"]["embedder"]["type"]["embedding"]
-    )
-    new_state_dict["fnet.embeddings.projection.weight"] = torch.tensor(
-        pretrained_model_params["encoder"]["embedder"]["hidden_mapping_in"]["kernel"]
-    ).T
-    new_state_dict["fnet.embeddings.projection.bias"] = torch.tensor(
-        pretrained_model_params["encoder"]["embedder"]["hidden_mapping_in"]["bias"]
-    )
-    new_state_dict["fnet.embeddings.LayerNorm.weight"] = torch.tensor(
-        pretrained_model_params["encoder"]["embedder"]["layer_norm"]["scale"]
-    )
-    new_state_dict["fnet.embeddings.LayerNorm.bias"] = torch.tensor(
-        pretrained_model_params["encoder"]["embedder"]["layer_norm"]["bias"]
-    )
-
-    # Encoder Layers
-    for layer in range(config.num_hidden_layers):
-        new_state_dict[f"fnet.encoder.layer.{layer}.fourier.output.LayerNorm.weight"] = torch.tensor(
-            pretrained_model_params["encoder"][f"encoder_{layer}"]["mixing_layer_norm"]["scale"]
-        )
-        new_state_dict[f"fnet.encoder.layer.{layer}.fourier.output.LayerNorm.bias"] = torch.tensor(
-            pretrained_model_params["encoder"][f"encoder_{layer}"]["mixing_layer_norm"]["bias"]
-        )
-
-        new_state_dict[f"fnet.encoder.layer.{layer}.intermediate.dense.weight"] = torch.tensor(
-            pretrained_model_params["encoder"][f"feed_forward_{layer}"]["intermediate"]["kernel"]
-        ).T
-        new_state_dict[f"fnet.encoder.layer.{layer}.intermediate.dense.bias"] = torch.tensor(
-            pretrained_model_params["encoder"][f"feed_forward_{layer}"]["intermediate"]["bias"]
-        )
-
-        new_state_dict[f"fnet.encoder.layer.{layer}.output.dense.weight"] = torch.tensor(
-            pretrained_model_params["encoder"][f"feed_forward_{layer}"]["output"]["kernel"]
-        ).T
-        new_state_dict[f"fnet.encoder.layer.{layer}.output.dense.bias"] = torch.tensor(
-            pretrained_model_params["encoder"][f"feed_forward_{layer}"]["output"]["bias"]
-        )
-
-        new_state_dict[f"fnet.encoder.layer.{layer}.output.LayerNorm.weight"] = torch.tensor(
-            pretrained_model_params["encoder"][f"encoder_{layer}"]["output_layer_norm"]["scale"]
-        )
-        new_state_dict[f"fnet.encoder.layer.{layer}.output.LayerNorm.bias"] = torch.tensor(
-            pretrained_model_params["encoder"][f"encoder_{layer}"]["output_layer_norm"]["bias"]
-        )
-
-    # Pooler Layers
-    new_state_dict["fnet.pooler.dense.weight"] = torch.tensor(pretrained_model_params["encoder"]["pooler"]["kernel"]).T
-    new_state_dict["fnet.pooler.dense.bias"] = torch.tensor(pretrained_model_params["encoder"]["pooler"]["bias"])
-
-    # Masked LM Layers
-    new_state_dict["cls.predictions.transform.dense.weight"] = torch.tensor(
-        pretrained_model_params["predictions_dense"]["kernel"]
-    ).T
-    new_state_dict["cls.predictions.transform.dense.bias"] = torch.tensor(
-        pretrained_model_params["predictions_dense"]["bias"]
-    )
-    new_state_dict["cls.predictions.transform.LayerNorm.weight"] = torch.tensor(
-        pretrained_model_params["predictions_layer_norm"]["scale"]
-    )
-    new_state_dict["cls.predictions.transform.LayerNorm.bias"] = torch.tensor(
-        pretrained_model_params["predictions_layer_norm"]["bias"]
-    )
-    new_state_dict["cls.predictions.decoder.weight"] = torch.tensor(
-        pretrained_model_params["encoder"]["embedder"]["word"]["embedding"]
-    )
-    new_state_dict["cls.predictions.decoder.bias"] = torch.tensor(
-        pretrained_model_params["predictions_output"]["output_bias"]
-    )
-    new_state_dict["cls.predictions.bias"] = torch.tensor(pretrained_model_params["predictions_output"]["output_bias"])
-
-    # Seq Relationship Layers
-    new_state_dict["cls.seq_relationship.weight"] = torch.tensor(
-        pretrained_model_params["classification"]["output_kernel"]
-    )
-    new_state_dict["cls.seq_relationship.bias"] = torch.tensor(
-        pretrained_model_params["classification"]["output_bias"]
-    )
-
-    # Load State Dict
-    fnet_pretraining_model.load_state_dict(new_state_dict)
-
-    # Save PreTrained
-    print(f"Saving pretrained model to {save_path}")
-    fnet_pretraining_model.save_pretrained(save_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--flax_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--fnet_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained FNet model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument("--save_path", default=None, type=str, required=True, help="Path to the output model.")
-    args = parser.parse_args()
-    convert_flax_checkpoint_to_pytorch(args.flax_checkpoint_path, args.fnet_config_file, args.save_path)
diff --git a/src/transformers/models/focalnet/convert_focalnet_to_hf_format.py b/src/transformers/models/focalnet/convert_focalnet_to_hf_format.py
deleted file mode 100644
index 4aed15928062..000000000000
--- a/src/transformers/models/focalnet/convert_focalnet_to_hf_format.py
+++ /dev/null
@@ -1,237 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert FocalNet checkpoints from the original repository. URL: https://github.com/microsoft/FocalNet/tree/main"""
-
-import argparse
-import json
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision import transforms
-
-from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
-from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling
-
-
-def get_focalnet_config(model_name):
-    depths = [2, 2, 6, 2] if "tiny" in model_name else [2, 2, 18, 2]
-    use_conv_embed = True if "large" in model_name or "huge" in model_name else False
-    use_post_layernorm = True if "large" in model_name or "huge" in model_name else False
-    use_layerscale = True if "large" in model_name or "huge" in model_name else False
-
-    if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
-        if "fl3" in model_name:
-            focal_levels = [3, 3, 3, 3]
-            focal_windows = [5, 5, 5, 5]
-        elif "fl4" in model_name:
-            focal_levels = [4, 4, 4, 4]
-            focal_windows = [3, 3, 3, 3]
-
-    if "tiny" in model_name or "small" in model_name or "base" in model_name:
-        focal_windows = [3, 3, 3, 3]
-        if "lrf" in model_name:
-            focal_levels = [3, 3, 3, 3]
-        else:
-            focal_levels = [2, 2, 2, 2]
-
-    if "tiny" in model_name:
-        embed_dim = 96
-    elif "small" in model_name:
-        embed_dim = 96
-    elif "base" in model_name:
-        embed_dim = 128
-    elif "large" in model_name:
-        embed_dim = 192
-    elif "xlarge" in model_name:
-        embed_dim = 256
-    elif "huge" in model_name:
-        embed_dim = 352
-
-    # set label information
-    repo_id = "huggingface/label-files"
-    if "large" in model_name or "huge" in model_name:
-        filename = "imagenet-22k-id2label.json"
-    else:
-        filename = "imagenet-1k-id2label.json"
-
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    label2id = {v: k for k, v in id2label.items()}
-
-    config = FocalNetConfig(
-        embed_dim=embed_dim,
-        depths=depths,
-        focal_levels=focal_levels,
-        focal_windows=focal_windows,
-        use_conv_embed=use_conv_embed,
-        id2label=id2label,
-        label2id=label2id,
-        use_post_layernorm=use_post_layernorm,
-        use_layerscale=use_layerscale,
-    )
-
-    return config
-
-
-def rename_key(name):
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "embeddings.norm")
-    if "layers" in name:
-        name = "encoder." + name
-    if "encoder.layers" in name:
-        name = name.replace("encoder.layers", "encoder.stages")
-    if "downsample.proj" in name:
-        name = name.replace("downsample.proj", "downsample.projection")
-    if "blocks" in name:
-        name = name.replace("blocks", "layers")
-    if "modulation.f.weight" in name or "modulation.f.bias" in name:
-        name = name.replace("modulation.f", "modulation.projection_in")
-    if "modulation.h.weight" in name or "modulation.h.bias" in name:
-        name = name.replace("modulation.h", "modulation.projection_context")
-    if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
-        name = name.replace("modulation.proj", "modulation.projection_out")
-
-    if name == "norm.weight":
-        name = "layernorm.weight"
-    if name == "norm.bias":
-        name = "layernorm.bias"
-
-    if "head" in name:
-        name = name.replace("head", "classifier")
-    else:
-        name = "focalnet." + name
-
-    return name
-
-
-def convert_focalnet_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub=False):
-    # fmt: off
-    model_name_to_url = {
-        "focalnet-tiny": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth",
-        "focalnet-tiny-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth",
-        "focalnet-small": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth",
-        "focalnet-small-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth",
-        "focalnet-base": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth",
-        "focalnet-base-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth",
-        "focalnet-large-lrf-fl3": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth",
-        "focalnet-large-lrf-fl4": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth",
-        "focalnet-xlarge-lrf-fl3": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth",
-        "focalnet-xlarge-lrf-fl4": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth",
-    }
-    # fmt: on
-
-    checkpoint_url = model_name_to_url[model_name]
-    print("Checkpoint URL: ", checkpoint_url)
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["model"]
-
-    # rename keys
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        state_dict[rename_key(key)] = val
-
-    config = get_focalnet_config(model_name)
-    model = FocalNetForImageClassification(config)
-    model.eval()
-
-    # load state dict
-    model.load_state_dict(state_dict)
-
-    # verify conversion
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-
-    processor = BitImageProcessor(
-        do_resize=True,
-        size={"shortest_edge": 256},
-        resample=PILImageResampling.BILINEAR,
-        do_center_crop=True,
-        crop_size=224,
-        do_normalize=True,
-        image_mean=IMAGENET_DEFAULT_MEAN,
-        image_std=IMAGENET_DEFAULT_STD,
-    )
-    image = Image.open(requests.get(url, stream=True).raw)
-    inputs = processor(images=image, return_tensors="pt")
-
-    image_transforms = transforms.Compose(
-        [
-            transforms.Resize(256),
-            transforms.CenterCrop(224),
-            transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-        ]
-    )
-
-    original_pixel_values = image_transforms(image).unsqueeze(0)
-
-    # verify pixel_values
-    assert torch.allclose(inputs.pixel_values, original_pixel_values, atol=1e-4)
-
-    outputs = model(**inputs)
-
-    predicted_class_idx = outputs.logits.argmax(-1).item()
-    print("Predicted class:", model.config.id2label[predicted_class_idx])
-
-    print("First values of logits:", outputs.logits[0, :3])
-
-    if model_name == "focalnet-tiny":
-        expected_slice = torch.tensor([0.2166, -0.4368, 0.2191])
-    elif model_name == "focalnet-tiny-lrf":
-        expected_slice = torch.tensor([1.1669, 0.0125, -0.1695])
-    elif model_name == "focalnet-small":
-        expected_slice = torch.tensor([0.4917, -0.0430, 0.1341])
-    elif model_name == "focalnet-small-lrf":
-        expected_slice = torch.tensor([-0.2588, -0.5342, -0.2331])
-    elif model_name == "focalnet-base":
-        expected_slice = torch.tensor([-0.1655, -0.4090, -0.1730])
-    elif model_name == "focalnet-base-lrf":
-        expected_slice = torch.tensor([0.5306, -0.0483, -0.3928])
-    assert torch.allclose(outputs.logits[0, :3], expected_slice, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor of {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and processor of {model_name} to the hub...")
-        model.push_to_hub(f"{model_name}")
-        processor.push_to_hub(f"{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="focalnet-tiny",
-        type=str,
-        help="Name of the FocalNet model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model and processor to the hub.",
-    )
-
-    args = parser.parse_args()
-    convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/fsmt/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/fsmt/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100755
index ef2764f0ed10..000000000000
--- a/src/transformers/models/fsmt/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,280 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Note: if you intend to run this script make sure you look under scripts/fsmt/
-# to locate the appropriate script to do the work correctly. There is a set of scripts to:
-# - download and prepare data and run the conversion script
-# - perform eval to get the best hparam into the config
-# - generate model_cards - useful if you have multiple models from the same paper
-
-import argparse
-import json
-import os
-import re
-from collections import OrderedDict
-from os.path import basename, dirname
-
-import fairseq
-import torch
-from fairseq import hub_utils
-from fairseq.data.dictionary import Dictionary
-
-from transformers import FSMTConfig, FSMTForConditionalGeneration
-from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES
-from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE
-from transformers.utils import WEIGHTS_NAME, logging
-
-
-logging.set_verbosity_warning()
-
-json_indent = 2
-
-# based on the results of a search on a range of `num_beams`, `length_penalty` and `early_stopping`
-# values against wmt19 test data to obtain the best BLEU scores, we will use the following defaults:
-#
-# * `num_beams`: 5 (higher scores better, but requires more memory/is slower, can be adjusted by users)
-# * `early_stopping`: `False` consistently scored better
-# * `length_penalty` varied, so will assign the best one depending on the model
-best_score_hparams = {
-    # fairseq:
-    "wmt19-ru-en": {"length_penalty": 1.1},
-    "wmt19-en-ru": {"length_penalty": 1.15},
-    "wmt19-en-de": {"length_penalty": 1.0},
-    "wmt19-de-en": {"length_penalty": 1.1},
-    # allenai:
-    "wmt16-en-de-dist-12-1": {"length_penalty": 0.6},
-    "wmt16-en-de-dist-6-1": {"length_penalty": 0.6},
-    "wmt16-en-de-12-1": {"length_penalty": 0.8},
-    "wmt19-de-en-6-6-base": {"length_penalty": 0.6},
-    "wmt19-de-en-6-6-big": {"length_penalty": 0.6},
-}
-
-# this remaps the different models to their organization names
-org_names = {}
-for m in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]:
-    org_names[m] = "facebook"
-for m in [
-    "wmt16-en-de-dist-12-1",
-    "wmt16-en-de-dist-6-1",
-    "wmt16-en-de-12-1",
-    "wmt19-de-en-6-6-base",
-    "wmt19-de-en-6-6-big",
-]:
-    org_names[m] = "allenai"
-
-
-def rewrite_dict_keys(d):
-    # (1) remove word breaking symbol, (2) add word ending symbol where the word is not broken up,
-    # e.g.: d = {'le@@': 5, 'tt@@': 6, 'er': 7} => {'le': 5, 'tt': 6, 'er</w>': 7}
-    d2 = dict((re.sub(r"@@$", "", k), v) if k.endswith("@@") else (re.sub(r"$", "</w>", k), v) for k, v in d.items())
-    keep_keys = "<s> <pad> </s> <unk>".split()
-    # restore the special tokens
-    for k in keep_keys:
-        del d2[f"{k}</w>"]
-        d2[k] = d[k]  # restore
-    return d2
-
-
-def convert_fsmt_checkpoint_to_pytorch(fsmt_checkpoint_path, pytorch_dump_folder_path):
-    # prep
-    assert os.path.exists(fsmt_checkpoint_path)
-    os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-    print(f"Writing results to {pytorch_dump_folder_path}")
-
-    # handle various types of models
-
-    checkpoint_file = basename(fsmt_checkpoint_path)
-    fsmt_folder_path = dirname(fsmt_checkpoint_path)
-
-    cls = fairseq.model_parallel.models.transformer.ModelParallelTransformerModel
-    models = cls.hub_models()
-    kwargs = {"bpe": "fastbpe", "tokenizer": "moses"}
-    data_name_or_path = "."
-    # note: since the model dump is old, fairseq has upgraded its model some
-    # time later, and it does a whole lot of rewrites and splits on the saved
-    # weights, therefore we can't use torch.load() directly on the model file.
-    # see: upgrade_state_dict(state_dict) in fairseq_model.py
-    print(f"using checkpoint {checkpoint_file}")
-    chkpt = hub_utils.from_pretrained(
-        fsmt_folder_path, checkpoint_file, data_name_or_path, archive_map=models, **kwargs
-    )
-
-    args = vars(chkpt["args"]["model"])
-
-    src_lang = args["source_lang"]
-    tgt_lang = args["target_lang"]
-
-    data_root = dirname(pytorch_dump_folder_path)
-    model_dir = basename(pytorch_dump_folder_path)
-
-    # dicts
-    src_dict_file = os.path.join(fsmt_folder_path, f"dict.{src_lang}.txt")
-    tgt_dict_file = os.path.join(fsmt_folder_path, f"dict.{tgt_lang}.txt")
-
-    src_dict = Dictionary.load(src_dict_file)
-    src_vocab = rewrite_dict_keys(src_dict.indices)
-    src_vocab_size = len(src_vocab)
-    src_vocab_file = os.path.join(pytorch_dump_folder_path, "vocab-src.json")
-    print(f"Generating {src_vocab_file} of {src_vocab_size} of {src_lang} records")
-    with open(src_vocab_file, "w", encoding="utf-8") as f:
-        f.write(json.dumps(src_vocab, ensure_ascii=False, indent=json_indent))
-
-    # detect whether this is a do_lower_case situation, which can be derived by checking whether we
-    # have at least one uppercase letter in the source vocab
-    do_lower_case = True
-    for k in src_vocab.keys():
-        if not k.islower():
-            do_lower_case = False
-            break
-
-    tgt_dict = Dictionary.load(tgt_dict_file)
-    tgt_vocab = rewrite_dict_keys(tgt_dict.indices)
-    tgt_vocab_size = len(tgt_vocab)
-    tgt_vocab_file = os.path.join(pytorch_dump_folder_path, "vocab-tgt.json")
-    print(f"Generating {tgt_vocab_file} of {tgt_vocab_size} of {tgt_lang} records")
-    with open(tgt_vocab_file, "w", encoding="utf-8") as f:
-        f.write(json.dumps(tgt_vocab, ensure_ascii=False, indent=json_indent))
-
-    # merges_file (bpecodes)
-    merges_file = os.path.join(pytorch_dump_folder_path, VOCAB_FILES_NAMES["merges_file"])
-    for fn in ["bpecodes", "code"]:  # older fairseq called the merges file "code"
-        fsmt_merges_file = os.path.join(fsmt_folder_path, fn)
-        if os.path.exists(fsmt_merges_file):
-            break
-    with open(fsmt_merges_file, encoding="utf-8") as fin:
-        merges = fin.read()
-    merges = re.sub(r" \d+$", "", merges, 0, re.M)  # remove frequency number
-    print(f"Generating {merges_file}")
-    with open(merges_file, "w", encoding="utf-8") as fout:
-        fout.write(merges)
-
-    # model config
-    fsmt_model_config_file = os.path.join(pytorch_dump_folder_path, "config.json")
-
-    # validate bpe/tokenizer config, as currently it's hardcoded to moses+fastbpe -
-    # may have to modify the tokenizer if a different type is used by a future model
-    assert args["bpe"] == "fastbpe", f"need to extend tokenizer to support bpe={args['bpe']}"
-    assert args["tokenizer"] == "moses", f"need to extend tokenizer to support bpe={args['tokenizer']}"
-
-    model_conf = {
-        "architectures": ["FSMTForConditionalGeneration"],
-        "model_type": "fsmt",
-        "activation_dropout": args["activation_dropout"],
-        "activation_function": "relu",
-        "attention_dropout": args["attention_dropout"],
-        "d_model": args["decoder_embed_dim"],
-        "dropout": args["dropout"],
-        "init_std": 0.02,
-        "max_position_embeddings": args["max_source_positions"],
-        "num_hidden_layers": args["encoder_layers"],
-        "src_vocab_size": src_vocab_size,
-        "tgt_vocab_size": tgt_vocab_size,
-        "langs": [src_lang, tgt_lang],
-        "encoder_attention_heads": args["encoder_attention_heads"],
-        "encoder_ffn_dim": args["encoder_ffn_embed_dim"],
-        "encoder_layerdrop": args["encoder_layerdrop"],
-        "encoder_layers": args["encoder_layers"],
-        "decoder_attention_heads": args["decoder_attention_heads"],
-        "decoder_ffn_dim": args["decoder_ffn_embed_dim"],
-        "decoder_layerdrop": args["decoder_layerdrop"],
-        "decoder_layers": args["decoder_layers"],
-        "bos_token_id": 0,
-        "pad_token_id": 1,
-        "eos_token_id": 2,
-        "is_encoder_decoder": True,
-        "scale_embedding": not args["no_scale_embedding"],
-        "tie_word_embeddings": args["share_all_embeddings"],
-    }
-
-    # good hparam defaults to start with
-    model_conf["num_beams"] = 5
-    model_conf["early_stopping"] = False
-    if model_dir in best_score_hparams and "length_penalty" in best_score_hparams[model_dir]:
-        model_conf["length_penalty"] = best_score_hparams[model_dir]["length_penalty"]
-    else:
-        model_conf["length_penalty"] = 1.0
-
-    print(f"Generating {fsmt_model_config_file}")
-    with open(fsmt_model_config_file, "w", encoding="utf-8") as f:
-        f.write(json.dumps(model_conf, ensure_ascii=False, indent=json_indent))
-
-    # tokenizer config
-    fsmt_tokenizer_config_file = os.path.join(pytorch_dump_folder_path, TOKENIZER_CONFIG_FILE)
-
-    tokenizer_conf = {
-        "langs": [src_lang, tgt_lang],
-        "model_max_length": 1024,
-        "do_lower_case": do_lower_case,
-    }
-
-    print(f"Generating {fsmt_tokenizer_config_file}")
-    with open(fsmt_tokenizer_config_file, "w", encoding="utf-8") as f:
-        f.write(json.dumps(tokenizer_conf, ensure_ascii=False, indent=json_indent))
-
-    # model
-    model = chkpt["models"][0]
-    model_state_dict = model.state_dict()
-
-    # rename keys to start with 'model.'
-    model_state_dict = OrderedDict(("model." + k, v) for k, v in model_state_dict.items())
-
-    # remove unneeded keys
-    ignore_keys = [
-        "model.model",
-        "model.encoder.version",
-        "model.decoder.version",
-        "model.encoder_embed_tokens.weight",
-        "model.decoder_embed_tokens.weight",
-        "model.encoder.embed_positions._float_tensor",
-        "model.decoder.embed_positions._float_tensor",
-    ]
-    for k in ignore_keys:
-        model_state_dict.pop(k, None)
-
-    config = FSMTConfig.from_pretrained(pytorch_dump_folder_path)
-    model_new = FSMTForConditionalGeneration(config)
-
-    # check that it loads ok
-    model_new.load_state_dict(model_state_dict, strict=False)
-
-    # save
-    pytorch_weights_dump_path = os.path.join(pytorch_dump_folder_path, WEIGHTS_NAME)
-    print(f"Generating {pytorch_weights_dump_path}")
-    torch.save(model_state_dict, pytorch_weights_dump_path)
-
-    print("Conversion is done!")
-    print("\nLast step is to upload the files to s3")
-    print(f"cd {data_root}")
-    print(f"transformers-cli upload {model_dir}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--fsmt_checkpoint_path",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts,"
-            " bpecodes, etc."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_fsmt_checkpoint_to_pytorch(args.fsmt_checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/funnel/convert_funnel_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/funnel/convert_funnel_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index 37f71c0d233e..000000000000
--- a/src/transformers/models/funnel/convert_funnel_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Funnel checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import FunnelBaseModel, FunnelConfig, FunnelModel, load_tf_weights_in_funnel
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path, base_model):
-    # Initialise PyTorch model
-    config = FunnelConfig.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = FunnelBaseModel(config) if base_model else FunnelModel(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_funnel(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--base_model", action="store_true", help="Whether you want just the base model (no decoder) or not."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(
-        args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
-    )
-
-
-__all__ = []
diff --git a/src/transformers/models/fuyu/convert_fuyu_model_weights_to_hf.py b/src/transformers/models/fuyu/convert_fuyu_model_weights_to_hf.py
deleted file mode 100644
index 6d029c0d13ab..000000000000
--- a/src/transformers/models/fuyu/convert_fuyu_model_weights_to_hf.py
+++ /dev/null
@@ -1,134 +0,0 @@
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import os
-import sys
-import warnings
-
-import flatdict
-import torch
-
-from transformers import FuyuConfig, FuyuForCausalLM, LlamaTokenizer
-
-
-try:
-    from transformers import LlamaTokenizerFast
-
-    tokenizer_class = LlamaTokenizerFast
-except ImportError as e:
-    warnings.warn(e)
-    warnings.warn(
-        "The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion"
-    )
-    tokenizer_class = LlamaTokenizer
-
-"""
-Sample usage: # TODO fix clone links from persimmon to fuyu
-```
-git clone https://github.com/adept-ai-labs/adept-inference
-wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_base_model_release.tar
-wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_chat_model_release.tar
-python src/transformers/models/fuyu/convert_fuyu_weights_to_hf.py  --input_dir /path/to/downloaded/fuyu/weights/ --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import FuyuForCausalLM, FuyuTokenizer
-
-model = FuyuForCausalLM.from_pretrained("/output/path")
-tokenizer = FuyuTokenizer.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "self_attention": "self_attn",
-    "language_model.encoder": "language_model.model",
-    "word_embeddings_for_head": "language_model.lm_head",
-    "language_model.embedding.word_embeddings": "language_model.model.embed_tokens",
-    "vit_encoder.linear_encoder": "vision_embed_tokens",
-}
-
-KEYS_TO_REMOVE = {
-    "rotary_emb.inv_freq",
-    "image_patch_projection",
-    "image_patch_projection.weight",
-    "image_patch_projection.bias",
-}
-
-
-def rename_state_dict(state_dict):
-    model_state_dict = {}
-    for key, value in state_dict.items():
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-        # if KEYS_TO_REMOVE in key:
-        if key in KEYS_TO_REMOVE:
-            continue
-        model_state_dict[key] = value
-    return model_state_dict
-
-
-def convert_fuyu_checkpoint(pytorch_dump_folder_path, ada_lib_path, pt_model_path, safe_serialization=False):
-    sys.path.insert(0, ada_lib_path)
-    model_state_dict_base = torch.load(pt_model_path, map_location="cpu")
-    state_dict = flatdict.FlatDict(model_state_dict_base["model"], ".")
-    state_dict = rename_state_dict(state_dict)
-
-    transformers_config = FuyuConfig()
-    model = FuyuForCausalLM(transformers_config).to(torch.bfloat16)
-    model.load_state_dict(state_dict)
-    model.save_pretrained(pytorch_dump_folder_path, safe_serialization=safe_serialization)
-    transformers_config.save_pretrained(pytorch_dump_folder_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        help="Location of Fuyu weights, which contains tokenizer.model and model folders",
-    )
-    parser.add_argument(
-        "--pt_model_path",
-        help="Location of Fuyu `model_optim_rng.pt`",
-    )
-    parser.add_argument(
-        "--output_dir",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--ada_lib_path",
-        help="Location of original source code from adept to deserialize .pt checkpoint",
-    )
-    parser.add_argument("--safe_serialization", type=bool, help="Whether or not to save using `safetensors`.")
-    args = parser.parse_args()
-    spm_path = os.path.join(args.input_dir, "adept_vocab.model")
-
-    convert_fuyu_checkpoint(
-        pytorch_dump_folder_path=args.output_dir,
-        pt_model_path=args.pt_model_path,
-        safe_serialization=args.safe_serialization,
-        ada_lib_path=args.ada_lib_path,
-    )
-    tokenizer = tokenizer_class(spm_path, bos_token="|ENDOFTEXT|", eos_token="|ENDOFTEXT|")
-    tokenizer.save_pretrained(args.output_dir)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/gemma/convert_gemma_weights_to_hf.py b/src/transformers/models/gemma/convert_gemma_weights_to_hf.py
deleted file mode 100644
index 9b71be35bfa1..000000000000
--- a/src/transformers/models/gemma/convert_gemma_weights_to_hf.py
+++ /dev/null
@@ -1,206 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import os
-import warnings
-
-import torch
-from accelerate import init_empty_weights
-
-from transformers import GemmaConfig, GemmaForCausalLM, GemmaTokenizer
-
-
-try:
-    from transformers import GemmaTokenizerFast
-except ImportError as e:
-    warnings.warn(e)
-    warnings.warn(
-        "The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion"
-    )
-    GemmaTokenizerFast = None
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/gemma/convert_gemma_weights_to_hf.py \
-    --input_dir /path/to/downloaded/gemma/weights --model_size 7B --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import GemmaForCausalLM, GemmaTokenizerFast
-
-model = GemmaForCausalLM.from_pretrained("/output/path")
-tokenizer = GemmaTokenizerFast.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-gemma_2b_config = GemmaConfig(
-    num_hidden_layers=18,
-    num_attention_heads=8,
-    num_key_value_heads=1,
-    hidden_size=2048,
-    intermediate_size=16384,
-)
-
-gemma_7b_config = GemmaConfig()
-
-CONFIG_MAPPING = {"2B": gemma_2b_config, "7B": gemma_7b_config}
-LAYER_NAME_MAPPING = {"embedder.weight": "model.embed_tokens.weight"}
-
-
-def write_model(save_path, input_base_path, config, safe_serialization=True, push_to_hub=False, dtype=torch.float32):
-    num_attn_heads = config.num_attention_heads
-    hidden_size = config.hidden_size
-    num_kv_heads = config.num_key_value_heads
-    head_dim = config.head_dim
-
-    print(f"Fetching all parameters from the checkpoint at '{input_base_path}'")
-    model_state_dict = torch.load(input_base_path, map_location="cpu")["model_state_dict"]
-    model_state_dict.pop("freqs_cis")
-
-    state_dict = {}
-    for k, v in model_state_dict.items():
-        if "qkv_proj" in k:
-            if num_kv_heads == 1:
-                v = v.reshape(num_attn_heads + num_kv_heads * 2, head_dim, hidden_size)
-                q_proj = v[:num_attn_heads, ...]
-                k_proj = v[num_attn_heads : num_attn_heads + num_kv_heads, ...].repeat(num_kv_heads, 1, 1)
-                v_proj = v[-num_kv_heads:, ...].repeat(num_kv_heads, 1, 1)
-
-                state_dict[k.replace("qkv_proj", "q_proj")] = q_proj.reshape(
-                    num_attn_heads * head_dim, hidden_size
-                ).clone()
-                state_dict[k.replace("qkv_proj", "k_proj")] = k_proj.reshape(
-                    num_kv_heads * head_dim, hidden_size
-                ).clone()
-                state_dict[k.replace("qkv_proj", "v_proj")] = v_proj[0].clone()
-            else:
-                q_proj, k_proj, v_proj = torch.split(v, v.shape[0] // 3, 0)
-                state_dict[k.replace("qkv_proj", "q_proj")] = q_proj.reshape(
-                    num_attn_heads * head_dim, hidden_size
-                ).clone()
-                state_dict[k.replace("qkv_proj", "k_proj")] = k_proj.reshape(
-                    num_kv_heads * head_dim, hidden_size
-                ).clone()
-                state_dict[k.replace("qkv_proj", "v_proj")] = v_proj.clone()
-
-        elif k == "embedder.weight":
-            state_dict[LAYER_NAME_MAPPING[k]] = v
-            state_dict["lm_head.weight"] = v
-        else:
-            state_dict[k] = v
-
-    torch.set_default_dtype(dtype)
-
-    print("Loading the checkpoint in a Gemma model.")
-    with init_empty_weights():
-        model = GemmaForCausalLM(config)
-    model.load_state_dict(state_dict, assign=True, strict=False)
-
-    model.config.torch_dtype = torch.float32
-    del model.config._name_or_path
-    print("Saving in the Transformers format.")
-
-    if push_to_hub:
-        print(f"pushing the model to {save_path}")
-        model.push_to_hub(save_path, safe_serialization=safe_serialization, private=True)
-    else:
-        model.save_pretrained(save_path, safe_serialization=safe_serialization)
-
-
-def write_tokenizer(input_tokenizer_path, save_path, push_to_hub=False):
-    # Initialize the tokenizer based on the `spm` model
-    tokenizer_class = GemmaTokenizer if GemmaTokenizerFast is None else GemmaTokenizerFast
-    print(f"Saving a {tokenizer_class.__name__} to {save_path}.")
-    tokenizer = tokenizer_class(input_tokenizer_path)
-    if push_to_hub:
-        tokenizer.push_to_hub(save_path)
-    else:
-        tokenizer.save_pretrained(save_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_checkpoint",
-        help="Absolute path to the target Gemma weights.",
-        required=True,
-    )
-    parser.add_argument(
-        "--tokenizer_checkpoint",
-        help="Location of Gemma tokenizer model",
-    )
-    parser.add_argument(
-        "--model_size",
-        default="7B",
-        choices=["2B", "7B", "tokenizer_only"],
-        help="'f' models correspond to the finetuned versions, and are specific to the Gemma2 official release. For more details on Gemma2, checkout the original repo: https://huggingface.co/google/gemma-7b",
-    )
-    parser.add_argument(
-        "--output_dir",
-        default="google/gemma-7b",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--pickle_serialization",
-        help="Whether or not to save using `safetensors`.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--convert_tokenizer",
-        help="Whether or not to convert the tokenizer as well.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        help="Whether or not to push the model to the hub at `output_dir` instead of saving it locally.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--dtype",
-        default="float32",
-        help="Target dtype of the converted model",
-    )
-    args = parser.parse_args()
-
-    if args.convert_tokenizer:
-        if args.tokenizer_checkpoint is None:
-            raise ValueError("Path to the tokenizer is required when passing --convert_tokenizer")
-
-        spm_path = os.path.join(args.tokenizer_checkpoint)
-        write_tokenizer(spm_path, args.output_dir, args.push_to_hub)
-
-    config = CONFIG_MAPPING[args.model_size]
-    dtype = getattr(torch, args.dtype)
-    write_model(
-        config=config,
-        input_base_path=args.input_checkpoint,
-        save_path=args.output_dir,
-        safe_serialization=not args.pickle_serialization,
-        push_to_hub=args.push_to_hub,
-        dtype=dtype,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/gemma2/convert_gemma2_weights_to_hf.py b/src/transformers/models/gemma2/convert_gemma2_weights_to_hf.py
deleted file mode 100644
index 1ad7d23c3c3e..000000000000
--- a/src/transformers/models/gemma2/convert_gemma2_weights_to_hf.py
+++ /dev/null
@@ -1,239 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import os
-import warnings
-
-import torch
-from accelerate import init_empty_weights
-
-from transformers import Gemma2Config, Gemma2ForCausalLM, GemmaTokenizer
-
-
-try:
-    from transformers import GemmaTokenizerFast
-except ImportError as e:
-    warnings.warn(e)
-    warnings.warn(
-        "The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion"
-    )
-    GemmaTokenizerFast = None
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/gemma2/convert_gemma2_weights_to_hf.py \
-    --input_dir /path/to/downloaded/gemma/weights --model_size 9B --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import Gemma2ForCausalLM, GemmaTokenizerFast
-
-model = Gemma2ForCausalLM.from_pretrained("/output/path")
-tokenizer = GemmaTokenizerFast.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-gemma_9b_config = Gemma2Config(
-    num_hidden_layers=42,
-    num_attention_heads=16,
-    num_key_value_heads=8,
-    hidden_size=3584,
-    intermediate_size=14336,
-    final_logit_softcapping=30.0,
-    attn_logit_softcapping=50.0,
-    head_dim=256,
-    sliding_window=4096,
-    query_pre_attn_scalar=224,
-)
-
-gemma_27b_config = Gemma2Config(
-    num_hidden_layers=46,
-    num_attention_heads=32,
-    num_key_value_heads=16,
-    hidden_size=4608,
-    intermediate_size=36864,
-    final_logit_softcapping=30.0,
-    attn_logit_softcapping=50.0,
-    head_dim=128,
-    sliding_window=4096,
-    query_pre_attn_scalar=144,
-)
-
-CONFIG_MAPPING = {"9B": gemma_9b_config, "27B": gemma_27b_config}
-LAYER_NAME_MAPPING = {"embedder.weight": "model.embed_tokens.weight"}
-
-
-def write_model(save_path, input_base_path, config, safe_serialization=True, push_to_hub=False, dtype=torch.float32):
-    num_attn_heads = config.num_attention_heads
-    hidden_size = config.hidden_size
-    num_kv_heads = config.num_key_value_heads
-    head_dim = config.head_dim
-
-    print(f"Fetching all parameters from the checkpoint at '{input_base_path}'")
-
-    if os.path.isdir(input_base_path):
-        print("Model seems sharded")
-
-        model_state_dict = {}
-        files = [file for file in os.listdir(input_base_path) if file.endswith(".bin")]
-
-        for file in files:
-            print(file)
-            loaded_state_dict = torch.load(os.path.join(input_base_path, file), map_location="cpu")
-            model_state_dict.update(loaded_state_dict)
-    else:
-        print("Model does not seem to be sharded")
-        model_state_dict = torch.load(input_base_path, map_location="cpu")["model_state_dict"]
-        model_state_dict.pop("freqs_cis")
-
-    state_dict = {}
-    for k, v in model_state_dict.items():
-        if "qkv_proj" in k:
-            if num_kv_heads == 1:
-                v = v.reshape(num_attn_heads + num_kv_heads * 2, head_dim, hidden_size)
-                q_proj = v[:num_attn_heads, ...]
-                k_proj = v[num_attn_heads : num_attn_heads + num_kv_heads, ...].repeat(num_kv_heads, 1, 1)
-                v_proj = v[-num_kv_heads:, ...].repeat(num_kv_heads, 1, 1)
-
-                state_dict[k.replace("qkv_proj", "q_proj")] = q_proj.reshape(
-                    num_attn_heads * head_dim, hidden_size
-                ).clone()
-                state_dict[k.replace("qkv_proj", "k_proj")] = k_proj.reshape(
-                    num_kv_heads * head_dim, hidden_size
-                ).clone()
-                state_dict[k.replace("qkv_proj", "v_proj")] = v_proj[0].clone()
-            else:
-                q_proj, k_proj, v_proj = torch.split(
-                    v, [num_attn_heads * head_dim, num_kv_heads * head_dim, num_kv_heads * head_dim], 0
-                )
-                state_dict[k.replace("qkv_proj", "q_proj")] = q_proj.reshape(
-                    num_attn_heads * head_dim, hidden_size
-                ).clone()
-                state_dict[k.replace("qkv_proj", "k_proj")] = k_proj.reshape(
-                    num_kv_heads * head_dim, hidden_size
-                ).clone()
-                state_dict[k.replace("qkv_proj", "v_proj")] = v_proj.reshape(
-                    num_kv_heads * head_dim, hidden_size
-                ).clone()
-
-        elif k == "embedder.weight":
-            state_dict[LAYER_NAME_MAPPING[k]] = v
-            state_dict["lm_head.weight"] = v
-        else:
-            state_dict[k] = v
-
-    torch.set_default_dtype(dtype)
-
-    print("Loading the checkpoint in a Gemma2 model.")
-    with init_empty_weights():
-        model = Gemma2ForCausalLM(config)
-    model.load_state_dict(state_dict, assign=True, strict=False)
-
-    model.config.torch_dtype = torch.float32
-    del model.config._name_or_path
-    print("Saving in the Transformers format.")
-
-    if push_to_hub:
-        print(f"pushing the model to {save_path}")
-        model.push_to_hub(save_path, safe_serialization=safe_serialization, private=True)
-    else:
-        model.save_pretrained(save_path, safe_serialization=safe_serialization)
-
-
-def write_tokenizer(input_tokenizer_path, save_path, push_to_hub=False):
-    # Initialize the tokenizer based on the `spm` model
-    tokenizer_class = GemmaTokenizer if GemmaTokenizerFast is None else GemmaTokenizerFast
-    print(f"Saving a {tokenizer_class.__name__} to {save_path}.")
-    tokenizer = tokenizer_class(input_tokenizer_path)
-    if push_to_hub:
-        tokenizer.push_to_hub(save_path)
-    else:
-        tokenizer.save_pretrained(save_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_checkpoint",
-        help="Absolute path to the target Gemma2 weights.",
-        required=True,
-    )
-    parser.add_argument(
-        "--tokenizer_checkpoint",
-        help="Location of Gemma2 tokenizer model",
-    )
-    parser.add_argument(
-        "--model_size",
-        default="9B",
-        choices=["9B", "27B", "tokenizer_only"],
-        help="'f' models correspond to the finetuned versions, and are specific to the Gemma22 official release. For more details on Gemma2, checkout the original repo: https://huggingface.co/google/gemma-7b",
-    )
-    parser.add_argument(
-        "--output_dir",
-        default="google/gemma-9b",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--pickle_serialization",
-        help="Whether or not to save using `safetensors`.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--convert_tokenizer",
-        help="Whether or not to convert the tokenizer as well.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        help="Whether or not to push the model to the hub at `output_dir` instead of saving it locally.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--dtype",
-        default="float32",
-        help="Target dtype of the converted model",
-    )
-    args = parser.parse_args()
-
-    if args.convert_tokenizer:
-        if args.tokenizer_checkpoint is None:
-            raise ValueError("Path to the tokenizer is required when passing --convert_tokenizer")
-
-        spm_path = os.path.join(args.tokenizer_checkpoint)
-        write_tokenizer(spm_path, args.output_dir, args.push_to_hub)
-    if not args.model_size == "tokenizer_only":
-        config = CONFIG_MAPPING[args.model_size]
-        dtype = getattr(torch, args.dtype)
-        write_model(
-            config=config,
-            input_base_path=args.input_checkpoint,
-            save_path=args.output_dir,
-            safe_serialization=not args.pickle_serialization,
-            push_to_hub=args.push_to_hub,
-            dtype=dtype,
-        )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/gemma3/convert_gemma3_weights_orbax_to_hf.py b/src/transformers/models/gemma3/convert_gemma3_weights_orbax_to_hf.py
deleted file mode 100644
index 2d8ecf4ac730..000000000000
--- a/src/transformers/models/gemma3/convert_gemma3_weights_orbax_to_hf.py
+++ /dev/null
@@ -1,589 +0,0 @@
-# coding=utf-8
-# Copyright 2025 Google Inc. HuggingFace Inc. team. All rights reserved.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-r"""Utility to convert Gemma models from Orbax to HF Transformers checkpoint.
-
-python -m transformers.models.gemma3.convert_gemma3_weights_orbax_to_hf \
-    --variant='gemma3_4b' \
-    --tokenizer_path="$HOME/gemma3/tokenizer/gemma3_cleaned_262144_v2.spiece.model" \
-    --checkpoint_path="$HOME/gemma3/gemma3_4b_pt_orbax/" \
-    --output_path="$HOME/gemma3/gemma3_4b_pt_safetensors/"
-"""
-
-from collections.abc import Iterator, Sequence
-from typing import Any
-
-import accelerate
-import numpy as np
-import torch
-import tree
-from absl import app, flags, logging
-from orbax import checkpoint as obc
-
-from transformers import (
-    Gemma3Config,
-    Gemma3ForCausalLM,
-    Gemma3ForConditionalGeneration,
-    Gemma3ImageProcessor,
-    Gemma3Processor,
-    Gemma3TextConfig,
-    GemmaTokenizerFast,
-    GenerationConfig,
-    SiglipVisionConfig,
-)
-from transformers.image_utils import PILImageResampling
-
-
-# ==== Internal Constants and Classes ====
-
-
-_CHAT_TEMPLATE = """{{ bos_token }}
-{%- if messages[0]['role'] == 'system' -%}
-    {%- if messages[0]['content'] is string -%}
-        {%- set first_user_prefix = messages[0]['content'] + '\n\n' -%}
-    {%- else -%}
-        {%- set first_user_prefix = messages[0]['content'][0]['text'] + '\n\n' -%}
-    {%- endif -%}
-    {%- set loop_messages = messages[1:] -%}
-{%- else -%}
-    {%- set first_user_prefix = "" -%}
-    {%- set loop_messages = messages -%}
-{%- endif -%}
-{%- for message in loop_messages -%}
-    {%- if (message['role'] == 'user') != (loop.index0 % 2 == 0) -%}
-        {{ raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") }}
-    {%- endif -%}
-    {%- if (message['role'] == 'assistant') -%}
-        {%- set role = "model" -%}
-    {%- else -%}
-        {%- set role = message['role'] -%}
-    {%- endif -%}
-    {{ '<start_of_turn>' + role + '\n' + (first_user_prefix if loop.first else "") }}
-    {%- if message['content'] is string -%}
-        {{ message['content'] | trim }}
-    {%- elif message['content'] is iterable -%}
-        {%- for item in message['content'] -%}
-            {%- if item['type'] == 'image' -%}
-                {{ '<start_of_image>' }}
-            {%- elif item['type'] == 'text' -%}
-                {{ item['text'] | trim }}
-            {%- endif -%}
-        {%- endfor -%}
-    {%- else -%}
-        {{ raise_exception("Invalid content type") }}
-    {%- endif -%}
-    {{ '<end_of_turn>\n' }}
-{%- endfor -%}
-{%- if add_generation_prompt -%}
-    {{'<start_of_turn>model\n'}}
-{%- endif -%}
-"""
-
-_DTYPES = {"float32", "bfloat16", "float16"}
-
-_SIGLIP_BASE = "SigLiPFromPatches_0/siglip_encoder"
-_SIGLIP_EMBEDDING = "SigLiPFromPatches_0/siglip_encoder/embedding"
-_SIGLIP_TRANSFORMER_ENCODER_BLOCK = "SigLiPFromPatches_0/siglip_encoder/Transformer/encoderblock_"
-_SIGLIP_TRANSFORMER_ENCODER_BLOCK_LEN = len(_SIGLIP_TRANSFORMER_ENCODER_BLOCK)
-_SIGLIP_TRANSFORMER_ENCODER_NORM = "SigLiPFromPatches_0/siglip_encoder/Transformer/encoder_norm"
-
-_TRANSFORMER_DECODER_BLOCK = "transformer/layer_"
-_TRANSFORMER_DECODER_BLOCK_LEN = len(_TRANSFORMER_DECODER_BLOCK)
-_TRANSFORMER_EMBEDDER = "transformer/embedder"
-_TRANSFORMER_FINAL_NORM = "transformer/final_norm"
-_TRANSFORMER_POST_TRAINING_PREFIX = "rlx_networks/policy_network/"
-_TRANSFORMER_POST_TRAINING_PREFIX_LEN = len(_TRANSFORMER_POST_TRAINING_PREFIX)
-
-_VISION_CONFIG = {
-    "hidden_size": 1152,
-    "intermediate_size": 4304,
-    "num_hidden_layers": 27,
-    "num_attention_heads": 16,
-    "num_channels": 3,
-    "image_size": 896,
-    "patch_size": 14,
-    "hidden_act": "gelu_pytorch_tanh",
-    "layer_norm_eps": 1e-6,
-    "attention_dropout": 0.0,
-    "vision_use_head": False,
-}
-
-_VARIANT_GEMMA_3_1B = "gemma3_1b"
-_VARIANT_GEMMA_3_4B = "gemma3_4b"
-_VARIANT_GEMMA_3_12B = "gemma3_12b"
-_VARIANT_GEMMA_3_27B = "gemma3_27b"
-_VARIANTS = {
-    _VARIANT_GEMMA_3_1B: Gemma3Config(
-        text_config=Gemma3TextConfig(
-            vocab_size=262_144,
-            hidden_size=1152,
-            intermediate_size=6 * 1152,
-            num_attention_heads=4,
-            num_hidden_layers=26,
-            num_key_value_heads=1,
-            head_dim=256,
-            sliding_window=512,
-            rope_theta=1_000_000,  # used for global RoPE only
-            rope_local_base_freq=10_000,
-            attn_logit_softcapping=None,
-            query_pre_attn_scalar=256,
-            max_position_embeddings=32_768,
-        ),
-        vision_config=None,
-    ),
-    _VARIANT_GEMMA_3_4B: Gemma3Config(
-        text_config=Gemma3TextConfig(
-            vocab_size=262_208,
-            hidden_size=2560,
-            intermediate_size=2560 * 8 // 2,
-            num_attention_heads=8,
-            head_dim=256,
-            num_hidden_layers=34,
-            num_key_value_heads=4,
-            sliding_window=1024,
-            rope_scaling={"rope_type": "linear", "factor": 8.0},  # used for global RoPE only
-            rope_theta=1_000_000,
-            rope_local_base_freq=10_000,
-            attn_logit_softcapping=None,
-            query_pre_attn_scalar=256,
-        ),
-        vision_config=_VISION_CONFIG,
-    ),
-    _VARIANT_GEMMA_3_12B: Gemma3Config(
-        text_config=Gemma3TextConfig(
-            vocab_size=262_208,
-            hidden_size=30 * 128,
-            intermediate_size=30 * 128 * 8 // 2,
-            num_attention_heads=16,
-            head_dim=256,
-            num_hidden_layers=48,
-            num_key_value_heads=8,
-            sliding_window=1024,
-            rope_scaling={"rope_type": "linear", "factor": 8.0},  # used for global RoPE only
-            rope_theta=1_000_000,
-            rope_local_base_freq=10_000,
-            attn_logit_softcapping=None,
-            query_pre_attn_scalar=256,
-        ),
-        vision_config=_VISION_CONFIG,
-    ),
-    _VARIANT_GEMMA_3_27B: Gemma3Config(
-        text_config=Gemma3TextConfig(
-            vocab_size=262_208,
-            hidden_size=42 * 128,
-            intermediate_size=42 * 128 * 8 // 2,
-            num_attention_heads=32,
-            num_hidden_layers=62,
-            num_key_value_heads=16,
-            head_dim=128,
-            sliding_window=1024,
-            rope_scaling={"rope_type": "linear", "factor": 8.0},  # used for global RoPE only
-            rope_theta=1_000_000,
-            rope_local_base_freq=10_000,
-            attn_logit_softcapping=None,
-            query_pre_attn_scalar=(42 * 128 // 32),  # 1 / sqrt(hidden_size // num_attention_heads)
-        ),
-        vision_config=_VISION_CONFIG,
-    ),
-}
-
-# ==== Flags ====
-
-_CHECKPOINT_PATH = flags.DEFINE_string(
-    name="checkpoint_path",
-    default=None,
-    help="Path to the Orbax checkpoint.",
-    required=True,
-)
-
-_INCLUDE_CHAT_TEMPLATE = flags.DEFINE_bool(
-    name="include_chat_template", default=False, help="If true, will save the default chat template with the tokenizer"
-)
-
-_OUTPUT_PATH = flags.DEFINE_string(
-    name="output_path",
-    default=None,
-    help="Path to store the HF checkpoint.",
-    required=True,
-)
-
-_TRANSFORMER_DTYPE = flags.DEFINE_enum(
-    name="text_dtype",
-    default="bfloat16",
-    help="The floating point precision (aka dtype) of the model.",
-    enum_values=_DTYPES,
-)
-
-_TOKENIZER_PATH = flags.DEFINE_string(
-    name="tokenizer_path",
-    default=None,
-    help="Path to the SentencePiece model file.",
-    required=True,
-)
-
-_VARIANT = flags.DEFINE_enum(
-    name="variant",
-    default=_VARIANT_GEMMA_3_4B,
-    help="The model variant to convert.",
-    enum_values=set(_VARIANTS.keys()),
-)
-
-_VERBOSE = flags.DEFINE_bool(
-    name="verbose",
-    default=False,
-    help="If true, log the path, shape, and dtype of every converted layer.",
-)
-
-_VISION_DTYPE = flags.DEFINE_enum(
-    name="vision_dtype",
-    default="float32",
-    help="The floating point precision (aka dtype) of the model.",
-    enum_values=_DTYPES,
-)
-
-
-def convert_siglip_weight(
-    config: SiglipVisionConfig,
-    paths: Sequence[str],
-    weights: np.ndarray,
-) -> tuple[str, np.ndarray]:
-    path, prop = paths
-    normalized_path: str = ""
-    updated_weights: np.ndarray = None
-
-    if path == _SIGLIP_BASE:
-        normalized_path = "vision_tower.vision_model.embeddings.position_embedding.weight"
-        updated_weights = weights.reshape(-1, config.hidden_size)
-    elif path == _SIGLIP_EMBEDDING:
-        if prop == "kernel":
-            normalized_path = "vision_tower.vision_model.embeddings.patch_embedding.weight"
-            updated_weights = weights.transpose(3, 2, 0, 1)
-        elif prop == "bias":
-            normalized_path = "vision_tower.vision_model.embeddings.patch_embedding.bias"
-            updated_weights = weights
-        else:
-            raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `kernel`.")
-    elif path.startswith(_SIGLIP_TRANSFORMER_ENCODER_BLOCK):
-        encoder_block_path = path[_SIGLIP_TRANSFORMER_ENCODER_BLOCK_LEN:]
-        next_path_seperator_idx = encoder_block_path.find("/")
-        layer_idx = encoder_block_path[:next_path_seperator_idx]
-        encoder_block_path = encoder_block_path[next_path_seperator_idx:]
-        normalized_path = f"vision_tower.vision_model.encoder.layers.{layer_idx}"
-
-        if encoder_block_path.startswith("/LayerNorm"):
-            normalized_path += ".layer_norm1" if path.endswith("_0") else ".layer_norm2"
-
-            if prop == "scale":
-                normalized_path += ".weight"
-                updated_weights = weights.transpose()
-            elif prop == "bias":
-                normalized_path += ".bias"
-                updated_weights = weights
-            else:
-                raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `scale`.")
-        elif encoder_block_path.startswith("/MlpBlock_0"):
-            normalized_path += ".mlp.fc1" if "/Dense_0" in encoder_block_path else ".mlp.fc2"
-
-            if prop == "kernel":
-                normalized_path += ".weight"
-                updated_weights = weights.transpose()
-            elif prop == "bias":
-                normalized_path += ".bias"
-                updated_weights = weights
-            else:
-                raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `kernel`.")
-        elif encoder_block_path.startswith("/MultiHeadDotProductAttention_0"):
-            if encoder_block_path.endswith("/key"):
-                normalized_path += ".self_attn.k_proj"
-            elif encoder_block_path.endswith("/out"):
-                normalized_path += ".self_attn.out_proj"
-            elif encoder_block_path.endswith("/query"):
-                normalized_path += ".self_attn.q_proj"
-            elif encoder_block_path.endswith("/value"):
-                normalized_path += ".self_attn.v_proj"
-            else:
-                raise ValueError(f"Unexpected path `{path}` in SigLIP Transformer MultiHeadDotProductAttention_0.")
-
-            if prop == "bias":
-                normalized_path += ".bias"
-                updated_weights = weights.reshape(-1, config.hidden_size).reshape(-1)
-            elif prop == "kernel":
-                normalized_path += ".weight"
-                updated_weights = weights.reshape(-1, config.hidden_size).transpose()
-            else:
-                raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `kernel`.")
-        else:
-            raise ValueError(f"Unexpected path `{path}` in SigLIP Transformer Encoder Block.")
-    elif path == _SIGLIP_TRANSFORMER_ENCODER_NORM:
-        if prop == "scale":
-            normalized_path = "vision_tower.vision_model.post_layernorm.weight"
-            updated_weights = weights.transpose()
-        elif prop == "bias":
-            normalized_path = "vision_tower.vision_model.post_layernorm.bias"
-            updated_weights = weights
-        else:
-            raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `scale`.")
-    else:
-        raise ValueError(f"Unexpected path `{path}`.")
-
-    return normalized_path, updated_weights
-
-
-def convert_transformer_weights(
-    config: Gemma3TextConfig,
-    paths: Sequence[str],
-    weights: np.ndarray,
-) -> Iterator[tuple[str, np.ndarray]]:
-    path, prop = paths
-
-    if path.startswith(_TRANSFORMER_POST_TRAINING_PREFIX):
-        path = path[_TRANSFORMER_POST_TRAINING_PREFIX_LEN:]
-
-    converted_paths: list[str] = []
-    converted_weights: list[Any] = []
-
-    attn_head_dim = config.num_attention_heads * config.head_dim
-    kv_head_dim = config.num_key_value_heads * config.head_dim
-
-    if path == _TRANSFORMER_EMBEDDER:
-        if prop == "input_embedding":
-            # Tied to language_model.lm_head.weight, assigned at the end.
-            converted_paths = ["language_model.model.embed_tokens.weight"]
-
-            if _VARIANT.value != _VARIANT_GEMMA_3_1B:
-                # Gemma3 model doesn't have image soft token in input and output embeddings, resize to avoid bugs we had with Mllama
-                pre_expansion_embeddings = weights
-                mu = np.mean(pre_expansion_embeddings, axis=0)
-                sigma = np.cov(pre_expansion_embeddings, rowvar=False, bias=True)
-                new_embeddings = np.random.multivariate_normal(mu, 1e-5 * sigma, size=64)
-                weights = np.vstack([pre_expansion_embeddings, new_embeddings])
-
-            converted_weights = [weights]
-        elif _VARIANT.value == _VARIANT_GEMMA_3_1B or prop in ("mm_output_embedding", "mm_input_embedding_extra"):
-            return zip([], [])
-        else:
-            raise ValueError(f"Unexpected member, {prop}, in Embedder.")
-    elif path.startswith(f"{_TRANSFORMER_EMBEDDER}/mm"):
-        if _VARIANT.value == _VARIANT_GEMMA_3_1B:
-            return zip([], [])
-
-        if path.endswith("/mm_input_projection"):
-            converted_paths = ["multi_modal_projector.mm_input_projection_weight"]
-            converted_weights = [weights]
-        elif path.endswith("/mm_soft_embedding_norm"):
-            converted_paths = ["multi_modal_projector.mm_soft_emb_norm.weight"]
-            converted_weights = [weights]
-        else:
-            raise ValueError(f"Unexpected subpath, `{path}`, in Embedder.")
-    elif path == _TRANSFORMER_FINAL_NORM:
-        converted_paths = ["language_model.model.norm.weight"]
-        converted_weights = [weights]
-    elif path.startswith(_TRANSFORMER_DECODER_BLOCK):
-        decoder_block_path = path[_TRANSFORMER_DECODER_BLOCK_LEN:]
-        next_path_seperator_idx = decoder_block_path.find("/")
-        layer_idx = decoder_block_path[:next_path_seperator_idx]
-        decoder_block_path = decoder_block_path[next_path_seperator_idx:]
-
-        base_path = f"language_model.model.layers.{layer_idx}"
-
-        if path.endswith("attn/attn_vec_einsum"):
-            converted_paths = [f"{base_path}.self_attn.o_proj.weight"]
-            converted_weights = [weights.transpose(2, 0, 1).reshape(config.hidden_size, attn_head_dim)]
-        elif path.endswith("attn/_key_norm"):
-            converted_paths = [f"{base_path}.self_attn.k_norm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("attn/kv_einsum"):
-            converted_paths = [
-                f"{base_path}.self_attn.k_proj.weight",
-                f"{base_path}.self_attn.v_proj.weight",
-            ]
-            k_proj_weights, v_proj_weights = weights
-            converted_weights = [
-                k_proj_weights.transpose(0, 2, 1).reshape(kv_head_dim, config.hidden_size),
-                v_proj_weights.transpose(0, 2, 1).reshape(kv_head_dim, config.hidden_size),
-            ]
-        elif path.endswith("attn/q_einsum"):
-            converted_paths = [f"{base_path}.self_attn.q_proj.weight"]
-            converted_weights = [weights.transpose(0, 2, 1).reshape(attn_head_dim, config.hidden_size)]
-        elif path.endswith("attn/_query_norm"):
-            converted_paths = [f"{base_path}.self_attn.q_norm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("mlp/gating_einsum"):
-            converted_paths = [
-                f"{base_path}.mlp.gate_proj.weight",
-                f"{base_path}.mlp.up_proj.weight",
-            ]
-            gate_proj_weight, up_proj_weight = weights
-            converted_weights = [gate_proj_weight, up_proj_weight]
-        elif path.endswith("mlp/linear"):
-            converted_paths = [f"{base_path}.mlp.down_proj.weight"]
-            converted_weights = [weights.transpose()]
-        elif path.endswith("post_attention_norm"):
-            converted_paths = [f"{base_path}.post_attention_layernorm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("post_ffw_norm"):
-            converted_paths = [f"{base_path}.post_feedforward_layernorm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("pre_attention_norm"):
-            converted_paths = [f"{base_path}.input_layernorm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("pre_ffw_norm"):
-            converted_paths = [f"{base_path}.pre_feedforward_layernorm.weight"]
-            converted_weights = [weights]
-        else:
-            raise ValueError(f"Unexpected path `{path}` in Decoder Block.")
-    else:
-        raise ValueError(f"Unexpected path `{path}`.")
-
-    if (cpl := len(converted_paths)) != (cwl := len(converted_weights)):
-        raise ValueError(
-            "The `converted_paths` and `converted_weights` should be the same "
-            f"length. Got {cpl} and {cwl}, respectively, for {path}."
-        )
-
-    return zip(converted_paths, converted_weights)
-
-
-def convert(checkpoint_path: str, config: Gemma3Config) -> dict[str, torch.Tensor]:
-    """Loads Orbax checkpoint from `input_path` and converts it to HF tree."""
-    checkpointer = obc.PyTreeCheckpointer()
-    ckpt = checkpointer.restore(checkpoint_path)
-    hf_tree: dict[str, torch.Tensor] = {}
-
-    def update_tree(path: str, weights: np.ndarray, target_dtype: torch.dtype) -> None:
-        hf_tree[path] = torch.from_numpy(weights.astype("float32")).type(target_dtype)
-        if _VERBOSE.value:
-            logging.info(
-                "%s converted shape=%s with dtype=%s",
-                path,
-                weights.shape,
-                target_dtype,
-            )
-
-    for paths, value in tree.flatten_with_path(ckpt):
-        if paths[0].startswith("SigLiPFromPatches_"):
-            if config.vision_config is None:
-                continue
-
-            path, weights = convert_siglip_weight(config=config.vision_config, paths=paths, weights=value)
-            update_tree(path, weights, config.vision_config.torch_dtype)
-        else:
-            for path, weights in convert_transformer_weights(config=config.text_config, paths=paths, weights=value):
-                if config.vision_config is None:
-                    path = path[len("language_model.") :]
-
-                update_tree(path, weights, config.text_config.torch_dtype)
-
-    if config.vision_config is None:
-        hf_tree["lm_head.weight"] = hf_tree["model.embed_tokens.weight"]
-    else:
-        hf_tree["language_model.lm_head.weight"] = hf_tree["language_model.model.embed_tokens.weight"]
-
-    return hf_tree
-
-
-def main(*args):
-    del args
-
-    output_path = _OUTPUT_PATH.value
-    variant = _VARIANT.value
-
-    config = _VARIANTS[variant]
-    config.text_config.torch_dtype = getattr(torch, _TRANSFORMER_DTYPE.value)
-    config.vision_config.torch_dtype = getattr(torch, _VISION_DTYPE.value)
-    if _INCLUDE_CHAT_TEMPLATE.value:
-        # Chat template is included for instruction tuned models, which treat
-        # both "<eos>" and "<end_of_turn>" as generation stoppers.
-        config.eos_token_id = [1, 106]
-
-    logging.info(
-        "Converting Gemma 3 (%s) @ %s (language) and %s (vision)",
-        variant,
-        _TRANSFORMER_DTYPE.value,
-        _VISION_DTYPE.value,
-    )
-    state_tree = convert(_CHECKPOINT_PATH.value, config)
-    logging.info("Converted Gemma 3 (%s) state tree from Orbax to Hugging Face.", variant)
-
-    with accelerate.init_empty_weights():
-        if variant == _VARIANT_GEMMA_3_1B:
-            model = Gemma3ForCausalLM(config=config.text_config)
-        else:
-            model = Gemma3ForConditionalGeneration(config)
-
-    model.load_state_dict(state_tree, assign=True, strict=True)
-    logging.info(
-        "Loaded Gemma 3 (%s) in Hugging Face Transformers as a %s instance.",
-        variant,
-        type(model).__name__,
-    )
-    model.save_pretrained(output_path, safe_serialization=True)
-    logging.info(
-        "Saved Gemma 3 (%s) to SafeTensors in %s using %s",
-        variant,
-        output_path,
-        type(model).__name__,
-    )
-    del model
-    del state_tree
-
-    tokenizer = GemmaTokenizerFast(
-        _TOKENIZER_PATH.value,
-        add_bos_token=True,
-        extra_special_tokens={
-            "image_token": "<image_soft_token>",  # Should be ID=262_144
-            "boi_token": "<start_of_image>",  # Should be ID=255_999
-            "eoi_token": "<end_of_image>",  # Should be ID=256_000
-        },
-        chat_template=_CHAT_TEMPLATE if _INCLUDE_CHAT_TEMPLATE.value else None,
-    )
-    tokenizer.save_pretrained(output_path)
-    logging.info("Saved GemmaTokenizer for %s to %s", variant, output_path)
-
-    if variant != _VARIANT_GEMMA_3_1B:
-        image_processor = Gemma3ImageProcessor(
-            image_seq_length=256,
-            image_mean=(0.5,) * 3,
-            image_std=(0.5,) * 3,
-            size={"height": 896, "width": 896},
-            resample=PILImageResampling.BILINEAR,
-        )
-        processor = Gemma3Processor(
-            image_processor=image_processor,
-            tokenizer=tokenizer,
-            chat_template=tokenizer.chat_template,
-        )
-        processor.save_pretrained(output_path)
-        logging.info("Saved Gemma3Processor for %s to %s", variant, output_path)
-        del processor
-
-    del tokenizer
-
-    generation_config = GenerationConfig(
-        pad_token_id=config.pad_token_id,
-        bos_token_id=config.bos_token_id,
-        eos_token_id=config.eos_token_id,
-        cache_implementation="hybrid",
-        temperature=1.0,
-        do_sample=True,
-        top_k=64,
-        top_p=0.95,
-    )
-    generation_config.save_pretrained(output_path)
-
-
-if __name__ == "__main__":
-    app.run(main)
diff --git a/src/transformers/models/git/convert_git_to_pytorch.py b/src/transformers/models/git/convert_git_to_pytorch.py
deleted file mode 100644
index 2f93a6b03a65..000000000000
--- a/src/transformers/models/git/convert_git_to_pytorch.py
+++ /dev/null
@@ -1,448 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert GIT checkpoints from the original repository.
-
-URL: https://github.com/microsoft/GenerativeImage2Text/tree/main"""
-
-import argparse
-from pathlib import Path
-
-import av
-import numpy as np
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision.transforms import CenterCrop, Compose, Normalize, Resize, ToTensor
-
-from transformers import (
-    AutoTokenizer,
-    CLIPImageProcessor,
-    GitConfig,
-    GitForCausalLM,
-    GitProcessor,
-    GitVisionConfig,
-    VideoMAEImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_git_config(model_name):
-    if "base" in model_name and "vqa" in model_name:
-        image_size = 480
-    elif "large" in model_name and "vqa" in model_name:
-        image_size = 420
-    else:
-        image_size = 224
-
-    vision_config = GitVisionConfig(image_size=image_size)
-
-    if "large" in model_name:
-        vision_config.patch_size = 14
-        vision_config.hidden_size = 1024
-        vision_config.intermediate_size = 4096
-        vision_config.num_hidden_layers = 24
-        vision_config.num_attention_heads = 16
-
-    is_video = "vatex" in model_name or "msrvtt" in model_name
-    num_image_with_embedding = 6 if is_video else None
-    config = GitConfig(vision_config=vision_config.to_dict(), num_image_with_embedding=num_image_with_embedding)
-
-    return config, image_size, is_video
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, prefix=""):
-    rename_keys = []
-
-    # image encoder
-    # ftm: off
-    rename_keys.append(
-        (f"{prefix}image_encoder.class_embedding", "git.image_encoder.vision_model.embeddings.class_embedding")
-    )
-    rename_keys.append(
-        (
-            f"{prefix}image_encoder.positional_embedding",
-            "git.image_encoder.vision_model.embeddings.position_embedding.weight",
-        )
-    )
-    rename_keys.append(
-        (f"{prefix}image_encoder.conv1.weight", "git.image_encoder.vision_model.embeddings.patch_embedding.weight")
-    )
-    rename_keys.append((f"{prefix}image_encoder.ln_pre.weight", "git.image_encoder.vision_model.pre_layrnorm.weight"))
-    rename_keys.append((f"{prefix}image_encoder.ln_pre.bias", "git.image_encoder.vision_model.pre_layrnorm.bias"))
-    rename_keys.append(
-        (f"{prefix}image_encoder.ln_post.weight", "git.image_encoder.vision_model.post_layernorm.weight")
-    )
-    rename_keys.append((f"{prefix}image_encoder.ln_post.bias", "git.image_encoder.vision_model.post_layernorm.bias"))
-    # fmt: on
-    rename_keys.append((f"{prefix}image_encoder.proj", "git.image_encoder.visual_projection.weight"))
-
-    # fmt: off
-    for i in range(config.vision_config.num_hidden_layers):
-        # image encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.attn.out_proj.weight", f"git.image_encoder.vision_model.encoder.layers.{i}.self_attn.out_proj.weight"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.attn.out_proj.bias", f"git.image_encoder.vision_model.encoder.layers.{i}.self_attn.out_proj.bias"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.ln_1.weight", f"git.image_encoder.vision_model.encoder.layers.{i}.layer_norm1.weight"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.ln_1.bias", f"git.image_encoder.vision_model.encoder.layers.{i}.layer_norm1.bias"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.mlp.c_fc.weight", f"git.image_encoder.vision_model.encoder.layers.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.mlp.c_fc.bias", f"git.image_encoder.vision_model.encoder.layers.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.mlp.c_proj.weight", f"git.image_encoder.vision_model.encoder.layers.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.mlp.c_proj.bias", f"git.image_encoder.vision_model.encoder.layers.{i}.mlp.fc2.bias"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.ln_2.weight", f"git.image_encoder.vision_model.encoder.layers.{i}.layer_norm2.weight"))
-        rename_keys.append((f"{prefix}image_encoder.transformer.resblocks.{i}.ln_2.bias", f"git.image_encoder.vision_model.encoder.layers.{i}.layer_norm2.bias"))
-    # fmt: on
-
-    # text decoder
-    # fmt: off
-    rename_keys.append((f"{prefix}textual.embedding.words.weight", "git.embeddings.word_embeddings.weight"))
-    rename_keys.append((f"{prefix}textual.embedding.positions.weight", "git.embeddings.position_embeddings.weight"))
-    rename_keys.append((f"{prefix}textual.visual_projection.0.weight", "git.visual_projection.visual_projection.0.weight"))
-    rename_keys.append((f"{prefix}textual.visual_projection.0.bias", "git.visual_projection.visual_projection.0.bias"))
-    rename_keys.append((f"{prefix}textual.visual_projection.1.weight", "git.visual_projection.visual_projection.1.weight"))
-    rename_keys.append((f"{prefix}textual.visual_projection.1.bias", "git.visual_projection.visual_projection.1.bias"))
-
-    rename_keys.append((f"{prefix}textual.embedding.layer_norm.weight", "git.embeddings.LayerNorm.weight"))
-    rename_keys.append((f"{prefix}textual.embedding.layer_norm.bias", "git.embeddings.LayerNorm.bias"))
-    rename_keys.append((f"{prefix}textual.output.weight", "output.weight"))
-    rename_keys.append((f"{prefix}textual.output.bias", "output.bias"))
-    for i in range(config.num_hidden_layers):
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.self.query.weight", f"git.encoder.layer.{i}.attention.self.query.weight"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.self.query.bias", f"git.encoder.layer.{i}.attention.self.query.bias"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.self.key.weight", f"git.encoder.layer.{i}.attention.self.key.weight"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.self.key.bias", f"git.encoder.layer.{i}.attention.self.key.bias"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.self.value.weight", f"git.encoder.layer.{i}.attention.self.value.weight"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.self.value.bias", f"git.encoder.layer.{i}.attention.self.value.bias"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.output.dense.weight", f"git.encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.output.dense.bias", f"git.encoder.layer.{i}.attention.output.dense.bias"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.output.LayerNorm.weight", f"git.encoder.layer.{i}.attention.output.LayerNorm.weight"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.attention.output.LayerNorm.bias", f"git.encoder.layer.{i}.attention.output.LayerNorm.bias"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.intermediate.dense.weight", f"git.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.intermediate.dense.bias", f"git.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.output.dense.weight", f"git.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.output.dense.bias", f"git.encoder.layer.{i}.output.dense.bias"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.output.LayerNorm.weight", f"git.encoder.layer.{i}.output.LayerNorm.weight"))
-        rename_keys.append((f"{prefix}textual.transformer.encoder.layer.{i}.output.LayerNorm.bias", f"git.encoder.layer.{i}.output.LayerNorm.bias"))
-    # fmt: on
-
-    if config.num_image_with_embedding is not None:
-        rename_keys.append(("img_temperal_embedding.0", "git.img_temperal_embedding.0"))
-        rename_keys.append(("img_temperal_embedding.1", "git.img_temperal_embedding.1"))
-        rename_keys.append(("img_temperal_embedding.2", "git.img_temperal_embedding.2"))
-        rename_keys.append(("img_temperal_embedding.3", "git.img_temperal_embedding.3"))
-        rename_keys.append(("img_temperal_embedding.4", "git.img_temperal_embedding.4"))
-        rename_keys.append(("img_temperal_embedding.5", "git.img_temperal_embedding.5"))
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val.T if "image_encoder.visual_projection" in new else val
-
-
-# we split up the matrix of each CLIP encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, prefix=""):
-    dim = config.vision_config.hidden_size
-    for i in range(config.vision_config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in the original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"{prefix}image_encoder.transformer.resblocks.{i}.attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}image_encoder.transformer.resblocks.{i}.attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"git.image_encoder.vision_model.encoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[
-            :dim, :
-        ]
-        state_dict[f"git.image_encoder.vision_model.encoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:dim]
-        state_dict[f"git.image_encoder.vision_model.encoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[
-            dim : dim * 2, :
-        ]
-        state_dict[f"git.image_encoder.vision_model.encoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[
-            dim : dim * 2
-        ]
-        state_dict[f"git.image_encoder.vision_model.encoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[
-            -dim:, :
-        ]
-        state_dict[f"git.image_encoder.vision_model.encoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-dim:]
-
-
-# We will verify our results on an image
-def prepare_img(model_name):
-    if "textvqa" in model_name:
-        filepath = hf_hub_download(repo_id="nielsr/textvqa-sample", filename="bus.png", repo_type="dataset")
-        image = Image.open(filepath).convert("RGB")
-    else:
-        url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-        image = Image.open(requests.get(url, stream=True).raw)
-
-    return image
-
-
-def prepare_video():
-    def read_video_pyav(container, indices):
-        """
-        Decode the video with PyAV decoder.
-
-        Args:
-            container (`av.container.input.InputContainer`): PyAV container.
-            indices (`List[int]`): List of frame indices to decode.
-
-        Returns:
-            result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
-        """
-        frames = []
-        container.seek(0)
-        start_index = indices[0]
-        end_index = indices[-1]
-        for i, frame in enumerate(container.decode(video=0)):
-            if i > end_index:
-                break
-            if i >= start_index and i in indices:
-                frames.append(frame)
-        return np.stack([x.to_ndarray(format="rgb24") for x in frames])
-
-    def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
-        """
-        Sample a given number of frame indices from the video.
-
-        Args:
-            clip_len (`int`): Total number of frames to sample.
-            frame_sample_rate (`int`): Sample every n-th frame.
-            seg_len (`int`): Maximum allowed index of sample's last frame.
-
-        Returns:
-            indices (`List[int]`): List of sampled frame indices
-        """
-        converted_len = int(clip_len * frame_sample_rate)
-        end_idx = np.random.randint(converted_len, seg_len)
-        start_idx = end_idx - converted_len
-        indices = np.linspace(start_idx, end_idx, num=clip_len)
-        indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
-        return indices
-
-    # set seed for reproducibility
-    np.random.seed(0)
-
-    file_path = hf_hub_download(repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset")
-    with av.open(file_path) as container:
-        # sample 6 frames
-        num_frames = 6
-        indices = sample_frame_indices(
-            clip_len=num_frames, frame_sample_rate=4, seg_len=container.streams.video[0].frames
-        )
-        frames = read_video_pyav(container, indices)
-
-        return frames
-
-
-@torch.no_grad()
-def convert_git_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our GIT structure.
-    """
-
-    model_name_to_url = {
-        "git-base": "https://publicgit.blob.core.windows.net/data/output/GIT_BASE/snapshot/model.pt",
-        "git-base-coco": "https://publicgit.blob.core.windows.net/data/output/GIT_BASE_COCO/snapshot/model.pt",
-        "git-base-textcaps": "https://publicgit.blob.core.windows.net/data/output/GIT_BASE_TEXTCAPS/snapshot/model.pt",
-        "git-base-vqav2": "https://publicgit.blob.core.windows.net/data/output/GIT_BASE_VQAv2/snapshot/model.pt",
-        "git-base-textvqa": "https://publicgit.blob.core.windows.net/data/output/GIT_BASE_TEXTVQA/snapshot/model.pt",  # todo
-        "git-base-vatex": "https://publicgit.blob.core.windows.net/data/output/GIT_BASE_VATEX/snapshot/model.pt",
-        "git-base-msrvtt-qa": (
-            "https://publicgit.blob.core.windows.net/data/output/GIT_BASE_MSRVTT_QA/snapshot/model.pt"
-        ),
-        "git-large": "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE/snapshot/model.pt",
-        "git-large-coco": "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_COCO/snapshot/model.pt",
-        "git-large-textcaps": (
-            "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_TEXTCAPS/snapshot/model.pt"
-        ),
-        "git-large-vqav2": "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_VQAv2/snapshot/model.pt",
-        "git-large-textvqa": "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_TEXTVQA/snapshot/model.pt",
-        "git-large-vatex": "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_VATEX/snapshot/model.pt",
-        "git-large-msrvtt-qa": (
-            "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_MSRVTT_QA/snapshot/model.pt"
-        ),
-        "git-large-r": "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_R/snapshot/model.pt",
-        "git-large-r-coco": "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_R_COCO/snapshot/model.pt",
-        "git-large-r-textcaps": (
-            "https://publicgit.blob.core.windows.net/data/output/GIT_LARGE_R_TEXTCAPS/snapshot/model.pt"
-        ),
-    }
-
-    model_name_to_path = {
-        "git-large": "/Users/nielsrogge/Documents/GIT/git_large_model.pt",
-        "git-large-coco": "/Users/nielsrogge/Documents/GIT/git_large_coco_model.pt",
-        "git-large-textcaps": "/Users/nielsrogge/Documents/GIT/git_large_textcaps_model.pt",
-        "git-large-vqav2": "/Users/nielsrogge/Documents/GIT/git_large_vqav2_model.pt",
-        "git-large-textvqa": "/Users/nielsrogge/Documents/GIT/git_large_textvqa_model.pt",
-    }
-
-    # define GIT configuration based on model name
-    config, image_size, is_video = get_git_config(model_name)
-    if "large" in model_name and not is_video and "large-r" not in model_name:
-        # large checkpoints take way too long to download
-        checkpoint_path = model_name_to_path[model_name]
-        state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-    else:
-        checkpoint_url = model_name_to_url[model_name]
-        state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu", file_name=model_name)[
-            "model"
-        ]
-    # rename keys
-    prefix = "module." if model_name == "git-base" else ""
-    rename_keys = create_rename_keys(config, prefix=prefix)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config, prefix=prefix)
-
-    # load HuggingFace model
-    model = GitForCausalLM(config)
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    model.eval()
-
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-
-    assert missing_keys == ["git.embeddings.position_ids", "git.image_encoder.vision_model.embeddings.position_ids"]
-    assert unexpected_keys == ["git.image_encoder.visual_projection.weight"]
-
-    # verify results
-    image_processor = (
-        VideoMAEImageProcessor(
-            size={"shortest_edge": image_size}, crop_size={"height": image_size, "width": image_size}
-        )
-        if is_video
-        else CLIPImageProcessor(
-            size={"shortest_edge": image_size}, crop_size={"height": image_size, "width": image_size}
-        )
-    )
-    tokenizer = AutoTokenizer.from_pretrained(
-        "google-bert/bert-base-uncased", model_input_names=["input_ids", "attention_mask"]
-    )
-    processor = GitProcessor(tokenizer=tokenizer, image_processor=image_processor)
-
-    if is_video:
-        video = prepare_video()
-        pixel_values = processor(images=list(video), return_tensors="pt").pixel_values
-    else:
-        image = prepare_img(model_name)
-        image_transforms = Compose(
-            [
-                Resize(image_size, interpolation=Image.BICUBIC),
-                CenterCrop(image_size),
-                ToTensor(),
-                Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),
-            ]
-        )
-        original_pixel_values = image_transforms(image).unsqueeze(0)
-        pixel_values = processor(images=image, return_tensors="pt").pixel_values
-
-        assert torch.allclose(pixel_values, original_pixel_values)
-
-    input_ids = torch.tensor([[101]])
-    outputs = model(input_ids, pixel_values=pixel_values)
-    logits = outputs.logits
-    print("Logits:", logits[0, -1, :3])
-
-    if model_name == "git-base":
-        expected_slice_logits = torch.tensor([-1.2832, -1.2835, -1.2840])
-    elif model_name == "git-base-coco":
-        expected_slice_logits = torch.tensor([-0.9925, -0.9930, -0.9935])
-    elif model_name == "git-base-textcaps":
-        expected_slice_logits = torch.tensor([-1.2980, -1.2983, -1.2985])
-    elif model_name == "git-base-vqav2":
-        expected_slice_logits = torch.tensor([-0.8570, -0.8568, -0.8561])
-    elif model_name == "git-base-textvqa":
-        expected_slice_logits = torch.tensor([-1.4085, -1.4083, -1.4082])
-    elif model_name == "git-base-vatex":
-        expected_slice_logits = torch.tensor([-1.3451, -1.3447, -1.3447])
-    elif model_name == "git-base-msrvtt-qa":
-        expected_slice_logits = torch.tensor([-0.8554, -0.8550, -0.8540])
-    elif model_name == "git-large":
-        expected_slice_logits = torch.tensor([-1.1708, -1.1707, -1.1705])
-    elif model_name == "git-large-coco":
-        expected_slice_logits = torch.tensor([-1.0425, -1.0423, -1.0422])
-    elif model_name == "git-large-textcaps":
-        expected_slice_logits = torch.tensor([-1.2705, -1.2708, -1.2706])
-    elif model_name == "git-large-vqav2":
-        expected_slice_logits = torch.tensor([-0.7042, -0.7043, -0.7043])
-    elif model_name == "git-large-textvqa":
-        expected_slice_logits = torch.tensor([-0.8590, -0.8592, -0.8590])
-    elif model_name == "git-large-vatex":
-        expected_slice_logits = torch.tensor([-1.0113, -1.0114, -1.0113])
-    elif model_name == "git-large-msrvtt-qa":
-        expected_slice_logits = torch.tensor([0.0130, 0.0134, 0.0131])
-    elif model_name == "git-large-r":
-        expected_slice_logits = torch.tensor([-1.1283, -1.1285, -1.1286])
-    elif model_name == "git-large-r-coco":
-        expected_slice_logits = torch.tensor([-0.9641, -0.9641, -0.9641])
-    elif model_name == "git-large-r-textcaps":
-        expected_slice_logits = torch.tensor([-1.1121, -1.1120, -1.1124])
-
-    assert torch.allclose(logits[0, -1, :3], expected_slice_logits, atol=1e-4)
-    print("Looks ok!")
-
-    prompt = ""
-    if "textvqa" in model_name:
-        prompt = "what does the front of the bus say at the top?"
-    elif "msrvtt-qa" in model_name:
-        prompt = "what does the woman eat?"
-    elif "vqa" in model_name:
-        prompt = "what are the cats doing?"
-    input_ids = tokenizer(prompt, add_special_tokens=False).input_ids
-    input_ids = [processor.tokenizer.cls_token_id] + input_ids
-    input_ids = torch.tensor(input_ids).unsqueeze(0)
-    print("Generating caption...")
-    generated_ids = model.generate(pixel_values=pixel_values, input_ids=input_ids, max_length=50)
-    print("Generated caption:", processor.batch_decode(generated_ids, skip_special_tokens=True))
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model and processor of {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and processor of {model_name} to the hub...")
-        model.push_to_hub(f"microsoft/{model_name}")
-        processor.push_to_hub(f"microsoft/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="git-base",
-        type=str,
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model to the hub.",
-    )
-
-    args = parser.parse_args()
-    convert_git_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/glm/convert_glm_weights_to_hf.py b/src/transformers/models/glm/convert_glm_weights_to_hf.py
deleted file mode 100644
index 1053f984d7f0..000000000000
--- a/src/transformers/models/glm/convert_glm_weights_to_hf.py
+++ /dev/null
@@ -1,195 +0,0 @@
-import argparse
-import json
-import os
-import re
-
-import torch
-from safetensors.torch import load_file
-from tokenizers import processors
-
-from transformers import GlmConfig, GlmForCausalLM, PreTrainedTokenizerFast
-
-
-# fmt: off
-# `None` means we drop the key
-STATE_DICT_MAPPING = {
-    # CausalLM keys
-    r"transformer.output_layer.weight":                                               r"lm_head.weight",
-
-    # Model keys
-    r"transformer.embedding.word_embeddings.weight":                                  r"model.embed_tokens.weight",
-    r"transformer.rotary_pos_emb.inv_freq":                                           None,
-    r"transformer.encoder.final_layernorm.weight":                                    r"model.norm.weight",
-
-    # Layers keys
-    r"transformer.encoder.layers.(\d+).input_layernorm.weight":                       r"model.layers.\1.input_layernorm.weight",
-    r"transformer.encoder.layers.(\d+).post_attention_layernorm.weight":              r"model.layers.\1.post_attention_layernorm.weight",
-
-    # Attention keys
-    r"transformer.encoder.layers.(\d+).self_attention.dense.weight":                  r"model.layers.\1.self_attn.o_proj.weight",
-    # qkv_proj will later be split in q|k|v|_proj
-    r"transformer.encoder.layers.(\d+).self_attention.query_key_value.(weight|bias)": r"model.layers.\1.self_attn.qkv_proj.\2",
-
-    # MLP keys
-    r"transformer.encoder.layers.(\d+).mlp.dense_h_to_4h.weight":                     r"model.layers.\1.mlp.gate_up_proj.weight",
-    r"transformer.encoder.layers.(\d+).mlp.dense_4h_to_h.weight":                     r"model.layers.\1.mlp.down_proj.weight",
-}
-# fmt: on
-
-
-def load_weights(input_dir: str):
-    safetensor_files = [os.path.join(input_dir, x) for x in os.listdir(input_dir) if x.endswith(".safetensors")]
-    bin_files = [os.path.join(input_dir, x) for x in os.listdir(input_dir) if x.endswith(".bin")]
-
-    all_weights = {}
-
-    if safetensor_files:
-        safetensor_files = sorted(safetensor_files, key=lambda x: int(x.rsplit("-", 3)[1]))
-        for file in safetensor_files:
-            tensors = load_file(file)
-            all_weights.update(tensors)
-        return all_weights
-
-    elif bin_files:
-        bin_files = sorted(bin_files, key=lambda x: int(x.rsplit("-", 3)[1]))
-        for file in bin_files:
-            tensors = torch.load(file, map_location="cpu")
-            all_weights.update(tensors)
-        return all_weights
-
-    else:
-        raise ValueError("No .safetensors or .bin files found in the specified directory.")
-
-
-def map_old_key_to_new(old_key):
-    for pattern, replacement in STATE_DICT_MAPPING.items():
-        if replacement is None:
-            if re.fullmatch(pattern, old_key):
-                return None
-        else:
-            new_key, n_replace = re.subn(pattern, replacement, old_key)
-            # Early exit of the loop
-            if n_replace > 0:
-                return new_key
-
-    raise ValueError(f"Key: {old_key} could not be mapped (check the mapping).")
-
-
-def convert_state_dict(original_state_dict: dict, config: GlmConfig):
-    new_dict = {}
-
-    head_dim = config.hidden_size // config.num_attention_heads
-    query_size = config.num_attention_heads * head_dim
-    kv_size = config.num_key_value_heads * head_dim
-
-    for old_key, value in original_state_dict.items():
-        new_key = map_old_key_to_new(old_key)
-        if new_key is None:
-            continue
-
-        if "qkv_proj." in new_key:
-            q_proj, k_proj, v_proj = (
-                value[:query_size, ...],
-                value[query_size : query_size + kv_size, ...],
-                value[query_size + kv_size :, ...],
-            )
-            new_dict[new_key.replace("qkv_proj.", "q_proj.")] = q_proj
-            new_dict[new_key.replace("qkv_proj.", "k_proj.")] = k_proj
-            new_dict[new_key.replace("qkv_proj.", "v_proj.")] = v_proj
-        else:
-            new_dict[new_key] = value
-    return new_dict
-
-
-def convert_config(original_config: dict):
-    key_mapping = {
-        "vocab_size": "padded_vocab_size",
-        "intermediate_size": "ffn_hidden_size",
-        "num_hidden_layers": "num_layers",
-        "max_position_embeddings": "seq_length",
-        "rms_norm_eps": "layernorm_epsilon",
-        "head_dim": "kv_channels",
-        "attention_bias": "add_qkv_bias",
-    }
-    similar_keys_to_keep = [
-        "num_attention_heads",
-        "hidden_size",
-        "attention_dropout",
-        "use_cache",
-        "eos_token_id",
-        "pad_token_id",
-        "tie_word_embeddings",
-    ]
-    new_config_kwargs = {k: original_config[v] for k, v in key_mapping.items()}
-    new_config_kwargs.update({k: v for k, v in original_config.items() if k in similar_keys_to_keep})
-    new_config_kwargs["num_key_value_heads"] = (
-        new_config_kwargs["num_attention_heads"]
-        if not original_config["multi_query_attention"]
-        else original_config["multi_query_group_num"]
-    )
-    new_config_kwargs["rope_theta"] = 10000.0 * getattr(original_config, "rope_ratio", 1)
-
-    new_config = GlmConfig(**new_config_kwargs)
-    return new_config
-
-
-def convert_glm_tokenizer(input_dir, use_post_processor=False):
-    fast_tok = PreTrainedTokenizerFast.from_pretrained(input_dir, model_input_names=["input_ids", "attention_mask"])
-    if use_post_processor:
-        fast_tok._tokenizer.post_processor = processors.Sequence(
-            [
-                processors.ByteLevel(trim_offsets=False),
-                processors.TemplateProcessing(
-                    single="[gMASK]:0 <sop>:0 $A:0",
-                    pair="[gMASK]:0 <sop>:0 $A:0 $B:1",
-                    special_tokens=[("[gMASK]", 151331), ("<sop>", 151333)],
-                ),
-            ],
-        )
-    else:
-        fast_tok._tokenizer.post_processor = processors.Sequence(
-            [processors.ByteLevel(trim_offsets=False)],
-        )
-    return fast_tok
-
-
-def convert_glm_model(input_dir, output_dir, use_post_processor=False):
-    # Load and convert config
-    with open(os.path.join(input_dir, "config.json")) as f:
-        original_config = json.load(f)
-    config = convert_config(original_config)
-    config.save_pretrained(output_dir)
-
-    # Load and convert weights
-    original_state_dict = load_weights(input_dir)
-    new_dict = convert_state_dict(original_state_dict, config)
-    with torch.device("meta"):
-        model = GlmForCausalLM(config)
-    model.load_state_dict(new_dict, strict=True, assign=True)
-    model.save_pretrained(output_dir)
-
-    # Load and convert tokenizer
-    tokenizer = convert_glm_tokenizer(input_dir, use_post_processor)
-    tokenizer.save_pretrained(output_dir)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "input_dir",
-        type=str,
-        help="Location of the local folder copied from the Hub.",
-    )
-    parser.add_argument(
-        "output_dir",
-        type=str,
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--use_post_processor",
-        action="store_true",
-        help="Whether to apply post processor with special tokens",
-    )
-
-    args = parser.parse_args()
-    convert_glm_model(args.input_dir, args.output_dir, args.use_post_processor)
diff --git a/src/transformers/models/glpn/convert_glpn_to_pytorch.py b/src/transformers/models/glpn/convert_glpn_to_pytorch.py
deleted file mode 100644
index 5d18c3b73a50..000000000000
--- a/src/transformers/models/glpn/convert_glpn_to_pytorch.py
+++ /dev/null
@@ -1,218 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert GLPN checkpoints."""
-
-import argparse
-from collections import OrderedDict
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import GLPNConfig, GLPNForDepthEstimation, GLPNImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def rename_keys(state_dict):
-    new_state_dict = OrderedDict()
-    for key, value in state_dict.items():
-        if key.startswith("module.encoder"):
-            key = key.replace("module.encoder", "glpn.encoder")
-        if key.startswith("module.decoder"):
-            key = key.replace("module.decoder", "decoder.stages")
-        if "patch_embed" in key:
-            # replace for example patch_embed1 by patch_embeddings.0
-            idx = key[key.find("patch_embed") + len("patch_embed")]
-            key = key.replace(f"patch_embed{idx}", f"patch_embeddings.{int(idx) - 1}")
-        if "norm" in key:
-            key = key.replace("norm", "layer_norm")
-        if "glpn.encoder.layer_norm" in key:
-            # replace for example layer_norm1 by layer_norm.0
-            idx = key[key.find("glpn.encoder.layer_norm") + len("glpn.encoder.layer_norm")]
-            key = key.replace(f"layer_norm{idx}", f"layer_norm.{int(idx) - 1}")
-        if "layer_norm1" in key:
-            key = key.replace("layer_norm1", "layer_norm_1")
-        if "layer_norm2" in key:
-            key = key.replace("layer_norm2", "layer_norm_2")
-        if "block" in key:
-            # replace for example block1 by block.0
-            idx = key[key.find("block") + len("block")]
-            key = key.replace(f"block{idx}", f"block.{int(idx) - 1}")
-        if "attn.q" in key:
-            key = key.replace("attn.q", "attention.self.query")
-        if "attn.proj" in key:
-            key = key.replace("attn.proj", "attention.output.dense")
-        if "attn" in key:
-            key = key.replace("attn", "attention.self")
-        if "fc1" in key:
-            key = key.replace("fc1", "dense1")
-        if "fc2" in key:
-            key = key.replace("fc2", "dense2")
-        if "linear_pred" in key:
-            key = key.replace("linear_pred", "classifier")
-        if "linear_fuse" in key:
-            key = key.replace("linear_fuse.conv", "linear_fuse")
-            key = key.replace("linear_fuse.bn", "batch_norm")
-        if "linear_c" in key:
-            # replace for example linear_c4 by linear_c.3
-            idx = key[key.find("linear_c") + len("linear_c")]
-            key = key.replace(f"linear_c{idx}", f"linear_c.{int(idx) - 1}")
-        if "bot_conv" in key:
-            key = key.replace("bot_conv", "0.convolution")
-        if "skip_conv1" in key:
-            key = key.replace("skip_conv1", "1.convolution")
-        if "skip_conv2" in key:
-            key = key.replace("skip_conv2", "2.convolution")
-        if "fusion1" in key:
-            key = key.replace("fusion1", "1.fusion")
-        if "fusion2" in key:
-            key = key.replace("fusion2", "2.fusion")
-        if "fusion3" in key:
-            key = key.replace("fusion3", "3.fusion")
-        if "fusion" in key and "conv" in key:
-            key = key.replace("conv", "convolutional_layer")
-        if key.startswith("module.last_layer_depth"):
-            key = key.replace("module.last_layer_depth", "head.head")
-        new_state_dict[key] = value
-
-    return new_state_dict
-
-
-def read_in_k_v(state_dict, config):
-    # for each of the encoder blocks:
-    for i in range(config.num_encoder_blocks):
-        for j in range(config.depths[i]):
-            # read in weights + bias of keys and values (which is a single matrix in the original implementation)
-            kv_weight = state_dict.pop(f"glpn.encoder.block.{i}.{j}.attention.self.kv.weight")
-            kv_bias = state_dict.pop(f"glpn.encoder.block.{i}.{j}.attention.self.kv.bias")
-            # next, add keys and values (in that order) to the state dict
-            state_dict[f"glpn.encoder.block.{i}.{j}.attention.self.key.weight"] = kv_weight[
-                : config.hidden_sizes[i], :
-            ]
-            state_dict[f"glpn.encoder.block.{i}.{j}.attention.self.key.bias"] = kv_bias[: config.hidden_sizes[i]]
-            state_dict[f"glpn.encoder.block.{i}.{j}.attention.self.value.weight"] = kv_weight[
-                config.hidden_sizes[i] :, :
-            ]
-            state_dict[f"glpn.encoder.block.{i}.{j}.attention.self.value.bias"] = kv_bias[config.hidden_sizes[i] :]
-
-
-# We will verify our results on a COCO image
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-
-    return image
-
-
-@torch.no_grad()
-def convert_glpn_checkpoint(checkpoint_path, pytorch_dump_folder_path, push_to_hub=False, model_name=None):
-    """
-    Copy/paste/tweak model's weights to our GLPN structure.
-    """
-
-    # load GLPN configuration (Segformer-B4 size)
-    config = GLPNConfig(hidden_sizes=[64, 128, 320, 512], decoder_hidden_size=64, depths=[3, 8, 27, 3])
-
-    # load image processor (only resize + rescale)
-    image_processor = GLPNImageProcessor()
-
-    # prepare image
-    image = prepare_img()
-    pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
-
-    logger.info("Converting model...")
-
-    # load original state dict
-    state_dict = torch.load(checkpoint_path, map_location=torch.device("cpu"))
-
-    # rename keys
-    state_dict = rename_keys(state_dict)
-
-    # key and value matrices need special treatment
-    read_in_k_v(state_dict, config)
-
-    # create HuggingFace model and load state dict
-    model = GLPNForDepthEstimation(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # forward pass
-    outputs = model(pixel_values)
-    predicted_depth = outputs.predicted_depth
-
-    # verify output
-    if model_name is not None:
-        if "nyu" in model_name:
-            expected_slice = torch.tensor(
-                [[4.4147, 4.0873, 4.0673], [3.7890, 3.2881, 3.1525], [3.7674, 3.5423, 3.4913]]
-            )
-        elif "kitti" in model_name:
-            expected_slice = torch.tensor(
-                [[3.4291, 2.7865, 2.5151], [3.2841, 2.7021, 2.3502], [3.1147, 2.4625, 2.2481]]
-            )
-        else:
-            raise ValueError(f"Unknown model name: {model_name}")
-
-        expected_shape = torch.Size([1, 480, 640])
-
-        assert predicted_depth.shape == expected_shape
-        assert torch.allclose(predicted_depth[0, :3, :3], expected_slice, atol=1e-4)
-        print("Looks ok!")
-
-    # finally, push to hub if required
-    if push_to_hub:
-        logger.info("Pushing model and image processor to the hub...")
-        model.push_to_hub(
-            repo_path_or_name=Path(pytorch_dump_folder_path, model_name),
-            organization="nielsr",
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
-        image_processor.push_to_hub(
-            repo_path_or_name=Path(pytorch_dump_folder_path, model_name),
-            organization="nielsr",
-            commit_message="Add image processor",
-            use_temp_dir=True,
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_path",
-        default=None,
-        type=str,
-        help="Path to the original PyTorch checkpoint (.pth file).",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether to upload the model to the HuggingFace hub."
-    )
-    parser.add_argument(
-        "--model_name",
-        default="glpn-kitti",
-        type=str,
-        help="Name of the model in case you're pushing to the hub.",
-    )
-    args = parser.parse_args()
-    convert_glpn_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)
diff --git a/src/transformers/models/got_ocr2/convert_got_ocr2_weights_to_hf.py b/src/transformers/models/got_ocr2/convert_got_ocr2_weights_to_hf.py
deleted file mode 100644
index 3df7214410e1..000000000000
--- a/src/transformers/models/got_ocr2/convert_got_ocr2_weights_to_hf.py
+++ /dev/null
@@ -1,274 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import gc
-import glob
-import os
-from typing import List, Optional
-
-import regex as re
-import torch
-from huggingface_hub import snapshot_download
-from safetensors import safe_open
-
-from transformers import (
-    GotOcr2Config,
-    GotOcr2ForConditionalGeneration,
-    GotOcr2ImageProcessor,
-    GotOcr2Processor,
-    PreTrainedTokenizerFast,
-    is_vision_available,
-)
-from transformers.convert_slow_tokenizer import TikTokenConverter
-from transformers.tokenization_utils import AddedToken
-
-
-if is_vision_available():
-    from transformers.image_utils import load_image
-
-
-# fmt: off
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    # Vision encoder mapping
-    r"model.vision_tower_high.pos_embed":                           r"vision_tower.pos_embed",
-    r"model.vision_tower_high.patch_embed.proj":                    r"vision_tower.patch_embed.projection",
-    r"model.vision_tower_high.blocks.(\d+).norm":                   r"vision_tower.layers.\1.layer_norm",
-    r"model.vision_tower_high.blocks.(\d+).attn":                   r"vision_tower.layers.\1.attn",
-    r"model.vision_tower_high.blocks.(\d+).mlp":                    r"vision_tower.layers.\1.mlp",
-    r"model.vision_tower_high.neck.0":                              r"vision_tower.neck.conv1",
-    r"model.vision_tower_high.neck.1":                              r"vision_tower.neck.layer_norm1",
-    r"model.vision_tower_high.neck.2":                              r"vision_tower.neck.conv2",
-    r"model.vision_tower_high.neck.3":                              r"vision_tower.neck.layer_norm2",
-    r"model.vision_tower_high.net_(\d+)":                           lambda m: f"multi_modal_projector.conv_upsampler{int(m.group(1)) - 1}",
-    r"model.mm_projector_vary" :                                    r"multi_modal_projector.multimodal_projector",
-    r"model.":                                                      r"language_model.model.",
-    r"lm_head":                                                     r"language_model.lm_head",
-}
-# fmt: on
-
-CONTEXT_LENGTH = 8000
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    """
-    This function should be applied only once, on the concatenated keys to efficiently rename using
-    the key mappings.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-        for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-            new_text = re.sub(pattern, replacement, new_text)
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-    return output_dict
-
-
-def load_original_state_dict(model_id):
-    directory_path = snapshot_download(repo_id=model_id, allow_patterns=["*.safetensors"])
-
-    original_state_dict = {}
-    for path in glob.glob(f"{directory_path}/*"):
-        if path.endswith(".safetensors"):
-            with safe_open(path, framework="pt", device="cpu") as f:
-                for key in f.keys():
-                    original_state_dict[key] = f.get_tensor(key)
-
-    return original_state_dict
-
-
-def get_got_ocr2_config():
-    config = GotOcr2Config()
-
-    return config
-
-
-def write_model(
-    model_path,
-    input_base_path,
-    push_to_hub=False,
-):
-    os.makedirs(model_path, exist_ok=True)
-
-    config = get_got_ocr2_config()
-    config.architectures = ["GotOcr2ForConditionalGeneration"]
-    config.save_pretrained(model_path)
-    print("Model config saved successfully...")
-
-    # ------------------------------------------------------------
-    # Convert weights
-    # ------------------------------------------------------------
-
-    print(f"Fetching all parameters from the checkpoint at {input_base_path}...")
-    state_dict_old = load_original_state_dict(input_base_path)
-    print("Converting model...")
-    all_keys = list(state_dict_old.keys())
-    new_keys = convert_old_keys_to_new_keys(all_keys)
-    state_dict = {}
-    for key in all_keys:
-        new_key = new_keys[key]
-        state_dict[new_key] = state_dict_old[key]
-
-    del state_dict_old
-    gc.collect()
-
-    print("Loading the checkpoint in a GotOcr2ForConditionalGeneration model.")
-    model = GotOcr2ForConditionalGeneration(config)
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    model = model.to(torch.bfloat16)
-    print("model dtype:", model.dtype)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-
-    print("Saving the model.")
-    model.save_pretrained(model_path)
-    if push_to_hub:
-        model.push_to_hub("stepfun-ai/GOT-OCR-2.0-hf", use_temp_dir=True)
-    del state_dict, model
-
-    # Safety check: reload the converted model
-    gc.collect()
-    print("Reloading the model to check if it's saved correctly.")
-    model = GotOcr2ForConditionalGeneration.from_pretrained(model_path, device_map="auto")
-    processor = GotOcr2Processor.from_pretrained(model_path)
-    image = load_image(
-        "https://huggingface.co/datasets/hf-internal-testing/fixtures_got_ocr/resolve/main/image_ocr.jpg"
-    )
-
-    inputs = processor(image, return_tensors="pt", format=True).to(model.device, dtype=model.dtype)
-    generate_ids = model.generate(**inputs, do_sample=False, num_beams=1, max_new_tokens=4)
-    decoded_output = processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)
-    expected_output = "\\title{\nR"
-    print("Decoded output:", decoded_output)
-    assert decoded_output == expected_output
-    print("Model reloaded successfully.")
-    del model
-
-
-class GotOcr2Converter(TikTokenConverter):
-    def __init__(
-        self,
-        vocab_file,
-        special_tokens: List[str],
-        pattern: str,
-        model_max_length: int,
-        chat_template: Optional[str] = None,
-        **kwargs,
-    ):
-        super().__init__(vocab_file, pattern=pattern)
-        self.additional_special_tokens = special_tokens
-        tokenizer = self.converted()
-        if chat_template is not None:
-            kwargs["chat_template"] = chat_template
-        self.tokenizer = PreTrainedTokenizerFast(
-            tokenizer_object=tokenizer,
-            model_input_names=["input_ids", "attention_mask"],
-            model_max_length=model_max_length,
-            **kwargs,
-        )
-
-
-def write_tokenizer(tokenizer_path: str, save_dir: str, push_to_hub: bool = False):
-    model_max_length = CONTEXT_LENGTH
-    pattern = r"(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"  # noqa: W605
-    # Special tokens
-    special_tokens = (
-        ["<|endoftext|>", "<|im_start|>", "<|im_end|>"]
-        + [f"<|extra_{i}|>" for i in range(205)]
-        + [
-            "<ref>",
-            "</ref>",
-            "<box>",
-            "</box>",
-            "<quad>",
-            "</quad>",
-            "<img>",
-            "</img>",
-            "<imgpad>",
-        ]
-    )
-
-    pad_token = "<|endoftext|>"
-    pad_token = AddedToken(pad_token, lstrip=False, rstrip=False, normalized=False, single_word=False)
-
-    converter = GotOcr2Converter(
-        vocab_file=tokenizer_path,
-        pattern=pattern,
-        special_tokens=special_tokens,
-        model_max_length=model_max_length,
-        pad_token=pad_token,
-        bos_token="<|endoftext|>",
-        eos_token="<|endoftext|>",
-        clean_up_tokenization_spaces=True,
-    )
-    tokenizer = converter.tokenizer
-    tokenizer.save_pretrained(save_dir)
-
-    if push_to_hub:
-        tokenizer.push_to_hub("stepfun-ai/GOT-OCR-2.0-hf", use_temp_dir=True)
-
-
-def write_image_processor(save_dir: str, push_to_hub: bool = False):
-    image_processor = GotOcr2ImageProcessor(
-        do_resize=True,
-        size={"height": 1024, "width": 1024},
-        do_rescale=True,
-        rescale_factor=1 / 255,
-        do_normalize=True,
-        image_mean=[0.48145466, 0.4578275, 0.40821073],
-        image_std=[0.26862954, 0.26130258, 0.27577711],
-    )
-
-    image_processor.save_pretrained(save_dir)
-    if push_to_hub:
-        image_processor.push_to_hub("stepfun-ai/GOT-OCR-2.0-hf", use_temp_dir=True)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        default="stepfun-ai/GOT-OCR2_0",
-        help="Location of LLaMA weights, which contains tokenizer.model and model folders",
-    )
-    parser.add_argument(
-        "--output_dir",
-        default="GotOcr2",
-        help="Location to write HF model and tokenizer",
-    )
-
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-    write_tokenizer(
-        tokenizer_path="qwen.tiktoken",
-        save_dir=args.output_dir,
-        push_to_hub=args.push_to_hub,
-    )
-
-    write_image_processor(
-        save_dir=args.output_dir,
-        push_to_hub=args.push_to_hub,
-    )
-    write_model(
-        model_path=args.output_dir,
-        input_base_path=args.input_dir,
-        push_to_hub=args.push_to_hub,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/gpt2/convert_gpt2_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/gpt2/convert_gpt2_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index 33f9dabed07f..000000000000
--- a/src/transformers/models/gpt2/convert_gpt2_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert OpenAI GPT checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import GPT2Config, GPT2Model, load_tf_weights_in_gpt2
-from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_gpt2_checkpoint_to_pytorch(gpt2_checkpoint_path, gpt2_config_file, pytorch_dump_folder_path):
-    # Construct model
-    if gpt2_config_file == "":
-        config = GPT2Config()
-    else:
-        config = GPT2Config.from_json_file(gpt2_config_file)
-    model = GPT2Model(config)
-
-    # Load weights from numpy
-    load_tf_weights_in_gpt2(model, config, gpt2_checkpoint_path)
-
-    # Save pytorch-model
-    pytorch_weights_dump_path = pytorch_dump_folder_path + "/" + WEIGHTS_NAME
-    pytorch_config_dump_path = pytorch_dump_folder_path + "/" + CONFIG_NAME
-    print(f"Save PyTorch model to {pytorch_weights_dump_path}")
-    torch.save(model.state_dict(), pytorch_weights_dump_path)
-    print(f"Save configuration file to {pytorch_config_dump_path}")
-    with open(pytorch_config_dump_path, "w", encoding="utf-8") as f:
-        f.write(config.to_json_string())
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--gpt2_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--gpt2_config_file",
-        default="",
-        type=str,
-        help=(
-            "An optional config json file corresponding to the pre-trained OpenAI model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    args = parser.parse_args()
-    convert_gpt2_checkpoint_to_pytorch(args.gpt2_checkpoint_path, args.gpt2_config_file, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/gpt_neo/convert_gpt_neo_mesh_tf_to_pytorch.py b/src/transformers/models/gpt_neo/convert_gpt_neo_mesh_tf_to_pytorch.py
deleted file mode 100644
index 3db22857293c..000000000000
--- a/src/transformers/models/gpt_neo/convert_gpt_neo_mesh_tf_to_pytorch.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The Eleuther AI and HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert GPT Neo checkpoint."""
-
-import argparse
-import json
-
-from transformers import GPTNeoConfig, GPTNeoForCausalLM, load_tf_weights_in_gpt_neo
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config_json = json.load(open(config_file, "r"))
-    config = GPTNeoConfig(
-        hidden_size=config_json["n_embd"],
-        num_layers=config_json["n_layer"],
-        num_heads=config_json["n_head"],
-        attention_types=config_json["attention_types"],
-        max_position_embeddings=config_json["n_positions"],
-        resid_dropout=config_json["res_dropout"],
-        embed_dropout=config_json["embed_dropout"],
-        attention_dropout=config_json["attn_dropout"],
-    )
-    print(f"Building PyTorch model from configuration: {config}")
-    model = GPTNeoForCausalLM(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_gpt_neo(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained mesh-tf model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/gpt_sw3/convert_megatron_to_pytorch.py b/src/transformers/models/gpt_sw3/convert_megatron_to_pytorch.py
deleted file mode 100644
index 2625701c1a75..000000000000
--- a/src/transformers/models/gpt_sw3/convert_megatron_to_pytorch.py
+++ /dev/null
@@ -1,197 +0,0 @@
-# Copyright 2022 The HuggingFace Inc. team and the AI-Sweden team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert GPT-SW3 megatron checkpoints to pytorch"""
-
-import argparse
-import os
-from os.path import isfile
-
-import torch
-
-from transformers import GPT2Config
-
-
-def recursive_print(name, val, spaces=0):
-    # Format the message.
-    if name is None:
-        msg = None
-    else:
-        fmt = "." * max(0, spaces - 2) + "# {:" + str(50 - spaces) + "s}"
-        msg = fmt.format(name)
-
-    # Print and recurse (if needed).
-    if isinstance(val, dict):
-        if msg is not None:
-            print(msg)
-        for k in val.keys():
-            recursive_print(k, val[k], spaces + 2)
-    elif isinstance(val, torch.Tensor):
-        print(msg, ":", val.size())
-    else:
-        print(msg, ":", val)
-
-
-def fix_query_key_value_ordering(param, num_splits, num_heads, hidden_size):
-    # Permutes layout of param tensor to [num_splits * num_heads * hidden_size, :]
-    # for compatibility with later versions of NVIDIA Megatron-LM.
-    # The inverse operation is performed inside Megatron-LM to read checkpoints:
-    # https://github.com/NVIDIA/Megatron-LM/blob/v2.4/megatron/checkpointing.py#L209
-    # If param is the weight tensor of the self-attention block, the returned tensor
-    # will have to be transposed one more time to be read by HuggingFace GPT2.
-    input_shape = param.size()
-    # other versions store [num_heads * num_splits * hidden_size, :]
-    saved_shape = (num_heads, num_splits, hidden_size) + input_shape[1:]
-    param = param.view(*saved_shape)
-    param = param.transpose(0, 1).contiguous()
-    param = param.view(*input_shape)
-    return param
-
-
-def convert_megatron_checkpoint(sd_megatron, config):
-    """
-    Converts a Megatron checkpoint to a HuggingFace GPT-SW3 checkpoint.
-    """
-    n_positions = config.n_positions
-    layers = config.n_layer
-    vocab_size = config.vocab_size
-    heads = config.n_head
-    hidden_size_per_head = config.n_embd // config.n_head
-
-    word_embeddings = sd_megatron["model.language_model.embedding.word_embeddings.weight"][:vocab_size, :]
-    sd_hf = {
-        "transformer.wte.weight": word_embeddings,
-        "transformer.wpe.weight": sd_megatron["model.language_model.embedding.position_embeddings.weight"],
-        "transformer.ln_f.weight": sd_megatron["model.language_model.encoder.final_layernorm.weight"],
-        "transformer.ln_f.bias": sd_megatron["model.language_model.encoder.final_layernorm.bias"],
-    }
-
-    pf = "model.language_model.encoder.layers."
-    for i in range(layers):
-        causal_mask = torch.tril(torch.ones((n_positions, n_positions), dtype=torch.bool))
-        causal_mask = causal_mask.view(1, 1, n_positions, n_positions)
-        sd_hf[f"transformer.h.{i}.attn.bias"] = causal_mask
-        sd_hf[f"transformer.h.{i}.attn.masked_bias"] = torch.tensor(-1e4, dtype=torch.bfloat16)
-
-        sd_hf[f"transformer.h.{i}.ln_1.weight"] = sd_megatron[f"{pf}{i}.input_layernorm.weight"]
-        sd_hf[f"transformer.h.{i}.ln_1.bias"] = sd_megatron[f"{pf}{i}.input_layernorm.bias"]
-
-        val1 = sd_megatron[f"{pf}{i}.self_attention.query_key_value.weight"]
-        val1 = fix_query_key_value_ordering(val1, 3, heads, hidden_size_per_head)
-        sd_hf[f"transformer.h.{i}.attn.c_attn.weight"] = val1.transpose(0, 1).contiguous()
-
-        val2 = sd_megatron[f"{pf}{i}.self_attention.query_key_value.bias"]
-        val2 = fix_query_key_value_ordering(val2, 3, heads, hidden_size_per_head)
-        sd_hf[f"transformer.h.{i}.attn.c_attn.bias"] = val2
-
-        sd_hf[f"transformer.h.{i}.attn.c_proj.weight"] = sd_megatron[f"{pf}{i}.self_attention.dense.weight"].transpose(
-            0, 1
-        )
-        sd_hf[f"transformer.h.{i}.attn.c_proj.bias"] = sd_megatron[f"{pf}{i}.self_attention.dense.bias"]
-        sd_hf[f"transformer.h.{i}.ln_2.weight"] = sd_megatron[f"{pf}{i}.post_attention_layernorm.weight"]
-        sd_hf[f"transformer.h.{i}.ln_2.bias"] = sd_megatron[f"{pf}{i}.post_attention_layernorm.bias"]
-        sd_hf[f"transformer.h.{i}.mlp.c_fc.weight"] = sd_megatron[f"{pf}{i}.mlp.dense_h_to_4h.weight"].transpose(0, 1)
-        sd_hf[f"transformer.h.{i}.mlp.c_fc.bias"] = sd_megatron[f"{pf}{i}.mlp.dense_h_to_4h.bias"]
-        sd_hf[f"transformer.h.{i}.mlp.c_proj.weight"] = sd_megatron[f"{pf}{i}.mlp.dense_4h_to_h.weight"].transpose(
-            0, 1
-        )
-        sd_hf[f"transformer.h.{i}.mlp.c_proj.bias"] = sd_megatron[f"{pf}{i}.mlp.dense_4h_to_h.bias"]
-
-    # For LM head, transformers' wants the matrix to weight embeddings.
-    sd_hf["lm_head.weight"] = word_embeddings
-
-    return sd_hf
-
-
-def copy_config(config_hf, config_megatron):
-    """Copy the config from Megatron to hf."""
-    config_hf.vocab_size = 64000
-    config_hf.n_positions = config_megatron["encoder_seq_length"]
-    config_hf.n_embd = config_megatron["hidden_size"]
-    config_hf.n_layer = config_megatron["num_layers"]
-    config_hf.n_head = config_megatron["num_attention_heads"]
-    config_hf.n_inner = config_megatron["ffn_hidden_size"]
-    config_hf.activation_function = "gelu"
-    config_hf.resid_pdrop = 0.1
-    config_hf.embd_pdrop = 0.1
-    config_hf.attn_pdrop = 0.1
-    config_hf.layer_norm_epsilon = config_megatron["layernorm_epsilon"]  # 1e-5
-    config_hf.initializer_range = config_megatron["init_method_std"]  # 0.02
-    config_hf.apply_query_key_layer_scaling = config_megatron["apply_query_key_layer_scaling"]  # True
-    config_hf.normalize_attention_scores = True
-    config_hf.use_cache = True
-
-    # This identifies the 6.7B (7B) model which uses a different tokenizer
-    if config_megatron["hidden_size"] == 4096:
-        config_hf.bos_token_id = 1  # <|endoftext|>
-        config_hf.eos_token_id = 1  # <|endoftext|>
-        config_hf.pad_token_id = 0  # <unk>
-    else:
-        config_hf.bos_token_id = 2  # <s>
-        config_hf.eos_token_id = 3  # <|endoftext|>
-        config_hf.pad_token_id = 0  # <pad>
-
-    return config_hf
-
-
-def main(args):
-    print(args)
-
-    checkpoint_path = args.checkpoint_path
-    save_path = args.save_path
-    if isfile(checkpoint_path):
-        raise FileNotFoundError(f"ERROR! could not find file {checkpoint_path}")
-
-    # Load the model.
-    checkpoint = torch.load(checkpoint_path, map_location="cpu")
-
-    # Load the config.
-    config_megatron = checkpoint["hyper_parameters"]["cfg"]
-    config_hf = GPT2Config()
-    config_hf = copy_config(config_hf=config_hf, config_megatron=config_megatron)
-    config_hf.architectures = ["GPT2LMHeadModel"]
-
-    sd_megatron = checkpoint["state_dict"]
-
-    # Convert.
-    print("Converting")
-    sd_hf = convert_megatron_checkpoint(sd_megatron, config_hf)
-
-    # Print the structure of converted state dict.
-    if args.print_checkpoint_structure:
-        recursive_print(None, sd_hf)
-
-    config_hf.tokenizer_class = "GPTSw3Tokenizer"
-
-    # Store the config to file.
-    print("Saving config")
-    config_hf.save_pretrained(save_path)
-
-    # Store the state_dict to file.
-    output_checkpoint_file = os.path.join(save_path, "pytorch_model.bin")
-    print(f'Saving checkpoint to "{output_checkpoint_file}"')
-    torch.save(sd_hf, output_checkpoint_file)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--checkpoint_path",
-        type=str,
-        required=True,
-        help="e.g. megatron_gpt--val_loss=2.42-step=38000-consumed_samples=54720000",
-    )
-    parser.add_argument("--save_path", type=str, required=True, help="e.g. /home/user/gpt-sw3/hf")
-    parser.add_argument("--print-checkpoint-structure", action="store_true")
-    _args = parser.parse_args()
-    main(_args)
diff --git a/src/transformers/models/grounding_dino/convert_grounding_dino_to_hf.py b/src/transformers/models/grounding_dino/convert_grounding_dino_to_hf.py
deleted file mode 100644
index ac8e82bfd825..000000000000
--- a/src/transformers/models/grounding_dino/convert_grounding_dino_to_hf.py
+++ /dev/null
@@ -1,491 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Grounding DINO checkpoints from the original repository.
-
-URL: https://github.com/IDEA-Research/GroundingDINO"""
-
-import argparse
-
-import requests
-import torch
-from PIL import Image
-from torchvision import transforms as T
-
-from transformers import (
-    AutoTokenizer,
-    GroundingDinoConfig,
-    GroundingDinoForObjectDetection,
-    GroundingDinoImageProcessor,
-    GroundingDinoProcessor,
-    SwinConfig,
-)
-
-
-IMAGENET_MEAN = [0.485, 0.456, 0.406]
-IMAGENET_STD = [0.229, 0.224, 0.225]
-
-
-def get_grounding_dino_config(model_name):
-    if "tiny" in model_name:
-        window_size = 7
-        embed_dim = 96
-        depths = (2, 2, 6, 2)
-        num_heads = (3, 6, 12, 24)
-        image_size = 224
-    elif "base" in model_name:
-        window_size = 12
-        embed_dim = 128
-        depths = (2, 2, 18, 2)
-        num_heads = (4, 8, 16, 32)
-        image_size = 384
-    else:
-        raise ValueError("Model not supported, only supports base and large variants")
-
-    backbone_config = SwinConfig(
-        window_size=window_size,
-        image_size=image_size,
-        embed_dim=embed_dim,
-        depths=depths,
-        num_heads=num_heads,
-        out_indices=[2, 3, 4],
-    )
-
-    config = GroundingDinoConfig(backbone_config=backbone_config)
-
-    return config
-
-
-def create_rename_keys(state_dict, config):
-    rename_keys = []
-    # fmt: off
-    ########################################## VISION BACKBONE - START
-    # patch embedding layer
-    rename_keys.append(("backbone.0.patch_embed.proj.weight",
-                        "model.backbone.conv_encoder.model.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("backbone.0.patch_embed.proj.bias",
-                        "model.backbone.conv_encoder.model.embeddings.patch_embeddings.projection.bias"))
-    rename_keys.append(("backbone.0.patch_embed.norm.weight",
-                        "model.backbone.conv_encoder.model.embeddings.norm.weight"))
-    rename_keys.append(("backbone.0.patch_embed.norm.bias",
-                        "model.backbone.conv_encoder.model.embeddings.norm.bias"))
-
-    for layer, depth in enumerate(config.backbone_config.depths):
-        for block in range(depth):
-            # layernorms
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.norm1.weight",
-                                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.layernorm_before.weight"))
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.norm1.bias",
-                                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.layernorm_before.bias"))
-
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.norm2.weight",
-                                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.layernorm_after.weight"))
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.norm2.bias",
-                                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.layernorm_after.bias"))
-            # attention
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.attn.relative_position_bias_table",
-                                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.self.relative_position_bias_table"))
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.attn.proj.weight",
-                            f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.output.dense.weight"))
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.attn.proj.bias",
-                            f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.output.dense.bias"))
-            # intermediate
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.mlp.fc1.weight",
-                            f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.intermediate.dense.weight"))
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.mlp.fc1.bias",
-                            f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.intermediate.dense.bias"))
-
-            # output
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.mlp.fc2.weight",
-                            f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.output.dense.weight"))
-            rename_keys.append((f"backbone.0.layers.{layer}.blocks.{block}.mlp.fc2.bias",
-                            f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.output.dense.bias"))
-
-        # downsample
-        if layer!=len(config.backbone_config.depths)-1:
-            rename_keys.append((f"backbone.0.layers.{layer}.downsample.reduction.weight",
-                                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.downsample.reduction.weight"))
-            rename_keys.append((f"backbone.0.layers.{layer}.downsample.norm.weight",
-                                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.downsample.norm.weight"))
-            rename_keys.append((f"backbone.0.layers.{layer}.downsample.norm.bias",
-                                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.downsample.norm.bias"))
-
-    for out_indice in config.backbone_config.out_indices:
-        # Grounding DINO implementation of out_indices isn't aligned with transformers
-        rename_keys.append((f"backbone.0.norm{out_indice-1}.weight",
-                        f"model.backbone.conv_encoder.model.hidden_states_norms.stage{out_indice}.weight"))
-        rename_keys.append((f"backbone.0.norm{out_indice-1}.bias",
-                        f"model.backbone.conv_encoder.model.hidden_states_norms.stage{out_indice}.bias"))
-
-    ########################################## VISION BACKBONE - END
-
-    ########################################## ENCODER - START
-    deformable_key_mappings = {
-        'self_attn.sampling_offsets.weight': 'deformable_layer.self_attn.sampling_offsets.weight',
-        'self_attn.sampling_offsets.bias': 'deformable_layer.self_attn.sampling_offsets.bias',
-        'self_attn.attention_weights.weight': 'deformable_layer.self_attn.attention_weights.weight',
-        'self_attn.attention_weights.bias': 'deformable_layer.self_attn.attention_weights.bias',
-        'self_attn.value_proj.weight': 'deformable_layer.self_attn.value_proj.weight',
-        'self_attn.value_proj.bias': 'deformable_layer.self_attn.value_proj.bias',
-        'self_attn.output_proj.weight': 'deformable_layer.self_attn.output_proj.weight',
-        'self_attn.output_proj.bias': 'deformable_layer.self_attn.output_proj.bias',
-        'norm1.weight': 'deformable_layer.self_attn_layer_norm.weight',
-        'norm1.bias': 'deformable_layer.self_attn_layer_norm.bias',
-        'linear1.weight': 'deformable_layer.fc1.weight',
-        'linear1.bias': 'deformable_layer.fc1.bias',
-        'linear2.weight': 'deformable_layer.fc2.weight',
-        'linear2.bias': 'deformable_layer.fc2.bias',
-        'norm2.weight': 'deformable_layer.final_layer_norm.weight',
-        'norm2.bias': 'deformable_layer.final_layer_norm.bias',
-    }
-    text_enhancer_key_mappings = {
-        'self_attn.in_proj_weight': 'text_enhancer_layer.self_attn.in_proj_weight',
-        'self_attn.in_proj_bias': 'text_enhancer_layer.self_attn.in_proj_bias',
-        'self_attn.out_proj.weight': 'text_enhancer_layer.self_attn.out_proj.weight',
-        'self_attn.out_proj.bias': 'text_enhancer_layer.self_attn.out_proj.bias',
-        'linear1.weight': 'text_enhancer_layer.fc1.weight',
-        'linear1.bias': 'text_enhancer_layer.fc1.bias',
-        'linear2.weight': 'text_enhancer_layer.fc2.weight',
-        'linear2.bias': 'text_enhancer_layer.fc2.bias',
-        'norm1.weight': 'text_enhancer_layer.layer_norm_before.weight',
-        'norm1.bias': 'text_enhancer_layer.layer_norm_before.bias',
-        'norm2.weight': 'text_enhancer_layer.layer_norm_after.weight',
-        'norm2.bias': 'text_enhancer_layer.layer_norm_after.bias',
-    }
-    fusion_key_mappings = {
-        'gamma_v': 'fusion_layer.vision_param',
-        'gamma_l': 'fusion_layer.text_param',
-        'layer_norm_v.weight': 'fusion_layer.layer_norm_vision.weight',
-        'layer_norm_v.bias': 'fusion_layer.layer_norm_vision.bias',
-        'layer_norm_l.weight': 'fusion_layer.layer_norm_text.weight',
-        'layer_norm_l.bias': 'fusion_layer.layer_norm_text.bias',
-        'attn.v_proj.weight': 'fusion_layer.attn.vision_proj.weight',
-        'attn.v_proj.bias': 'fusion_layer.attn.vision_proj.bias',
-        'attn.l_proj.weight': 'fusion_layer.attn.text_proj.weight',
-        'attn.l_proj.bias': 'fusion_layer.attn.text_proj.bias',
-        'attn.values_v_proj.weight': 'fusion_layer.attn.values_vision_proj.weight',
-        'attn.values_v_proj.bias': 'fusion_layer.attn.values_vision_proj.bias',
-        'attn.values_l_proj.weight': 'fusion_layer.attn.values_text_proj.weight',
-        'attn.values_l_proj.bias': 'fusion_layer.attn.values_text_proj.bias',
-        'attn.out_v_proj.weight': 'fusion_layer.attn.out_vision_proj.weight',
-        'attn.out_v_proj.bias': 'fusion_layer.attn.out_vision_proj.bias',
-        'attn.out_l_proj.weight': 'fusion_layer.attn.out_text_proj.weight',
-        'attn.out_l_proj.bias': 'fusion_layer.attn.out_text_proj.bias',
-    }
-    for layer in range(config.encoder_layers):
-        # deformable
-        for src, dest in deformable_key_mappings.items():
-            rename_keys.append((f"transformer.encoder.layers.{layer}.{src}",
-                                f"model.encoder.layers.{layer}.{dest}"))
-        # text enhance
-        for src, dest in text_enhancer_key_mappings.items():
-            rename_keys.append((f"transformer.encoder.text_layers.{layer}.{src}",
-                                f"model.encoder.layers.{layer}.{dest}"))
-        # fusion layers
-        for src, dest in fusion_key_mappings.items():
-            rename_keys.append((f"transformer.encoder.fusion_layers.{layer}.{src}",
-                                f"model.encoder.layers.{layer}.{dest}"))
-    ########################################## ENCODER - END
-
-    ########################################## DECODER - START
-    key_mappings_decoder = {
-        'cross_attn.sampling_offsets.weight': 'encoder_attn.sampling_offsets.weight',
-        'cross_attn.sampling_offsets.bias': 'encoder_attn.sampling_offsets.bias',
-        'cross_attn.attention_weights.weight': 'encoder_attn.attention_weights.weight',
-        'cross_attn.attention_weights.bias': 'encoder_attn.attention_weights.bias',
-        'cross_attn.value_proj.weight': 'encoder_attn.value_proj.weight',
-        'cross_attn.value_proj.bias': 'encoder_attn.value_proj.bias',
-        'cross_attn.output_proj.weight': 'encoder_attn.output_proj.weight',
-        'cross_attn.output_proj.bias': 'encoder_attn.output_proj.bias',
-        'norm1.weight': 'encoder_attn_layer_norm.weight',
-        'norm1.bias': 'encoder_attn_layer_norm.bias',
-        'ca_text.in_proj_weight': 'encoder_attn_text.in_proj_weight',
-        'ca_text.in_proj_bias': 'encoder_attn_text.in_proj_bias',
-        'ca_text.out_proj.weight': 'encoder_attn_text.out_proj.weight',
-        'ca_text.out_proj.bias': 'encoder_attn_text.out_proj.bias',
-        'catext_norm.weight': 'encoder_attn_text_layer_norm.weight',
-        'catext_norm.bias': 'encoder_attn_text_layer_norm.bias',
-        'self_attn.in_proj_weight': 'self_attn.in_proj_weight',
-        'self_attn.in_proj_bias': 'self_attn.in_proj_bias',
-        'self_attn.out_proj.weight': 'self_attn.out_proj.weight',
-        'self_attn.out_proj.bias': 'self_attn.out_proj.bias',
-        'norm2.weight': 'self_attn_layer_norm.weight',
-        'norm2.bias': 'self_attn_layer_norm.bias',
-        'linear1.weight': 'fc1.weight',
-        'linear1.bias': 'fc1.bias',
-        'linear2.weight': 'fc2.weight',
-        'linear2.bias': 'fc2.bias',
-        'norm3.weight': 'final_layer_norm.weight',
-        'norm3.bias': 'final_layer_norm.bias',
-    }
-    for layer_num in range(config.decoder_layers):
-        source_prefix_decoder = f'transformer.decoder.layers.{layer_num}.'
-        target_prefix_decoder = f'model.decoder.layers.{layer_num}.'
-
-        for source_name, target_name in key_mappings_decoder.items():
-            rename_keys.append((source_prefix_decoder + source_name,
-                               target_prefix_decoder + target_name))
-    ########################################## DECODER - END
-
-    ########################################## Additional - START
-    for layer_name, params in state_dict.items():
-        #### TEXT BACKBONE
-        if "bert" in layer_name:
-            rename_keys.append((layer_name, layer_name.replace("bert", "model.text_backbone")))
-        #### INPUT PROJ - PROJECT OUTPUT FEATURES FROM VISION BACKBONE
-        if "input_proj" in layer_name:
-            rename_keys.append((layer_name, layer_name.replace("input_proj", "model.input_proj_vision")))
-        #### INPUT PROJ - PROJECT OUTPUT FEATURES FROM TEXT BACKBONE
-        if "feat_map" in layer_name:
-            rename_keys.append((layer_name, layer_name.replace("feat_map", "model.text_projection")))
-        #### DECODER REFERENCE POINT HEAD
-        if "transformer.decoder.ref_point_head" in layer_name:
-            rename_keys.append((layer_name, layer_name.replace("transformer.decoder.ref_point_head",
-                                                               "model.decoder.reference_points_head")))
-        #### DECODER BBOX EMBED
-        if "transformer.decoder.bbox_embed" in layer_name:
-            rename_keys.append((layer_name, layer_name.replace("transformer.decoder.bbox_embed",
-                                                               "model.decoder.bbox_embed")))
-        if "transformer.enc_output" in layer_name:
-            rename_keys.append((layer_name, layer_name.replace("transformer", "model")))
-
-        if "transformer.enc_out_bbox_embed" in layer_name:
-            rename_keys.append((layer_name, layer_name.replace("transformer.enc_out_bbox_embed",
-                                                               "model.encoder_output_bbox_embed")))
-
-    rename_keys.append(("transformer.level_embed", "model.level_embed"))
-    rename_keys.append(("transformer.decoder.norm.weight", "model.decoder.layer_norm.weight"))
-    rename_keys.append(("transformer.decoder.norm.bias", "model.decoder.layer_norm.bias"))
-    rename_keys.append(("transformer.tgt_embed.weight", "model.query_position_embeddings.weight"))
-    ########################################## Additional - END
-
-    # fmt: on
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v_encoder(state_dict, config):
-    ########################################## VISION BACKBONE - START
-    embed_dim = config.backbone_config.embed_dim
-    for layer, depth in enumerate(config.backbone_config.depths):
-        hidden_size = embed_dim * 2**layer
-        for block in range(depth):
-            # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-            in_proj_weight = state_dict.pop(f"backbone.0.layers.{layer}.blocks.{block}.attn.qkv.weight")
-            in_proj_bias = state_dict.pop(f"backbone.0.layers.{layer}.blocks.{block}.attn.qkv.bias")
-            # next, add query, keys and values (in that order) to the state dict
-            state_dict[
-                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.self.query.weight"
-            ] = in_proj_weight[:hidden_size, :]
-            state_dict[
-                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.self.query.bias"
-            ] = in_proj_bias[:hidden_size]
-
-            state_dict[
-                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.self.key.weight"
-            ] = in_proj_weight[hidden_size : hidden_size * 2, :]
-            state_dict[
-                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.self.key.bias"
-            ] = in_proj_bias[hidden_size : hidden_size * 2]
-
-            state_dict[
-                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.self.value.weight"
-            ] = in_proj_weight[-hidden_size:, :]
-            state_dict[
-                f"model.backbone.conv_encoder.model.encoder.layers.{layer}.blocks.{block}.attention.self.value.bias"
-            ] = in_proj_bias[-hidden_size:]
-    ########################################## VISION BACKBONE - END
-
-
-def read_in_q_k_v_text_enhancer(state_dict, config):
-    hidden_size = config.hidden_size
-    for idx in range(config.encoder_layers):
-        # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"model.encoder.layers.{idx}.text_enhancer_layer.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"model.encoder.layers.{idx}.text_enhancer_layer.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.encoder.layers.{idx}.text_enhancer_layer.self_attn.query.weight"] = in_proj_weight[
-            :hidden_size, :
-        ]
-        state_dict[f"model.encoder.layers.{idx}.text_enhancer_layer.self_attn.query.bias"] = in_proj_bias[:hidden_size]
-
-        state_dict[f"model.encoder.layers.{idx}.text_enhancer_layer.self_attn.key.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"model.encoder.layers.{idx}.text_enhancer_layer.self_attn.key.bias"] = in_proj_bias[
-            hidden_size : hidden_size * 2
-        ]
-
-        state_dict[f"model.encoder.layers.{idx}.text_enhancer_layer.self_attn.value.weight"] = in_proj_weight[
-            -hidden_size:, :
-        ]
-        state_dict[f"model.encoder.layers.{idx}.text_enhancer_layer.self_attn.value.bias"] = in_proj_bias[
-            -hidden_size:
-        ]
-
-
-def read_in_q_k_v_decoder(state_dict, config):
-    hidden_size = config.hidden_size
-    for idx in range(config.decoder_layers):
-        # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"model.decoder.layers.{idx}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"model.decoder.layers.{idx}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.decoder.layers.{idx}.self_attn.query.weight"] = in_proj_weight[:hidden_size, :]
-        state_dict[f"model.decoder.layers.{idx}.self_attn.query.bias"] = in_proj_bias[:hidden_size]
-
-        state_dict[f"model.decoder.layers.{idx}.self_attn.key.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"model.decoder.layers.{idx}.self_attn.key.bias"] = in_proj_bias[hidden_size : hidden_size * 2]
-
-        state_dict[f"model.decoder.layers.{idx}.self_attn.value.weight"] = in_proj_weight[-hidden_size:, :]
-        state_dict[f"model.decoder.layers.{idx}.self_attn.value.bias"] = in_proj_bias[-hidden_size:]
-
-        # read in weights + bias of cross-attention
-        in_proj_weight = state_dict.pop(f"model.decoder.layers.{idx}.encoder_attn_text.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"model.decoder.layers.{idx}.encoder_attn_text.in_proj_bias")
-
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.decoder.layers.{idx}.encoder_attn_text.query.weight"] = in_proj_weight[:hidden_size, :]
-        state_dict[f"model.decoder.layers.{idx}.encoder_attn_text.query.bias"] = in_proj_bias[:hidden_size]
-
-        state_dict[f"model.decoder.layers.{idx}.encoder_attn_text.key.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"model.decoder.layers.{idx}.encoder_attn_text.key.bias"] = in_proj_bias[
-            hidden_size : hidden_size * 2
-        ]
-
-        state_dict[f"model.decoder.layers.{idx}.encoder_attn_text.value.weight"] = in_proj_weight[-hidden_size:, :]
-        state_dict[f"model.decoder.layers.{idx}.encoder_attn_text.value.bias"] = in_proj_bias[-hidden_size:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-    return image
-
-
-def preprocess_caption(caption: str) -> str:
-    result = caption.lower().strip()
-    if result.endswith("."):
-        return result
-    return result + "."
-
-
-@torch.no_grad()
-def convert_grounding_dino_checkpoint(args):
-    model_name = args.model_name
-    pytorch_dump_folder_path = args.pytorch_dump_folder_path
-    push_to_hub = args.push_to_hub
-    verify_logits = args.verify_logits
-
-    checkpoint_mapping = {
-        "grounding-dino-tiny": "https://huggingface.co/ShilongLiu/GroundingDino/resolve/main/groundingdino_swint_ogc.pth",
-        "grounding-dino-base": "https://huggingface.co/ShilongLiu/GroundingDino/resolve/main/groundingdino_swinb_cogcoor.pth",
-    }
-    # Define default GroundingDino configuation
-    config = get_grounding_dino_config(model_name)
-
-    # Load original checkpoint
-    checkpoint_url = checkpoint_mapping[model_name]
-    original_state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["model"]
-    original_state_dict = {k.replace("module.", ""): v for k, v in original_state_dict.items()}
-
-    for name, param in original_state_dict.items():
-        print(name, param.shape)
-
-    # Rename keys
-    new_state_dict = original_state_dict.copy()
-    rename_keys = create_rename_keys(original_state_dict, config)
-
-    for src, dest in rename_keys:
-        rename_key(new_state_dict, src, dest)
-    read_in_q_k_v_encoder(new_state_dict, config)
-    read_in_q_k_v_text_enhancer(new_state_dict, config)
-    read_in_q_k_v_decoder(new_state_dict, config)
-
-    # Load HF model
-    model = GroundingDinoForObjectDetection(config)
-    model.eval()
-    missing_keys, unexpected_keys = model.load_state_dict(new_state_dict, strict=False)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-
-    # Load and process test image
-    image = prepare_img()
-    transforms = T.Compose([T.Resize(size=800, max_size=1333), T.ToTensor(), T.Normalize(IMAGENET_MEAN, IMAGENET_STD)])
-    original_pixel_values = transforms(image).unsqueeze(0)
-
-    image_processor = GroundingDinoImageProcessor()
-    tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
-    processor = GroundingDinoProcessor(image_processor=image_processor, tokenizer=tokenizer)
-
-    text = "a cat"
-    inputs = processor(images=image, text=preprocess_caption(text), return_tensors="pt")
-
-    assert torch.allclose(original_pixel_values, inputs.pixel_values, atol=1e-4)
-
-    if verify_logits:
-        # Running forward
-        with torch.no_grad():
-            outputs = model(**inputs)
-
-        print(outputs.logits[0, :3, :3])
-
-        expected_slice = torch.tensor(
-            [[-4.8913, -0.1900, -0.2161], [-4.9653, -0.3719, -0.3950], [-5.9599, -3.3765, -3.3104]]
-        )
-
-        assert torch.allclose(outputs.logits[0, :3, :3], expected_slice, atol=1e-4)
-        print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub(f"EduardoPacheco/{model_name}")
-        processor.push_to_hub(f"EduardoPacheco/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="grounding-dino-tiny",
-        type=str,
-        choices=["grounding-dino-tiny", "grounding-dino-base"],
-        help="Name of the GroundingDino model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    parser.add_argument(
-        "--verify_logits", action="store_false", help="Whether or not to verify logits after conversion."
-    )
-
-    args = parser.parse_args()
-    convert_grounding_dino_checkpoint(args)
diff --git a/src/transformers/models/groupvit/convert_groupvit_nvlab_to_hf.py b/src/transformers/models/groupvit/convert_groupvit_nvlab_to_hf.py
deleted file mode 100644
index 059f10f6129b..000000000000
--- a/src/transformers/models/groupvit/convert_groupvit_nvlab_to_hf.py
+++ /dev/null
@@ -1,217 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Convert GroupViT checkpoints from the original repository.
-
-URL: https://github.com/NVlabs/GroupViT
-"""
-
-import argparse
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel
-
-
-def rename_key(name):
-    # vision encoder
-    if "img_encoder.pos_embed" in name:
-        name = name.replace("img_encoder.pos_embed", "vision_model.embeddings.position_embeddings")
-    if "img_encoder.patch_embed.proj" in name:
-        name = name.replace("img_encoder.patch_embed.proj", "vision_model.embeddings.patch_embeddings.projection")
-    if "img_encoder.patch_embed.norm" in name:
-        name = name.replace("img_encoder.patch_embed.norm", "vision_model.embeddings.layernorm")
-    if "img_encoder.layers" in name:
-        name = name.replace("img_encoder.layers", "vision_model.encoder.stages")
-    if "blocks" in name and "res" not in name:
-        name = name.replace("blocks", "layers")
-    if "attn" in name and "pre_assign" not in name:
-        name = name.replace("attn", "self_attn")
-    if "proj" in name and "self_attn" in name and "text" not in name:
-        name = name.replace("proj", "out_proj")
-    if "pre_assign_attn.attn.proj" in name:
-        name = name.replace("pre_assign_attn.attn.proj", "pre_assign_attn.attn.out_proj")
-    if "norm1" in name:
-        name = name.replace("norm1", "layer_norm1")
-    if "norm2" in name and "pre_assign" not in name:
-        name = name.replace("norm2", "layer_norm2")
-    if "img_encoder.norm" in name:
-        name = name.replace("img_encoder.norm", "vision_model.layernorm")
-    # text encoder
-    if "text_encoder.token_embedding" in name:
-        name = name.replace("text_encoder.token_embedding", "text_model.embeddings.token_embedding")
-    if "text_encoder.positional_embedding" in name:
-        name = name.replace("text_encoder.positional_embedding", "text_model.embeddings.position_embedding.weight")
-    if "text_encoder.transformer.resblocks." in name:
-        name = name.replace("text_encoder.transformer.resblocks.", "text_model.encoder.layers.")
-    if "ln_1" in name:
-        name = name.replace("ln_1", "layer_norm1")
-    if "ln_2" in name:
-        name = name.replace("ln_2", "layer_norm2")
-    if "c_fc" in name:
-        name = name.replace("c_fc", "fc1")
-    if "c_proj" in name:
-        name = name.replace("c_proj", "fc2")
-    if "text_encoder" in name:
-        name = name.replace("text_encoder", "text_model")
-    if "ln_final" in name:
-        name = name.replace("ln_final", "final_layer_norm")
-    # projection layers
-    if "img_projector.linear_hidden." in name:
-        name = name.replace("img_projector.linear_hidden.", "visual_projection.")
-    if "img_projector.linear_out." in name:
-        name = name.replace("img_projector.linear_out.", "visual_projection.3.")
-    if "text_projector.linear_hidden" in name:
-        name = name.replace("text_projector.linear_hidden", "text_projection")
-    if "text_projector.linear_out" in name:
-        name = name.replace("text_projector.linear_out", "text_projection.3")
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, config):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "qkv" in key:
-            # weights and biases of the key, value and query projections of vision encoder's attention layers require special treatment:
-            # we need to split them up into separate matrices/vectors
-            key_split = key.split(".")
-            stage_num, layer_num = int(key_split[2]), int(key_split[4])
-            dim = config.vision_config.hidden_size
-            if "weight" in key:
-                orig_state_dict[
-                    f"vision_model.encoder.stages.{stage_num}.layers.{layer_num}.self_attn.q_proj.weight"
-                ] = val[:dim, :]
-                orig_state_dict[
-                    f"vision_model.encoder.stages.{stage_num}.layers.{layer_num}.self_attn.k_proj.weight"
-                ] = val[dim : dim * 2, :]
-                orig_state_dict[
-                    f"vision_model.encoder.stages.{stage_num}.layers.{layer_num}.self_attn.v_proj.weight"
-                ] = val[-dim:, :]
-            else:
-                orig_state_dict[
-                    f"vision_model.encoder.stages.{stage_num}.layers.{layer_num}.self_attn.q_proj.bias"
-                ] = val[:dim]
-                orig_state_dict[
-                    f"vision_model.encoder.stages.{stage_num}.layers.{layer_num}.self_attn.k_proj.bias"
-                ] = val[dim : dim * 2]
-                orig_state_dict[
-                    f"vision_model.encoder.stages.{stage_num}.layers.{layer_num}.self_attn.v_proj.bias"
-                ] = val[-dim:]
-        elif "in_proj" in key:
-            # weights and biases of the key, value and query projections of text encoder's attention layers require special treatment:
-            # we need to split them up into separate matrices/vectors
-            key_split = key.split(".")
-            layer_num = int(key_split[3])
-            dim = config.text_config.hidden_size
-            if "weight" in key:
-                orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.q_proj.weight"] = val[:dim, :]
-                orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.k_proj.weight"] = val[
-                    dim : dim * 2, :
-                ]
-                orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.v_proj.weight"] = val[-dim:, :]
-            else:
-                orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.q_proj.bias"] = val[:dim]
-                orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.k_proj.bias"] = val[dim : dim * 2]
-                orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.v_proj.bias"] = val[-dim:]
-        else:
-            new_name = rename_key(key)
-            # squeeze if necessary
-            if (
-                "text_projection.0" in new_name
-                or "text_projection.3" in new_name
-                or "visual_projection.0" in new_name
-                or "visual_projection.3" in new_name
-            ):
-                orig_state_dict[new_name] = val.squeeze_()
-            else:
-                orig_state_dict[new_name] = val
-
-    return orig_state_dict
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_groupvit_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, model_name="groupvit-gcc-yfcc", push_to_hub=False
-):
-    """
-    Copy/paste/tweak model's weights to the Transformers design.
-    """
-    config = GroupViTConfig()
-    model = GroupViTModel(config).eval()
-
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-    new_state_dict = convert_state_dict(state_dict, config)
-    missing_keys, unexpected_keys = model.load_state_dict(new_state_dict, strict=False)
-    assert missing_keys == ["text_model.embeddings.position_ids"]
-    assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(unexpected_keys) == 0)
-
-    # verify result
-    processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
-    image = prepare_img()
-    inputs = processor(text=["a photo of a cat", "a photo of a dog"], images=image, padding=True, return_tensors="pt")
-
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    if model_name == "groupvit-gcc-yfcc":
-        expected_logits = torch.tensor([[13.3523, 6.3629]])
-    elif model_name == "groupvit-gcc-redcaps":
-        expected_logits = torch.tensor([[16.1873, 8.6230]])
-    else:
-        raise ValueError(f"Model name {model_name} not supported.")
-    assert torch.allclose(outputs.logits_per_image, expected_logits, atol=1e-3)
-
-    processor.save_pretrained(pytorch_dump_folder_path)
-    model.save_pretrained(pytorch_dump_folder_path)
-    print("Successfully saved processor and model to", pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing to the hub...")
-        processor.push_to_hub(model_name, organization="nielsr")
-        model.push_to_hub(model_name, organization="nielsr")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to dump the processor and PyTorch model."
-    )
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to GroupViT checkpoint")
-    parser.add_argument(
-        "--model_name",
-        default="groupvit-gccy-fcc",
-        type=str,
-        help="Name of the model. Expecting either 'groupvit-gcc-yfcc' or 'groupvit-gcc-redcaps'",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether or not to push the converted model and processor to the 🤗 hub using the provided `model_name`.",
-    )
-    args = parser.parse_args()
-
-    convert_groupvit_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)
diff --git a/src/transformers/models/hiera/convert_hiera_to_hf.py b/src/transformers/models/hiera/convert_hiera_to_hf.py
deleted file mode 100644
index eed27645b344..000000000000
--- a/src/transformers/models/hiera/convert_hiera_to_hf.py
+++ /dev/null
@@ -1,369 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Hiera checkpoints from the original repository.
-
-URL: https://github.com/facebookresearch/hiera
-"""
-
-import argparse
-import json
-import math
-from typing import Dict, Tuple
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision import transforms
-
-from transformers import BitImageProcessor, HieraConfig, HieraForImageClassification, HieraForPreTraining, HieraModel
-from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config: HieraConfig, base_model: bool, mae_model: bool):
-    rename_keys = []
-    # fmt: off
-    num_stages = len(config.depths)
-    # embedding dimensions for input and stages
-    dims = [config.embed_dim] + [int(config.embed_dim * config.embed_dim_multiplier**i) for i in range(num_stages)]
-
-    global_layer_idx = 0
-    for stage_idx in range(num_stages):
-        dim_in = dims[stage_idx]
-        dim_out = dims[stage_idx + 1]
-        for layer_idx in range(config.depths[stage_idx]):
-            rename_keys.append((f"blocks.{global_layer_idx}.norm1.weight", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.layernorm_before.weight"))
-            rename_keys.append((f"blocks.{global_layer_idx}.norm1.bias", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.layernorm_before.bias"))
-            rename_keys.append((f"blocks.{global_layer_idx}.attn.qkv.weight", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.attn.qkv.weight"))
-            rename_keys.append((f"blocks.{global_layer_idx}.attn.qkv.bias", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.attn.qkv.bias"))
-            rename_keys.append((f"blocks.{global_layer_idx}.attn.proj.weight", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.attn.proj.weight"))
-            rename_keys.append((f"blocks.{global_layer_idx}.attn.proj.bias", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.attn.proj.bias"))
-            rename_keys.append((f"blocks.{global_layer_idx}.norm2.weight", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.layernorm_after.weight"))
-            rename_keys.append((f"blocks.{global_layer_idx}.norm2.bias", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.layernorm_after.bias"))
-            rename_keys.append((f"blocks.{global_layer_idx}.mlp.fc1.weight", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.mlp.fc1.weight"))
-            rename_keys.append((f"blocks.{global_layer_idx}.mlp.fc1.bias", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.mlp.fc1.bias"))
-            rename_keys.append((f"blocks.{global_layer_idx}.mlp.fc2.weight", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.mlp.fc2.weight"))
-            rename_keys.append((f"blocks.{global_layer_idx}.mlp.fc2.bias", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.mlp.fc2.bias"))
-
-            # projection layer only for the first layer of each stage boundary (except the first stage)
-            if dim_out != dim_in and layer_idx == 0:
-                rename_keys.append((f"blocks.{global_layer_idx}.proj.weight", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.proj.weight"))
-                rename_keys.append((f"blocks.{global_layer_idx}.proj.bias", f"hiera.encoder.stages.{stage_idx}.layers.{layer_idx}.proj.bias"))
-
-            global_layer_idx += 1
-
-    # projection layer + position embeddings
-    rename_keys.extend(
-        [
-            ("patch_embed.proj.weight", "hiera.embeddings.patch_embeddings.projection.weight"),
-            ("patch_embed.proj.bias", "hiera.embeddings.patch_embeddings.projection.bias")
-        ]
-    )
-
-    rename_keys.append(("pos_embed", "hiera.embeddings.position_embeddings"))
-
-    if base_model:
-        # layernorm + pooler
-        rename_keys.extend([("norm.weight", "pooler.layernorm.weight"), ("norm.bias", "pooler.layernorm.bias")])
-        # if just the base model, we should remove "hiera" from all keys that start with "hiera"
-        rename_keys = [(pair[0], pair[1][6:]) if pair[1].startswith("hiera") else pair for pair in rename_keys]
-    elif mae_model:
-        rename_keys.extend(
-            [
-                ("encoder_norm.weight", "encoder_norm.weight"),
-                ("encoder_norm.bias", "encoder_norm.bias"),
-                ("mask_token", "decoder.mask_token"),
-                ("decoder_pos_embed", "decoder.decoder_position_embeddings"),
-                ("decoder_norm.weight", "decoder.decoder_norm.weight"),
-                ("decoder_norm.bias", "decoder.decoder_norm.bias"),
-                ("decoder_pred.weight", "decoder.decoder_pred.weight"),
-                ("decoder_pred.bias", "decoder.decoder_pred.bias"),
-                ("decoder_embed.weight", "decoder.decoder_embeddings.weight"),
-                ("decoder_embed.bias", "decoder.decoder_embeddings.bias")
-            ]
-        )
-        for i in range(config.decoder_depth):
-            rename_keys.extend(
-                [
-                    (f"decoder_blocks.{i}.norm1.weight", f"decoder.decoder_block.layers.{i}.layernorm_before.weight"),
-                    (f"decoder_blocks.{i}.norm1.bias", f"decoder.decoder_block.layers.{i}.layernorm_before.bias"),
-                    (f"decoder_blocks.{i}.attn.qkv.weight", f"decoder.decoder_block.layers.{i}.attn.qkv.weight"),
-                    (f"decoder_blocks.{i}.attn.qkv.bias", f"decoder.decoder_block.layers.{i}.attn.qkv.bias"),
-                    (f"decoder_blocks.{i}.attn.proj.weight", f"decoder.decoder_block.layers.{i}.attn.proj.weight"),
-                    (f"decoder_blocks.{i}.attn.proj.bias", f"decoder.decoder_block.layers.{i}.attn.proj.bias"),
-                    (f"decoder_blocks.{i}.norm2.weight", f"decoder.decoder_block.layers.{i}.layernorm_after.weight"),
-                    (f"decoder_blocks.{i}.norm2.bias", f"decoder.decoder_block.layers.{i}.layernorm_after.bias"),
-                    (f"decoder_blocks.{i}.mlp.fc1.weight", f"decoder.decoder_block.layers.{i}.mlp.fc1.weight"),
-                    (f"decoder_blocks.{i}.mlp.fc1.bias", f"decoder.decoder_block.layers.{i}.mlp.fc1.bias"),
-                    (f"decoder_blocks.{i}.mlp.fc2.weight", f"decoder.decoder_block.layers.{i}.mlp.fc2.weight"),
-                    (f"decoder_blocks.{i}.mlp.fc2.bias", f"decoder.decoder_block.layers.{i}.mlp.fc2.bias"),
-                ]
-            )
-        for i in range(config.num_query_pool):
-            rename_keys.extend(
-                [
-                    (f"multi_scale_fusion_heads.{i}.weight", f"multiscale_fusion.multi_scale_fusion_heads.{i}.weight"),
-                    (f"multi_scale_fusion_heads.{i}.bias", f"multiscale_fusion.multi_scale_fusion_heads.{i}.bias")
-                ]
-            )
-    else:
-        # layernorm + classification head
-        rename_keys.extend(
-            [
-                ("norm.weight", "hiera.pooler.layernorm.weight"),
-                ("norm.bias", "hiera.pooler.layernorm.bias"),
-                ("head.projection.weight", "classifier.weight"),
-                ("head.projection.bias", "classifier.bias"),
-            ]
-        )
-    # fmt: on
-    return rename_keys
-
-
-def remove_classification_head_(state_dict):
-    ignore_keys = ["head.projection.weight", "head.projection.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-def get_labels_for_classifier(model_name: str) -> Tuple[Dict[int, str], Dict[str, int], int]:
-    repo_id = "huggingface/label-files"
-
-    filename = "imagenet-1k-id2label.json"
-
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    label2id = {v: k for k, v in id2label.items()}
-    num_labels = len(id2label)
-
-    return id2label, label2id, num_labels
-
-
-def get_hiera_config(model_name: str, base_model: bool, mae_model: bool) -> HieraConfig:
-    if model_name == "hiera-tiny-224":
-        config = HieraConfig(depths=[1, 2, 7, 2])
-    elif model_name == "hiera-small-224":
-        config = HieraConfig(depths=[1, 2, 11, 2])
-    elif model_name == "hiera-base-224":
-        config = HieraConfig()
-    elif model_name == "hiera-base-plus-224":
-        config = HieraConfig(embed_dim=112, num_heads=[2, 4, 8, 16])
-    elif model_name == "hiera-large-224":
-        config = HieraConfig(embed_dim=144, num_heads=[2, 4, 8, 16], depths=[2, 6, 36, 4])
-    elif model_name == "hiera-huge-224":
-        config = HieraConfig(embed_dim=256, num_heads=[4, 8, 16, 32], depths=[2, 6, 36, 4])
-    else:
-        raise ValueError(f"Unrecognized model name: {model_name}")
-
-    if base_model:
-        pass
-    elif mae_model:
-        config.num_query_pool = 2
-        config.decoder_hidden_size = 512
-        config.decoder_depth = 8
-        config.decoder_num_heads = 16
-        # Table 3b from Hiera: A Hierarchical Vision Transformer without the Bells-and-Whistles
-        config.mask_ratio = 0.6
-    else:
-        id2label, label2id, num_labels = get_labels_for_classifier(model_name)
-        config.id2label = id2label
-        config.label2id = label2id
-        config.num_labels = num_labels
-
-    return config
-
-
-@torch.no_grad()
-def convert_hiera_checkpoint(args):
-    model_name = args.model_name
-    base_model = args.base_model
-    pytorch_dump_folder_path = args.pytorch_dump_folder_path
-    push_to_hub = args.push_to_hub
-    mae_model = args.mae_model
-
-    config = get_hiera_config(model_name, base_model, mae_model)
-
-    # Load original hiera model
-    original_model_name = model_name.replace("-", "_")
-    original_model_name = f"mae_{original_model_name}" if mae_model else original_model_name
-
-    original_checkpoint_name = "mae_in1k_ft_in1k" if not (base_model or mae_model) else "mae_in1k"
-
-    original_model = torch.hub.load(
-        "facebookresearch/hiera",
-        model=original_model_name,
-        pretrained=True,
-        checkpoint=original_checkpoint_name,
-    )
-
-    original_model.eval()
-    original_state_dict = original_model.state_dict()
-    # Don't need to remove head for MAE because original implementation doesn't have it on MAE
-    if base_model:
-        remove_classification_head_(original_state_dict)
-
-    # # Rename keys
-    new_state_dict = original_state_dict.copy()
-    rename_keys = create_rename_keys(config, base_model, mae_model)
-
-    for src, dest in rename_keys:
-        rename_key(new_state_dict, src, dest)
-
-    # Load HF hiera model
-    if base_model:
-        model = HieraModel(config)
-    elif mae_model:
-        model = HieraForPreTraining(config)
-    else:
-        model = HieraForImageClassification(config)
-
-    model.eval()
-
-    missing_keys, unexpected_keys = model.load_state_dict(new_state_dict, strict=False)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-
-    input_image = prepare_img()
-
-    original_image_preprocessor = transforms.Compose(
-        [
-            transforms.Resize(int((256 / 224) * 224), interpolation=transforms.functional.InterpolationMode.BICUBIC),
-            transforms.CenterCrop(224),
-            transforms.ToTensor(),
-            transforms.Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD),
-        ]
-    )
-
-    image_processor = BitImageProcessor(
-        image_mean=IMAGENET_DEFAULT_MEAN, image_std=IMAGENET_DEFAULT_STD, size={"shortest_edge": 256}
-    )
-    inputs = image_processor(images=input_image, return_tensors="pt")
-
-    expected_pixel_values = original_image_preprocessor(input_image).unsqueeze(0)
-
-    input_image = prepare_img()
-
-    inputs = image_processor(images=input_image, return_tensors="pt")
-    expected_pixel_values = original_image_preprocessor(input_image).unsqueeze(0)
-    assert torch.allclose(inputs.pixel_values, expected_pixel_values, atol=1e-4)
-    print("Pixel values look good!")
-    print(f"{inputs.pixel_values[0, :3, :3, :3]=}")
-
-    # If is MAE we pass a noise to generate a random mask
-    mask_spatial_shape = [
-        i // s // ms for i, s, ms in zip(config.image_size, config.patch_stride, config.masked_unit_size)
-    ]
-    num_windows = math.prod(mask_spatial_shape)
-    torch.manual_seed(2)
-    noise = torch.rand(1, num_windows)
-    outputs = model(**inputs) if not mae_model else model(noise=noise, **inputs)
-    # original implementation returns logits.softmax(dim=-1)
-
-    if base_model:
-        expected_prob, expected_intermediates = original_model(expected_pixel_values, return_intermediates=True)
-        expected_last_hidden = expected_intermediates[-1]
-        batch_size, _, _, hidden_dim = expected_last_hidden.shape
-        expected_last_hidden = expected_last_hidden.reshape(batch_size, -1, hidden_dim)
-        assert torch.allclose(outputs.last_hidden_state, expected_last_hidden, atol=1e-3)
-        print("Base Model looks good as hidden states match original implementation!")
-        print(f"{outputs.last_hidden_state[0, :3, :3]=}")
-    elif mae_model:
-        # get mask from noise to be able to compare outputs
-        mask, _ = model.hiera.embeddings.patch_embeddings.random_masking(expected_pixel_values, noise)
-        expected_loss, _, _, _ = original_model(expected_pixel_values, mask=mask.bool())
-        assert torch.allclose(outputs.loss, expected_loss, atol=1e-3)
-        print("MAE Model looks good as loss matches original implementation!")
-    else:
-        expected_prob = original_model(expected_pixel_values)
-        assert torch.allclose(outputs.logits.softmax(dim=-1), expected_prob, atol=1e-3)
-        print("Classifier looks good as probs match original implementation")
-        print(f"{outputs.logits[:, :5]=}")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor for {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        hub_name = model_name
-        if base_model:
-            hub_name = model_name
-        elif mae_model:
-            hub_name = f"{model_name}-mae"
-        else:
-            hub_name = f"{model_name}-in1k"
-        repo_id = f"EduardoPacheco/{hub_name}"
-        print(f"Pushing model and processor for {model_name} to hub at {repo_id}")
-        model.push_to_hub(repo_id)
-        image_processor.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model-name",
-        default="hiera-tiny-224",
-        type=str,
-        choices=[
-            "hiera-tiny-224",
-            "hiera-small-224",
-            "hiera-base-224",
-            "hiera-base-plus-224",
-            "hiera-large-224",
-            "hiera-huge-224",
-        ],
-        help="Name of the Hiera model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch-dump-folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--verify-logits",
-        action="store_true",
-        help="Whether or not to verify the logits against the original implementation.",
-    )
-    parser.add_argument(
-        "--push-to-hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    parser.add_argument(
-        "--base-model",
-        action="store_true",
-        help="Whether to only convert the base model (no projection head weights).",
-    )
-    parser.add_argument(
-        "--mae-model", action="store_true", help="Whether to convert to MAE checkpoint to HieraForPreTraining."
-    )
-
-    args = parser.parse_args()
-    convert_hiera_checkpoint(args)
diff --git a/src/transformers/models/hubert/convert_distilhubert_original_s3prl_checkpoint_to_pytorch.py b/src/transformers/models/hubert/convert_distilhubert_original_s3prl_checkpoint_to_pytorch.py
deleted file mode 100644
index f5914f35c546..000000000000
--- a/src/transformers/models/hubert/convert_distilhubert_original_s3prl_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,222 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Hubert checkpoint."""
-
-import argparse
-
-import torch
-from s3prl.hub import distilhubert
-
-from transformers import HubertConfig, HubertModel, Wav2Vec2FeatureExtractor, logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "mask_emb": "masked_spec_embed",
-}
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    assert hf_shape == value.shape, (
-        f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-        f" {value.shape} for {full_name}"
-    )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                mapped_key = mapped_key
-
-                if key in name:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "weight" in name:
-                        weight_type = "weight"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
-                " found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-def convert_config(model):
-    config = HubertConfig()
-    fs_config = model.config
-
-    config.activation_dropout = fs_config.activation_dropout
-    config.apply_spec_augment = False
-    config.attention_dropout = fs_config.attention_dropout
-    config.conv_bias = False
-    conv_layers = eval(fs_config.extractor_conv_feature_layers)
-    config.conv_dim = [x[0] for x in conv_layers]
-    config.conv_kernel = [x[1] for x in conv_layers]
-    config.conv_stride = [x[2] for x in conv_layers]
-    config.feat_extract_activation = "gelu"
-    config.feat_extract_norm = "layer" if fs_config.extractor_mode == "layer_norm" else "group"
-    config.feat_proj_layer_norm = False
-    config.feat_proj_dropout = 0.0
-    config.final_dropout = 0.0
-    config.hidden_act = fs_config.activation_fn
-    config.hidden_dropout = fs_config.dropout
-    config.hidden_size = fs_config.encoder_embed_dim
-    config.initializer_range = 0.02
-    config.intermediate_size = fs_config.encoder_ffn_embed_dim
-    config.layer_norm_eps = 1e-5
-    config.layerdrop = 0.0
-    config.num_attention_heads = fs_config.encoder_attention_heads
-    config.num_conv_pos_embedding_groups = fs_config.conv_pos_groups
-    config.num_conv_pos_embeddings = fs_config.conv_pos
-    config.num_feat_extract_layers = len(conv_layers)
-    config.num_hidden_layers = fs_config.encoder_layers
-
-    return config
-
-
-@torch.no_grad()
-def convert_hubert_checkpoint(pytorch_dump_folder_path, config_path=None):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    model = distilhubert().model.model
-
-    if config_path is not None:
-        config = HubertConfig.from_pretrained(config_path)
-    else:
-        config = convert_config(model)
-    model = model.eval()
-
-    feature_extractor = Wav2Vec2FeatureExtractor(
-        feature_size=1,
-        sampling_rate=16000,
-        padding_value=0,
-        do_normalize=False,
-        return_attention_mask=False,
-    )
-    hf_model = HubertModel(config)
-
-    recursively_load_weights(model, hf_model)
-
-    feature_extractor.save_pretrained(pytorch_dump_folder_path)
-    hf_model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    args = parser.parse_args()
-    convert_hubert_checkpoint(args.pytorch_dump_folder_path, args.config_path)
diff --git a/src/transformers/models/hubert/convert_hubert_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/hubert/convert_hubert_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 4966340493f3..000000000000
--- a/src/transformers/models/hubert/convert_hubert_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,261 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Hubert checkpoint."""
-
-import argparse
-import json
-import os
-
-import fairseq
-import torch
-from fairseq.data import Dictionary
-
-from transformers import (
-    HubertConfig,
-    HubertForCTC,
-    HubertModel,
-    Wav2Vec2CTCTokenizer,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2Processor,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.batch_norm",
-    "encoder.pos_conv.1": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "w2v_encoder.proj": "lm_head",
-    "mask_emb": "masked_spec_embed",
-}
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    assert hf_shape == value.shape, (
-        f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-        f" {value.shape} for {full_name}"
-    )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    elif weight_type == "running_mean":
-        hf_pointer.running_mean.data = value
-    elif weight_type == "running_var":
-        hf_pointer.running_var.data = value
-    elif weight_type == "num_batches_tracked":
-        hf_pointer.num_batches_tracked.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model, is_finetuned):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.hubert.feature_extractor if is_finetuned else hf_model.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                mapped_key = "hubert." + mapped_key if (is_finetuned and mapped_key != "lm_head") else mapped_key
-
-                if key in name or (key.split("w2v_model.")[-1] == name.split(".")[0] and not is_finetuned):
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "weight" in name:
-                        weight_type = "weight"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    elif "running_mean" in name:
-                        weight_type = "running_mean"
-                    elif "running_var" in name:
-                        weight_type = "running_var"
-                    elif "num_batches_tracked" in name:
-                        weight_type = "num_batches_tracked"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
-                " found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-@torch.no_grad()
-def convert_hubert_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, config_path=None, dict_path=None, is_finetuned=True
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = HubertConfig.from_pretrained(config_path)
-    else:
-        config = HubertConfig()
-
-    if is_finetuned:
-        if dict_path:
-            target_dict = Dictionary.load(dict_path)
-
-            # important change bos & pad token id since CTC symbol is <pad> and
-            # not <s> as in fairseq
-            config.bos_token_id = target_dict.pad_index
-            config.pad_token_id = target_dict.bos_index
-            config.eos_token_id = target_dict.eos_index
-            config.vocab_size = len(target_dict.symbols)
-            vocab_path = os.path.join(pytorch_dump_folder_path, "vocab.json")
-            if not os.path.isdir(pytorch_dump_folder_path):
-                logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(pytorch_dump_folder_path))
-                return
-            os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-            with open(vocab_path, "w", encoding="utf-8") as vocab_handle:
-                json.dump(target_dict.indices, vocab_handle)
-            tokenizer = Wav2Vec2CTCTokenizer(
-                vocab_path,
-                unk_token=target_dict.unk_word,
-                pad_token=target_dict.pad_word,
-                bos_token=target_dict.bos_word,
-                eos_token=target_dict.eos_word,
-                word_delimiter_token="|",
-                do_lower_case=False,
-            )
-            return_attention_mask = True if config.feat_extract_norm == "layer" else False
-            feature_extractor = Wav2Vec2FeatureExtractor(
-                feature_size=1,
-                sampling_rate=16000,
-                padding_value=0,
-                do_normalize=True,
-                return_attention_mask=return_attention_mask,
-            )
-            processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
-            processor.save_pretrained(pytorch_dump_folder_path)
-
-        hf_wav2vec = HubertForCTC(config)
-    else:
-        hf_wav2vec = HubertModel(config)
-
-    if is_finetuned:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-            [checkpoint_path], arg_overrides={"data": "/".join(dict_path.split("/")[:-1])}
-        )
-    else:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path])
-
-    model = model[0].eval()
-
-    recursively_load_weights(model, hf_wav2vec, is_finetuned)
-
-    hf_wav2vec.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
-    )
-    args = parser.parse_args()
-    convert_hubert_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
-    )
diff --git a/src/transformers/models/hubert/convert_hubert_original_s3prl_checkpoint_to_pytorch.py b/src/transformers/models/hubert/convert_hubert_original_s3prl_checkpoint_to_pytorch.py
deleted file mode 100644
index ff15b90088af..000000000000
--- a/src/transformers/models/hubert/convert_hubert_original_s3prl_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Hubert checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import HubertConfig, HubertForSequenceClassification, Wav2Vec2FeatureExtractor, logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-SUPPORTED_MODELS = ["UtteranceLevel"]
-
-
-@torch.no_grad()
-def convert_s3prl_checkpoint(base_model_name, config_path, checkpoint_path, model_dump_path):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    checkpoint = torch.load(checkpoint_path, map_location="cpu")
-    if checkpoint["Config"]["downstream_expert"]["modelrc"]["select"] not in SUPPORTED_MODELS:
-        raise NotImplementedError(f"The supported s3prl models are {SUPPORTED_MODELS}")
-
-    downstream_dict = checkpoint["Downstream"]
-
-    hf_congfig = HubertConfig.from_pretrained(config_path)
-    hf_model = HubertForSequenceClassification.from_pretrained(base_model_name, config=hf_congfig)
-    hf_feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
-        base_model_name, return_attention_mask=True, do_normalize=False
-    )
-
-    if hf_congfig.use_weighted_layer_sum:
-        hf_model.layer_weights.data = checkpoint["Featurizer"]["weights"]
-
-    hf_model.projector.weight.data = downstream_dict["projector.weight"]
-    hf_model.projector.bias.data = downstream_dict["projector.bias"]
-    hf_model.classifier.weight.data = downstream_dict["model.post_net.linear.weight"]
-    hf_model.classifier.bias.data = downstream_dict["model.post_net.linear.bias"]
-
-    hf_feature_extractor.save_pretrained(model_dump_path)
-    hf_model.save_pretrained(model_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--base_model_name", default=None, type=str, help="Name of the huggingface pretrained base model."
-    )
-    parser.add_argument("--config_path", default=None, type=str, help="Path to the huggingface classifier config.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to the s3prl checkpoint.")
-    parser.add_argument("--model_dump_path", default=None, type=str, help="Path to the final converted model.")
-    args = parser.parse_args()
-    convert_s3prl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
diff --git a/src/transformers/models/idefics2/convert_idefics2_weights_to_hf.py b/src/transformers/models/idefics2/convert_idefics2_weights_to_hf.py
deleted file mode 100644
index ea44ee11e58c..000000000000
--- a/src/transformers/models/idefics2/convert_idefics2_weights_to_hf.py
+++ /dev/null
@@ -1,185 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import copy
-
-import torch
-from accelerate import init_empty_weights
-
-from transformers import (
-    AutoConfig,
-    AutoModelForCausalLM,
-    AutoTokenizer,
-    Idefics2Config,
-    Idefics2ForConditionalGeneration,
-    Idefics2ImageProcessor,
-    Idefics2Processor,
-    MistralConfig,
-)
-
-
-EPILOG_TXT = """Example:
-    python transformers/src/transformers/models/idefics2/convert_idefics2_weights_to_hf.py --original_model_id HuggingFaceM4/idefics2-8b --output_hub_path org/idefics2
-"""
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "lm_head.weight": "lm_head.linear.weight",
-    "model.layers": "model.text_model.layers",
-    "model.norm": "model.text_model.norm",
-    "model.perceiver_resampler": "model.connector.perceiver_resampler",
-    "model.modality_projection": "model.connector.modality_projection",
-}
-
-
-WEIGHTS_TO_MERGE_MAPPING = (
-    # (weights to merge in merging order), (new weight name)
-    (
-        ("model.embed_tokens.weight", "model.embed_tokens.additional_embedding.weight"),
-        "model.text_model.embed_tokens.weight",
-    ),
-    (("lm_head.linear.weight", "additional_fc.weight"), "lm_head.weight"),
-)
-
-
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if key.endswith(".inv_freq"):
-            continue
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        new_state_dict[key] = value
-    return new_state_dict
-
-
-def merge_weights(state_dict):
-    new_state_dict = copy.deepcopy(state_dict)
-
-    # Merge the weights
-    for weights_to_merge, new_weight_name in WEIGHTS_TO_MERGE_MAPPING:
-        for weight in weights_to_merge:
-            assert weight in state_dict, f"Weight {weight} is missing in the state dict"
-            if new_weight_name not in new_state_dict:
-                new_state_dict[new_weight_name] = [state_dict[weight]]
-            else:
-                new_state_dict[new_weight_name].append(state_dict[weight])
-        new_state_dict[new_weight_name] = torch.cat(new_state_dict[new_weight_name], dim=0)
-
-    # Remove the weights that were merged
-    for weights_to_merge, new_weight_name in WEIGHTS_TO_MERGE_MAPPING:
-        for weight in weights_to_merge:
-            if weight in new_state_dict and weight != new_weight_name:
-                new_state_dict.pop(weight)
-
-    return new_state_dict
-
-
-def get_config(checkpoint):
-    if checkpoint == "HuggingFaceM4/idefics2":
-        # We load the config then recreate to use the text_config
-        config = AutoConfig.from_pretrained(checkpoint)
-        text_config = MistralConfig(
-            vocab_size=config.vocab_size + config.additional_vocab_size,
-            hidden_size=config.hidden_size,
-            intermediate_size=config.intermediate_size,
-            num_hidden_layers=config.num_hidden_layers,
-            num_attention_heads=config.num_attention_heads,
-            num_key_value_heads=config.num_key_value_heads,
-            hidden_act=config.hidden_act,
-            max_position_embeddings=config.max_position_embeddings,
-            initializer_range=config.initializer_range,
-            rms_norm_eps=config.rms_norm_eps,
-            tie_word_embeddings=config.tie_word_embeddings,
-            rope_theta=config.rope_theta,
-            sliding_window=config.sliding_window,
-            attention_dropout=config.attention_dropout,
-            pad_token_id=config.pad_token_id,
-            bos_token_id=config.bos_token_id,
-            eos_token_id=config.eos_token_id,
-        )
-        perceiver_config = config.perceiver_config.to_dict()
-        config = Idefics2Config(
-            text_config=text_config.to_dict(),
-            vision_config=config.vision_config,
-            perceiver_config=perceiver_config,
-            use_cache=config.use_cache,
-            image_token_id=config.image_token_id,
-            tie_word_embeddings=config.tie_word_embeddings,
-        )
-        return config
-
-    return AutoConfig.from_pretrained(checkpoint)
-
-
-def convert_idefics2_hub_to_hf(original_model_id, output_hub_path, push_to_hub):
-    # The original model maps to AutoModelForCausalLM, converted we map to Idefics2ForConditionalGeneration
-    original_model = AutoModelForCausalLM.from_pretrained(original_model_id, trust_remote_code=True)
-    # The original model doesn't use the idefics2 processing objects
-    image_seq_len = original_model.config.perceiver_config.resampler_n_latents
-    image_processor = Idefics2ImageProcessor()
-    tokenizer = AutoTokenizer.from_pretrained(original_model_id)
-    processor = Idefics2Processor(
-        image_processor=image_processor,
-        tokenizer=tokenizer,
-        image_seq_len=image_seq_len,
-    )
-    state_dict = original_model.state_dict()
-    state_dict = convert_state_dict_to_hf(state_dict)
-
-    # Merge weights
-    state_dict = merge_weights(state_dict)
-
-    config = get_config(original_model_id)
-
-    with init_empty_weights():
-        model = Idefics2ForConditionalGeneration(config)
-
-    model.load_state_dict(state_dict, strict=True, assign=True)
-
-    model.save_pretrained(output_hub_path)
-    processor.save_pretrained(output_hub_path)
-
-    if push_to_hub:
-        model.push_to_hub(output_hub_path, private=True)
-        processor.push_to_hub(output_hub_path, private=True)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        epilog=EPILOG_TXT,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument(
-        "--original_model_id",
-        help="Hub location of the text model",
-    )
-    parser.add_argument(
-        "--output_hub_path",
-        help="Location on the hub of the converted model",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="If set, the model will be pushed to the hub after conversion.",
-    )
-    args = parser.parse_args()
-    convert_idefics2_hub_to_hf(args.original_model_id, args.output_hub_path, args.push_to_hub)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/idefics3/convert_idefics3_weights_to_hf.py b/src/transformers/models/idefics3/convert_idefics3_weights_to_hf.py
deleted file mode 100644
index 204104a58b30..000000000000
--- a/src/transformers/models/idefics3/convert_idefics3_weights_to_hf.py
+++ /dev/null
@@ -1,214 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import json
-
-import torch
-from accelerate import init_empty_weights
-from huggingface_hub import hf_hub_download
-
-from transformers import (
-    AutoModelForCausalLM,
-    AutoTokenizer,
-    Idefics3Config,
-    Idefics3ForConditionalGeneration,
-    Idefics3ImageProcessor,
-    Idefics3Processor,
-    LlamaConfig,
-)
-
-
-EPILOG_TXT = """Example:
-    python transformers/src/transformers/models/idefics3/convert_idefics3_weights_to_hf.py --original_model_id HuggingFaceM4/Idefics3-8B-Llama3 --output_hub_path org/idefics3
-"""
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "lm_head.weight": "lm_head.linear.weight",
-    "model.layers": "model.text_model.layers",
-    "model.norm": "model.text_model.norm",
-    "model.modality_projection": "model.connector.modality_projection",
-}
-
-
-WEIGHTS_TO_MERGE_MAPPING = (
-    # (weights to merge in merging order), (new weight name)
-    (
-        ("model.embed_tokens.weight", "model.embed_tokens.additional_embedding.weight"),
-        "model.text_model.embed_tokens.weight",
-    ),
-    (("lm_head.linear.weight", "additional_fc.weight"), "lm_head.weight"),
-)
-
-WEIGHTS_TO_DROP = (
-    # The original model had a vision head, but this is never used
-    "model.vision_model.head",
-)
-
-
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    old_state_dict_keys = set(state_dict.keys())
-
-    # Flattened list of weights to merge. We keep these in the original state dict to merge them later
-    original_weights_to_merge = [w for weights in WEIGHTS_TO_MERGE_MAPPING for w in weights[0]]
-
-    # for key, value in state_dict.items():
-    for old_key in old_state_dict_keys:
-        if old_key.endswith(".inv_freq") or any(w in old_key for w in WEIGHTS_TO_DROP):
-            state_dict.pop(old_key)
-            continue
-
-        key = old_key
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        weight = state_dict.pop(old_key)
-        if key in original_weights_to_merge:
-            new_state_dict[key] = weight
-            # Bit of a hack - we need to keep the original weights to merge them later
-            state_dict[key] = weight
-        else:
-            new_state_dict[key] = weight
-
-    return new_state_dict
-
-
-def merge_weights(state_dict, new_state_dict):
-    old_weight_names = set(state_dict.keys())
-
-    # Merge the weights
-    for weights_to_merge, new_weight_name in WEIGHTS_TO_MERGE_MAPPING:
-        for weight_to_merge in weights_to_merge:
-            print(weight_to_merge)
-            assert weight_to_merge in state_dict, f"Weight {weight_to_merge} is missing in the state dict"
-
-            weight = state_dict.pop(weight_to_merge)
-            if new_weight_name not in new_state_dict:
-                new_state_dict[new_weight_name] = [weight]
-            else:
-                new_state_dict[new_weight_name].append(weight)
-
-            old_weight_names.remove(weight_to_merge)
-
-        new_state_dict[new_weight_name] = torch.cat(new_state_dict[new_weight_name], dim=0)
-
-    # Remove the weights that were merged
-    for weights_to_merge, new_weight_name in WEIGHTS_TO_MERGE_MAPPING:
-        for weight in weights_to_merge:
-            if weight in new_state_dict and weight != new_weight_name:
-                new_state_dict.pop(weight)
-
-    return new_state_dict
-
-
-def get_config(checkpoint):
-    # We load the config then recreate to use the text_config
-
-    # download the config file
-    filepath = hf_hub_download(repo_id=checkpoint, filename="config.json")
-    with open(filepath, "r") as f:
-        config_json = json.load(f)
-
-    # Setup the vision config
-    vision_config = config_json.pop("vision_config")
-    vision_config.pop("vision_model_name", None)
-    if "embed_dim" in vision_config:
-        vision_config["hidden_size"] = vision_config.pop("embed_dim")
-
-    config_json["vocab_size"] = config_json.pop("vocab_size") + config_json.pop("additional_vocab_size")
-
-    image_token_id = config_json.pop("image_token_id", config_json["vocab_size"] - 2)
-    use_cache = config_json.pop("use_cache", True)
-    tie_word_embeddings = config_json.pop("tie_word_embeddings", True)
-    scale_factor = config_json.pop("scale_factor", 2)
-    vocab_size = config_json.pop("vocab_size", 100000)
-
-    # Remove "freeze" params from the config
-    config_json = {k: v for k, v in config_json.items() if not k.startswith("freeze_")}
-    text_config = LlamaConfig(**config_json)
-
-    config = Idefics3Config(
-        text_config=text_config,
-        vision_config=vision_config,
-        use_cache=use_cache,
-        image_token_id=image_token_id,
-        tie_word_embeddings=tie_word_embeddings,
-        scale_factor=scale_factor,
-        vocab_size=vocab_size,
-    )
-    return config
-
-
-def convert_idefics3_hub_to_hf(original_model_id, output_hub_path, push_to_hub):
-    # The original model maps to AutoModelForCausalLM, converted we map to Idefics3ForConditionalGeneration
-    original_model = AutoModelForCausalLM.from_pretrained(
-        original_model_id, trust_remote_code=True, torch_dtype=torch.bfloat16
-    )
-    # The original model doesn't use the Idefics3 processing objects
-    image_processor = Idefics3ImageProcessor()
-    tokenizer = AutoTokenizer.from_pretrained(original_model_id)
-    processor = Idefics3Processor(
-        image_processor=image_processor,
-        tokenizer=tokenizer,
-    )
-    state_dict = original_model.state_dict()
-    new_state_dict = convert_state_dict_to_hf(state_dict)
-
-    # Merge weights
-    new_state_dict = merge_weights(state_dict, new_state_dict)
-    del state_dict
-
-    config = get_config(original_model_id)
-    print(config)
-
-    with init_empty_weights():
-        model = Idefics3ForConditionalGeneration(config)
-
-    model.load_state_dict(new_state_dict, strict=True, assign=True)
-
-    model.save_pretrained(output_hub_path)
-    processor.save_pretrained(output_hub_path)
-
-    if push_to_hub:
-        model.push_to_hub(output_hub_path, private=True)
-        processor.push_to_hub(output_hub_path, private=True)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        epilog=EPILOG_TXT,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument(
-        "--original_model_id",
-        help="Hub location of the text model",
-    )
-    parser.add_argument(
-        "--output_hub_path",
-        help="Location on the hub of the converted model",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="If set, the model will be pushed to the hub after conversion.",
-    )
-    args = parser.parse_args()
-    convert_idefics3_hub_to_hf(args.original_model_id, args.output_hub_path, args.push_to_hub)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/ijepa/convert_ijepa_to_hf.py b/src/transformers/models/ijepa/convert_ijepa_to_hf.py
deleted file mode 100644
index 5c15a72ff888..000000000000
--- a/src/transformers/models/ijepa/convert_ijepa_to_hf.py
+++ /dev/null
@@ -1,267 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert IJEPA checkpoints from the original repository.
-
-URL: https://github.com/facebookresearch/ijepa
-"""
-
-import argparse
-import gc
-import re
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import (
-    IJepaConfig,
-    IJepaModel,
-    ViTImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-# fmt: off
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    # Projection layer + position embeddings
-    r"pos_embed":                               r"embeddings.position_embeddings",
-    r"patch_embed.proj.weight":                 r"embeddings.patch_embeddings.projection.weight",
-    r"patch_embed.proj.bias":                   r"embeddings.patch_embeddings.projection.bias",
-
-    # Encoder layers: Layernorms, Attention, Feedforward layers
-    r"blocks.(\d+).norm1.weight":               r"encoder.layer.\1.layernorm_before.weight",
-    r"blocks.(\d+).norm1.bias":                 r"encoder.layer.\1.layernorm_before.bias",
-    r"blocks.(\d+).attn.proj.weight":           r"encoder.layer.\1.attention.output.dense.weight",
-    r"blocks.(\d+).attn.proj.bias":             r"encoder.layer.\1.attention.output.dense.bias",
-    r"blocks.(\d+).norm2.weight":               r"encoder.layer.\1.layernorm_after.weight",
-    r"blocks.(\d+).norm2.bias":                 r"encoder.layer.\1.layernorm_after.bias",
-    r"blocks.(\d+).mlp.fc1.weight":             r"encoder.layer.\1.intermediate.dense.weight",
-    r"blocks.(\d+).mlp.fc1.bias":               r"encoder.layer.\1.intermediate.dense.bias",
-    r"blocks.(\d+).mlp.fc2.weight":             r"encoder.layer.\1.output.dense.weight",
-    r"blocks.(\d+).mlp.fc2.bias":               r"encoder.layer.\1.output.dense.bias",
-
-    # Layernorm + pooler
-    r"norm.weight":                             r"layernorm.weight",
-    r"norm.bias":                               r"layernorm.bias",
-}
-# fmt: on
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    """
-    Converts old keys to new keys using the mapping and dynamically removes the 'ijepa.' prefix if necessary.
-
-    Args:
-        state_dict_keys (dict): The keys from the state_dict to convert.
-
-    Returns:
-        dict: A mapping from old keys to new keys.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-
-        # Apply regex-based mapping
-        for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-            if replacement is None:
-                new_text = re.sub(pattern, "", new_text)  # Skip the key
-                continue
-            new_text = re.sub(pattern, replacement, new_text)
-
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-
-    return output_dict
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    for i in range(config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[: config.hidden_size, :]
-        state_dict[f"encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[-config.hidden_size :, :]
-        state_dict[f"encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-def get_ijepa_config(model_name):
-    patch_size = int(model_name.split("_")[1][4:])
-    config = IJepaConfig(patch_size=patch_size)
-    if "vith" in model_name:
-        config.hidden_size = 1280
-        config.num_hidden_layers = 32
-        config.num_attention_heads = 16
-        config.layer_norm_eps = 1e-6
-        config.mlp_ratio = 4
-        config.intermediate_size = 5120
-        if model_name == "ijepa_vith16_1k":
-            config.image_size = 448
-    elif "vitg" in model_name:
-        config.hidden_size = 1408
-        config.num_hidden_layers = 40
-        config.num_attention_heads = 16
-        config.layer_norm_eps = 1e-6
-        config.mlp_ratio = 48 / 11
-        config.intermediate_size = 6144
-    else:
-        raise ValueError("Model not supported, only supports huge and giant models.")
-    return config
-
-
-@torch.no_grad()
-def write_model(model_name, output_dir, safe_serialization, push_to_hub, verify_logits):
-    """
-    Copy/paste/tweak model's weights to our IJEPA structure.
-    """
-
-    # define default IJEPA configuration
-    config = get_ijepa_config(model_name)
-
-    checkpoint_mapping = {
-        "ijepa_vith14_1k": "https://dl.fbaipublicfiles.com/ijepa/IN1K-vit.h.14-300e.pth.tar",
-        "ijepa_vith14_22k": "https://dl.fbaipublicfiles.com/ijepa/IN22K-vit.h.14-900e.pth.tar",
-        "ijepa_vith16_1k": "https://dl.fbaipublicfiles.com/ijepa/IN1K-vit.h.16-448px-300e.pth.tar",
-        "ijepa_vitg16_22k": "https://dl.fbaipublicfiles.com/ijepa/IN22K-vit.g.16-600e.pth.tar",
-    }
-
-    # Load original checkpoint
-    checkpoint_url = checkpoint_mapping[model_name]
-    original_state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["encoder"]
-    original_state_dict = {k.replace("module.", ""): v for k, v in original_state_dict.items()}
-
-    # Rename keys
-    state_dict = original_state_dict.copy()
-    new_keys = convert_old_keys_to_new_keys(state_dict.keys())
-    for old_key, new_key in new_keys.items():
-        rename_key(state_dict, old_key, new_key)
-    read_in_q_k_v(state_dict, config)
-
-    # load HuggingFace model
-    model = IJepaModel(config, add_pooling_layer=False).eval()
-    model.load_state_dict(state_dict)
-    size = {"height": config.image_size, "width": config.image_size}
-    image_processor = ViTImageProcessor(size=size)
-
-    if verify_logits:
-        # Check outputs on an image, prepared by ViTImageProcessor
-        encoding = image_processor(images=prepare_img(), return_tensors="pt")
-        pixel_values = encoding["pixel_values"]
-        with torch.no_grad():
-            outputs = model(pixel_values)
-
-        expected_slices = {
-            "ijepa_vith14_1k": torch.Tensor(
-                [[-0.0621, -0.0054, -2.7513], [-0.1952, 0.0909, -3.9536], [0.0942, -0.0331, -1.2833]]
-            ),
-            "ijepa_vith14_22k": torch.Tensor(
-                [[0.0358, -0.0045, -0.2154], [0.0418, -0.0246, 0.0108], [0.2529, -0.0345, -0.0246]]
-            ),
-            "ijepa_vith16_1k": torch.Tensor(
-                [[0.5145, -0.1259, 0.0615], [0.1132, 0.0028, -0.0496], [1.1586, -0.0056, -0.0387]]
-            ),
-            "ijepa_vitg16_22k": torch.Tensor(
-                [[0.0512, -0.0510, -0.0649], [0.1972, 0.0380, -0.0790], [0.1667, -0.0834, -0.1240]]
-            ),
-        }
-
-        assert torch.allclose(
-            expected_slices[model_name],
-            outputs.last_hidden_state[0, :3, :3],
-            atol=1e-4,
-        )
-
-    if output_dir:
-        Path(output_dir).mkdir(exist_ok=True)
-        print(f"Saving model {model_name} to {output_dir}")
-        image_processor.save_pretrained(output_dir, safe_serialization=safe_serialization)
-        model.save_pretrained(output_dir, safe_serialization=safe_serialization)
-
-    if push_to_hub:
-        image_processor.push_to_hub(repo_id=f"jmtzt/{model_name}", safe_serialization=safe_serialization)
-        model.push_to_hub(repo_id=f"jmtzt/{model_name}", safe_serialization=safe_serialization)
-
-    if output_dir:
-        del model, state_dict
-        gc.collect()
-        print("Reloading the model to check if it's saved correctly.")
-        IJepaModel.from_pretrained(output_dir, device_map="auto")
-        print("Model reloaded successfully.")
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="ijepa_vith14_1k",
-        type=str,
-        choices=[
-            "ijepa_vith14_1k",
-            "ijepa_vith14_22k",
-            "ijepa_vith16_1k",
-            "ijepa_vitg16_22k",
-        ],
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--output_dir",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--safe_serialization", default=True, type=bool, help="Whether or not to save using `safetensors`."
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether or not to push the model to the 🤗 Hub.",
-    )
-    parser.add_argument(
-        "--verify_logits", action="store_false", help="Whether or not to verify logits after conversion."
-    )
-
-    parser.set_defaults()
-    args = parser.parse_args()
-    write_model(args.model_name, args.output_dir, args.safe_serialization, args.push_to_hub, args.verify_logits)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/imagegpt/convert_imagegpt_original_tf2_to_pytorch.py b/src/transformers/models/imagegpt/convert_imagegpt_original_tf2_to_pytorch.py
deleted file mode 100644
index 182d66b9af28..000000000000
--- a/src/transformers/models/imagegpt/convert_imagegpt_original_tf2_to_pytorch.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert OpenAI Image GPT checkpoints."""
-
-import argparse
-
-import torch
-
-from transformers import ImageGPTConfig, ImageGPTForCausalLM, load_tf_weights_in_imagegpt
-from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_imagegpt_checkpoint_to_pytorch(imagegpt_checkpoint_path, model_size, pytorch_dump_folder_path):
-    # Construct configuration depending on size
-    MODELS = {"small": (512, 8, 24), "medium": (1024, 8, 36), "large": (1536, 16, 48)}
-    n_embd, n_head, n_layer = MODELS[model_size]  # set model hyperparameters
-    config = ImageGPTConfig(n_embd=n_embd, n_layer=n_layer, n_head=n_head)
-    model = ImageGPTForCausalLM(config)
-
-    # Load weights from numpy
-    load_tf_weights_in_imagegpt(model, config, imagegpt_checkpoint_path)
-
-    # Save pytorch-model
-    pytorch_weights_dump_path = pytorch_dump_folder_path + "/" + WEIGHTS_NAME
-    pytorch_config_dump_path = pytorch_dump_folder_path + "/" + CONFIG_NAME
-    print(f"Save PyTorch model to {pytorch_weights_dump_path}")
-    torch.save(model.state_dict(), pytorch_weights_dump_path)
-    print(f"Save configuration file to {pytorch_config_dump_path}")
-    with open(pytorch_config_dump_path, "w", encoding="utf-8") as f:
-        f.write(config.to_json_string())
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--imagegpt_checkpoint_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the TensorFlow checkpoint path.",
-    )
-    parser.add_argument(
-        "--model_size",
-        default=None,
-        type=str,
-        required=True,
-        help="Size of the model (can be either 'small', 'medium' or 'large').",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_imagegpt_checkpoint_to_pytorch(
-        args.imagegpt_checkpoint_path, args.model_size, args.pytorch_dump_folder_path
-    )
diff --git a/src/transformers/models/instructblip/convert_instructblip_original_to_pytorch.py b/src/transformers/models/instructblip/convert_instructblip_original_to_pytorch.py
deleted file mode 100644
index f8b9c86cfddc..000000000000
--- a/src/transformers/models/instructblip/convert_instructblip_original_to_pytorch.py
+++ /dev/null
@@ -1,303 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Convert InstructBLIP checkpoints from the original repository.
-
-URL: https://github.com/salesforce/LAVIS/tree/main/projects/instructblip
-"""
-
-import argparse
-
-import requests
-import torch
-
-# pip3 install salesforce-lavis
-# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis_float32 (there's also the fix_lavis branch)
-# also note: to convert Vicuna checkpoints, we had to include /home/niels/python_projects/checkpoints/FastChat/vicuna-7b in lavis/configs/models/blip2/blip2_instruct_vicuna7b.yaml
-# same for Vicuna-13b
-from lavis.models import load_model_and_preprocess
-from PIL import Image
-
-from transformers import (
-    AutoTokenizer,
-    BlipImageProcessor,
-    InstructBlipConfig,
-    InstructBlipForConditionalGeneration,
-    InstructBlipProcessor,
-    InstructBlipQFormerConfig,
-    InstructBlipVisionConfig,
-    LlamaConfig,
-    LlamaTokenizerFast,
-    T5Config,
-    T5TokenizerFast,
-)
-from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
-
-
-def load_demo_image():
-    url = "https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-
-    return image
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-    # fmt: off
-
-    # vision encoder
-    rename_keys.append(("visual_encoder.cls_token", "vision_model.embeddings.class_embedding"))
-    rename_keys.append(("visual_encoder.pos_embed", "vision_model.embeddings.position_embedding"))
-    rename_keys.append(("visual_encoder.patch_embed.proj.weight", "vision_model.embeddings.patch_embedding.weight"))
-    rename_keys.append(("visual_encoder.patch_embed.proj.bias", "vision_model.embeddings.patch_embedding.bias"))
-    rename_keys.append(("ln_vision.weight", "vision_model.post_layernorm.weight"))
-    rename_keys.append(("ln_vision.bias", "vision_model.post_layernorm.bias"))
-
-    for i in range(config.vision_config.num_hidden_layers):
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm1.weight", f"vision_model.encoder.layers.{i}.layer_norm1.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm1.bias", f"vision_model.encoder.layers.{i}.layer_norm1.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm2.weight", f"vision_model.encoder.layers.{i}.layer_norm2.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm2.bias", f"vision_model.encoder.layers.{i}.layer_norm2.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.qkv.weight", f"vision_model.encoder.layers.{i}.self_attn.qkv.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.proj.weight", f"vision_model.encoder.layers.{i}.self_attn.projection.weight",))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.proj.bias", f"vision_model.encoder.layers.{i}.self_attn.projection.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc1.weight", f"vision_model.encoder.layers.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc1.bias", f"vision_model.encoder.layers.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc2.weight", f"vision_model.encoder.layers.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc2.bias", f"vision_model.encoder.layers.{i}.mlp.fc2.bias"))
-
-    # QFormer
-    rename_keys.append(("Qformer.bert.embeddings.LayerNorm.weight", "qformer.embeddings.layernorm.weight"))
-    rename_keys.append(("Qformer.bert.embeddings.LayerNorm.bias", "qformer.embeddings.layernorm.bias"))
-
-    # fmt: on
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def read_in_q_v_bias(state_dict, config):
-    for i in range(config.vision_config.num_hidden_layers):
-        # read in original q and v biases
-        q_bias = state_dict.pop(f"visual_encoder.blocks.{i}.attn.q_bias")
-        v_bias = state_dict.pop(f"visual_encoder.blocks.{i}.attn.v_bias")
-
-        # next, set bias in the state dict
-        qkv_bias = torch.cat((q_bias, torch.zeros_like(v_bias, requires_grad=False), v_bias))
-        state_dict[f"vision_model.encoder.layers.{i}.self_attn.qkv.bias"] = qkv_bias
-
-
-def get_blip2_config(model_name):
-    image_size = 364 if "coco" in model_name else 224
-    vision_config = InstructBlipVisionConfig(image_size=image_size).to_dict()
-
-    # make sure the models have proper bos_token_id and eos_token_id set (important for generation)
-    # seems like flan-T5 models don't have bos_token_id properly set?
-    if "t5-xl" in model_name:
-        text_config = T5Config.from_pretrained("google/flan-t5-xl", dense_act_fn="gelu", bos_token_id=1).to_dict()
-    elif "t5-xxl" in model_name:
-        text_config = T5Config.from_pretrained("google/flan-t5-xxl", dense_act_fn="gelu", bos_token_id=1).to_dict()
-    elif "vicuna-7b" in model_name:
-        text_config = LlamaConfig.from_pretrained("decapoda-research/llama-7b-hf", vocab_size=32001).to_dict()
-    elif "vicuna-13b" in model_name:
-        text_config = LlamaConfig.from_pretrained("decapoda-research/llama-13b-hf", vocab_size=32001).to_dict()
-    else:
-        raise ValueError("Model name not supported")
-
-    # the authors add one special "[DEC]" token to the vocab of Q-Former, hence vocab size = 30522 + 1
-    qformer_config = InstructBlipQFormerConfig(vocab_size=30523).to_dict()
-    config = InstructBlipConfig(vision_config=vision_config, text_config=text_config, qformer_config=qformer_config)
-
-    return config, image_size
-
-
-@torch.no_grad()
-def convert_blip2_checkpoint(model_name, pytorch_dump_folder_path=None, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to Transformers design.
-    """
-    qformer_tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased", truncation_side="left")
-    qformer_tokenizer.add_special_tokens({"bos_token": "[DEC]"})
-
-    if "t5" in model_name:
-        tokenizer = T5TokenizerFast.from_pretrained("google/flan-t5-xl", truncation_side="left")
-    elif "vicuna" in model_name:
-        # the following was used in the original implementation:
-        # tokenizer = LlamaTokenizer.from_pretrained("huggyllama/llama-7b", use_fast=False, truncation_side="left")
-        # tokenizer.add_special_tokens({"pad_token": "[PAD]"})
-        # tokenizer.add_special_tokens({"bos_token": "</s>"})
-        # tokenizer.add_special_tokens({"eos_token": "</s>"})
-        # tokenizer.add_special_tokens({"unk_token": "</s>"})
-        tokenizer = LlamaTokenizerFast.from_pretrained(
-            "huggyllama/llama-7b", truncation_side="left", bos_token="</s>", unk_token="</s>"
-        )
-        tokenizer.add_special_tokens({"pad_token": "[PAD]"})
-
-    config, image_size = get_blip2_config(model_name)
-    hf_model = InstructBlipForConditionalGeneration(config).eval()
-
-    model_name_to_original = {
-        "instructblip-vicuna-7b": ("blip2_vicuna_instruct", "vicuna7b"),
-        "instructblip-vicuna-13b": ("blip2_vicuna_instruct", "vicuna13b"),
-        "instructblip-flan-t5-xl": ("blip2_t5_instruct", "flant5xl"),
-        "instructblip-flan-t5-xxl": ("blip2_t5_instruct", "flant5xxl"),
-    }
-
-    name, type = model_name_to_original[model_name]
-
-    # load original model
-    print("Loading original model...")
-    hf_model_device = "cuda:1" if torch.cuda.is_available() else "cpu"
-    lavis_device = "cuda:2" if torch.cuda.is_available() else "cpu"
-    original_model, vis_processors, _ = load_model_and_preprocess(
-        name=name, model_type=type, is_eval=True, device=lavis_device
-    )
-    original_model.eval()
-    print("Done!")
-
-    # update state dict keys
-    state_dict = original_model.state_dict()
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-
-    # some keys can be renamed efficiently
-    for key, val in state_dict.copy().items():
-        val = state_dict.pop(key)
-        if key.startswith("Qformer.bert"):
-            key = key.replace("Qformer.bert", "qformer")
-        if "attention.self" in key:
-            key = key.replace("self", "attention")
-        if "llm_proj" in key:
-            key = key.replace("llm_proj", "language_projection")
-        if "t5_proj" in key:
-            key = key.replace("t5_proj", "language_projection")
-        if key.startswith("llm_model"):
-            key = key.replace("llm_model", "language_model")
-        if key.startswith("t5"):
-            key = key.replace("t5", "language")
-        state_dict[key] = val
-
-    # read in qv biases
-    read_in_q_v_bias(state_dict, config)
-
-    # note: weights get loaded in torch.float32 by default
-    hf_model.load_state_dict(state_dict, strict=True)
-
-    image = load_demo_image()
-    prompt = "What is unusual about this image?"
-
-    # create processor
-    image_processor = BlipImageProcessor(
-        size={"height": image_size, "width": image_size}, image_mean=OPENAI_CLIP_MEAN, image_std=OPENAI_CLIP_STD
-    )
-    processor = InstructBlipProcessor(
-        image_processor=image_processor,
-        tokenizer=tokenizer,
-        qformer_tokenizer=qformer_tokenizer,
-    )
-    inputs = processor(images=image, text=prompt, return_tensors="pt").to(hf_model_device)
-
-    # make sure processor creates exact same pixel values
-    original_pixel_values = vis_processors["eval"](image).unsqueeze(0).to(lavis_device)
-    pixel_values = inputs.pixel_values
-    assert torch.allclose(original_pixel_values.to(pixel_values.device), pixel_values)
-
-    original_model.to(lavis_device)
-    hf_model.to(hf_model_device)
-    with torch.no_grad():
-        if "vicuna" in model_name:
-            original_logits = original_model({"image": original_pixel_values, "text_input": [prompt]}).logits
-            logits = hf_model(**inputs).logits
-        else:
-            original_logits = original_model(
-                {"image": original_pixel_values, "text_input": [prompt], "text_output": ["\n"]}
-            ).logits
-            label_input_ids = tokenizer("\n", return_tensors="pt").input_ids.to(hf_model_device)
-            labels = label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id, -100)
-            logits = hf_model(**inputs, labels=labels).logits
-
-    print("First values of original logits:", original_logits[0, :3, :3])
-    print("First values of HF logits:", logits[0, :3, :3])
-
-    # assert values
-    assert original_logits.shape == logits.shape
-    atol = 1e-4 if "vicuna" in model_name else 1e-5
-    assert torch.allclose(original_logits.to(logits.device), logits, atol=atol)
-    print("Looks ok!")
-
-    print("Generating with original model...")
-    original_outputs = original_model.generate({"image": original_pixel_values, "prompt": prompt}, num_beams=5)
-
-    # important: we need to cast the weights of the HF model to the appropriate type
-    print("Generating with HF model...")
-    outputs = hf_model.generate(
-        **inputs,
-        do_sample=False,
-        num_beams=5,
-        max_length=256,
-        min_length=1,
-        top_p=0.9,
-        repetition_penalty=1.5,
-        length_penalty=1.0,
-        temperature=1,
-    )
-    if "vicuna" in model_name:
-        # convert output id 0 to 2 (eos_token_id)
-        # TODO add this in the generate method?
-        outputs[outputs == 0] = 2
-    print("Original generation:", original_outputs)
-    output_text = processor.batch_decode(outputs, skip_special_tokens=True)
-    output_text = [text.strip() for text in output_text]
-    print("HF generation:", output_text)
-
-    if pytorch_dump_folder_path is not None:
-        processor.save_pretrained(pytorch_dump_folder_path)
-        hf_model.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        processor.push_to_hub(f"Salesforce/{model_name}")
-        hf_model.push_to_hub(f"Salesforce/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    choices = [
-        "instructblip-vicuna-7b",
-        "instructblip-vicuna-13b",
-        "instructblip-flan-t5-xl",
-        "instructblip-flan-t5-xxl",
-    ]
-    parser.add_argument(
-        "--model_name",
-        default="instructblip-flan-t5-xl",
-        choices=choices,
-        type=str,
-        help="Path to hf config.json of model to convert",
-    )
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model and processor to the hub after converting",
-    )
-
-    args = parser.parse_args()
-
-    convert_blip2_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/instructblipvideo/convert_instructblipvideo_original_to_pytorch.py b/src/transformers/models/instructblipvideo/convert_instructblipvideo_original_to_pytorch.py
deleted file mode 100644
index 9b3d508db6ff..000000000000
--- a/src/transformers/models/instructblipvideo/convert_instructblipvideo_original_to_pytorch.py
+++ /dev/null
@@ -1,305 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Convert InstructBlipVideo checkpoints from the original repository.
-
-URL: https://github.com/salesforce/LAVIS/tree/main/projects/instructblipvideo
-"""
-
-import argparse
-
-import requests
-import torch
-
-# pip3 install salesforce-lavis
-# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis_float32 (there's also the fix_lavis branch)
-# also note: to convert Vicuna checkpoints, we had to include /home/niels/python_projects/checkpoints/FastChat/vicuna-7b in lavis/configs/models/blip2/blip2_instruct_vicuna7b.yaml
-# same for Vicuna-13b
-from lavis.models import load_model_and_preprocess
-from PIL import Image
-
-from transformers import (
-    AutoTokenizer,
-    BlipImageProcessor,
-    InstructBlipProcessor,
-    InstructBlipVideoConfig,
-    InstructBlipVideoForConditionalGeneration,
-    InstructBlipVideoQFormerConfig,
-    InstructBlipVideoVisionConfig,
-    LlamaConfig,
-    LlamaTokenizerFast,
-    T5Config,
-    T5TokenizerFast,
-)
-from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
-
-
-def load_demo_image():
-    url = "https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-
-    return image
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-    # fmt: off
-
-    # vision encoder
-    rename_keys.append(("visual_encoder.cls_token", "vision_model.embeddings.class_embedding"))
-    rename_keys.append(("visual_encoder.pos_embed", "vision_model.embeddings.position_embedding"))
-    rename_keys.append(("visual_encoder.patch_embed.proj.weight", "vision_model.embeddings.patch_embedding.weight"))
-    rename_keys.append(("visual_encoder.patch_embed.proj.bias", "vision_model.embeddings.patch_embedding.bias"))
-    rename_keys.append(("ln_vision.weight", "vision_model.post_layernorm.weight"))
-    rename_keys.append(("ln_vision.bias", "vision_model.post_layernorm.bias"))
-
-    for i in range(config.vision_config.num_hidden_layers):
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm1.weight", f"vision_model.encoder.layers.{i}.layer_norm1.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm1.bias", f"vision_model.encoder.layers.{i}.layer_norm1.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm2.weight", f"vision_model.encoder.layers.{i}.layer_norm2.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.norm2.bias", f"vision_model.encoder.layers.{i}.layer_norm2.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.qkv.weight", f"vision_model.encoder.layers.{i}.self_attn.qkv.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.proj.weight", f"vision_model.encoder.layers.{i}.self_attn.projection.weight",))
-        rename_keys.append((f"visual_encoder.blocks.{i}.attn.proj.bias", f"vision_model.encoder.layers.{i}.self_attn.projection.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc1.weight", f"vision_model.encoder.layers.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc1.bias", f"vision_model.encoder.layers.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc2.weight", f"vision_model.encoder.layers.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc2.bias", f"vision_model.encoder.layers.{i}.mlp.fc2.bias"))
-
-    # QFormer
-    rename_keys.append(("Qformer.bert.embeddings.LayerNorm.weight", "qformer.embeddings.layernorm.weight"))
-    rename_keys.append(("Qformer.bert.embeddings.LayerNorm.bias", "qformer.embeddings.layernorm.bias"))
-
-    # fmt: on
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def read_in_q_v_bias(state_dict, config):
-    for i in range(config.vision_config.num_hidden_layers):
-        # read in original q and v biases
-        q_bias = state_dict.pop(f"visual_encoder.blocks.{i}.attn.q_bias")
-        v_bias = state_dict.pop(f"visual_encoder.blocks.{i}.attn.v_bias")
-
-        # next, set bias in the state dict
-        qkv_bias = torch.cat((q_bias, torch.zeros_like(v_bias, requires_grad=False), v_bias))
-        state_dict[f"vision_model.encoder.layers.{i}.self_attn.qkv.bias"] = qkv_bias
-
-
-def get_blip2_config(model_name):
-    image_size = 364 if "coco" in model_name else 224
-    vision_config = InstructBlipVideoVisionConfig(image_size=image_size).to_dict()
-
-    # make sure the models have proper bos_token_id and eos_token_id set (important for generation)
-    # seems like flan-T5 models don't have bos_token_id properly set?
-    if "t5-xl" in model_name:
-        text_config = T5Config.from_pretrained("google/flan-t5-xl", dense_act_fn="gelu", bos_token_id=1).to_dict()
-    elif "t5-xxl" in model_name:
-        text_config = T5Config.from_pretrained("google/flan-t5-xxl", dense_act_fn="gelu", bos_token_id=1).to_dict()
-    elif "vicuna-7b" in model_name:
-        text_config = LlamaConfig.from_pretrained("decapoda-research/llama-7b-hf", vocab_size=32001).to_dict()
-    elif "vicuna-13b" in model_name:
-        text_config = LlamaConfig.from_pretrained("decapoda-research/llama-13b-hf", vocab_size=32001).to_dict()
-    else:
-        raise ValueError("Model name not supported")
-
-    # the authors add one special "[DEC]" token to the vocab of Q-Former, hence vocab size = 30522 + 1
-    qformer_config = InstructBlipVideoQFormerConfig(vocab_size=30523).to_dict()
-    config = InstructBlipVideoConfig(
-        vision_config=vision_config, text_config=text_config, qformer_config=qformer_config
-    )
-
-    return config, image_size
-
-
-@torch.no_grad()
-def convert_blip2_checkpoint(model_name, pytorch_dump_folder_path=None, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to Transformers design.
-    """
-    qformer_tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased", truncation_side="left")
-    qformer_tokenizer.add_special_tokens({"bos_token": "[DEC]"})
-
-    if "t5" in model_name:
-        tokenizer = T5TokenizerFast.from_pretrained("google/flan-t5-xl", truncation_side="left")
-    elif "vicuna" in model_name:
-        # the following was used in the original implementation:
-        # tokenizer = LlamaTokenizer.from_pretrained("huggyllama/llama-7b", use_fast=False, truncation_side="left")
-        # tokenizer.add_special_tokens({"pad_token": "[PAD]"})
-        # tokenizer.add_special_tokens({"bos_token": "</s>"})
-        # tokenizer.add_special_tokens({"eos_token": "</s>"})
-        # tokenizer.add_special_tokens({"unk_token": "</s>"})
-        tokenizer = LlamaTokenizerFast.from_pretrained(
-            "huggyllama/llama-7b", truncation_side="left", bos_token="</s>", unk_token="</s>"
-        )
-        tokenizer.add_special_tokens({"pad_token": "[PAD]"})
-
-    config, image_size = get_blip2_config(model_name)
-    hf_model = InstructBlipVideoForConditionalGeneration(config).eval()
-
-    model_name_to_original = {
-        "instructblipvideo-vicuna-7b": ("blip2_vicuna_instruct", "vicuna7b"),
-        "instructblipvideo-vicuna-13b": ("blip2_vicuna_instruct", "vicuna13b"),
-        "instructblipvideo-flan-t5-xl": ("blip2_t5_instruct", "flant5xl"),
-        "instructblipvideo-flan-t5-xxl": ("blip2_t5_instruct", "flant5xxl"),
-    }
-
-    name, type = model_name_to_original[model_name]
-
-    # load original model
-    print("Loading original model...")
-    hf_model_device = "cuda:1" if torch.cuda.is_available() else "cpu"
-    lavis_device = "cuda:2" if torch.cuda.is_available() else "cpu"
-    original_model, vis_processors, _ = load_model_and_preprocess(
-        name=name, model_type=type, is_eval=True, device=lavis_device
-    )
-    original_model.eval()
-    print("Done!")
-
-    # update state dict keys
-    state_dict = original_model.state_dict()
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-
-    # some keys can be renamed efficiently
-    for key, val in state_dict.copy().items():
-        val = state_dict.pop(key)
-        if key.startswith("Qformer.bert"):
-            key = key.replace("Qformer.bert", "qformer")
-        if "attention.self" in key:
-            key = key.replace("self", "attention")
-        if "llm_proj" in key:
-            key = key.replace("llm_proj", "language_projection")
-        if "t5_proj" in key:
-            key = key.replace("t5_proj", "language_projection")
-        if key.startswith("llm_model"):
-            key = key.replace("llm_model", "language_model")
-        if key.startswith("t5"):
-            key = key.replace("t5", "language")
-        state_dict[key] = val
-
-    # read in qv biases
-    read_in_q_v_bias(state_dict, config)
-
-    # note: weights get loaded in torch.float32 by default
-    hf_model.load_state_dict(state_dict, strict=True)
-
-    image = load_demo_image()
-    prompt = "What is unusual about this image?"
-
-    # create processor
-    image_processor = BlipImageProcessor(
-        size={"height": image_size, "width": image_size}, image_mean=OPENAI_CLIP_MEAN, image_std=OPENAI_CLIP_STD
-    )
-    processor = InstructBlipProcessor(
-        image_processor=image_processor,
-        tokenizer=tokenizer,
-        qformer_tokenizer=qformer_tokenizer,
-    )
-    inputs = processor(images=image, text=prompt, return_tensors="pt").to(hf_model_device)
-
-    # make sure processor creates exact same pixel values
-    original_pixel_values = vis_processors["eval"](image).unsqueeze(0).to(lavis_device)
-    pixel_values = inputs.pixel_values
-    assert torch.allclose(original_pixel_values.to(pixel_values.device), pixel_values)
-
-    original_model.to(lavis_device)
-    hf_model.to(hf_model_device)
-    with torch.no_grad():
-        if "vicuna" in model_name:
-            original_logits = original_model({"image": original_pixel_values, "text_input": [prompt]}).logits
-            logits = hf_model(**inputs).logits
-        else:
-            original_logits = original_model(
-                {"image": original_pixel_values, "text_input": [prompt], "text_output": ["\n"]}
-            ).logits
-            label_input_ids = tokenizer("\n", return_tensors="pt").input_ids.to(hf_model_device)
-            labels = label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id, -100)
-            logits = hf_model(**inputs, labels=labels).logits
-
-    print("First values of original logits:", original_logits[0, :3, :3])
-    print("First values of HF logits:", logits[0, :3, :3])
-
-    # assert values
-    assert original_logits.shape == logits.shape
-    atol = 1e-4 if "vicuna" in model_name else 1e-5
-    assert torch.allclose(original_logits.to(logits.device), logits, atol=atol)
-    print("Looks ok!")
-
-    print("Generating with original model...")
-    original_outputs = original_model.generate({"image": original_pixel_values, "prompt": prompt}, num_beams=5)
-
-    # important: we need to cast the weights of the HF model to the appropriate type
-    print("Generating with HF model...")
-    outputs = hf_model.generate(
-        **inputs,
-        do_sample=False,
-        num_beams=5,
-        max_length=256,
-        min_length=1,
-        top_p=0.9,
-        repetition_penalty=1.5,
-        length_penalty=1.0,
-        temperature=1,
-    )
-    if "vicuna" in model_name:
-        # convert output id 0 to 2 (eos_token_id)
-        # TODO add this in the generate method?
-        outputs[outputs == 0] = 2
-    print("Original generation:", original_outputs)
-    output_text = processor.batch_decode(outputs, skip_special_tokens=True)
-    output_text = [text.strip() for text in output_text]
-    print("HF generation:", output_text)
-
-    if pytorch_dump_folder_path is not None:
-        processor.save_pretrained(pytorch_dump_folder_path)
-        hf_model.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        processor.push_to_hub(f"Salesforce/{model_name}")
-        hf_model.push_to_hub(f"Salesforce/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    choices = [
-        "instructblipvideo-vicuna-7b",
-        "instructblipvideo-vicuna-13b",
-        "instructblipvideo-flan-t5-xl",
-        "instructblipvideo-flan-t5-xxl",
-    ]
-    parser.add_argument(
-        "--model_name",
-        default="instructblipvideo-flan-t5-xl",
-        choices=choices,
-        type=str,
-        help="Path to hf config.json of model to convert",
-    )
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model and processor to the hub after converting",
-    )
-
-    args = parser.parse_args()
-
-    convert_blip2_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/kosmos2/convert_kosmos2_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/kosmos2/convert_kosmos2_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 04c7712aa846..000000000000
--- a/src/transformers/models/kosmos2/convert_kosmos2_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,77 +0,0 @@
-import argparse
-
-from fairseq.checkpoint_utils import load_checkpoint_to_cpu
-
-from transformers import Kosmos2Config, Kosmos2ForConditionalGeneration
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "gpt_model.decoder.output_projection": "text_model.lm_head",
-    "gpt_model.decoder": "text_model.model",
-    "img_connector": "image_to_text_projection",
-    "img_model.visual.class_embedding": "vision_model.model.embeddings.class_embedding",
-    "img_model.visual.positional_embedding": "vision_model.model.embeddings.position_embedding.weight",
-    "img_model.visual.conv1": "vision_model.model.embeddings.patch_embedding",
-    "img_model.visual": "vision_model.model",
-    "ln_pre": "pre_layrnorm",
-    "ln_post": "post_layernorm",
-    "transformer.resblocks": "encoder.layers",
-    "ts_attn": "self_attn",
-    "ln_1": "layer_norm1",
-    "ln_2": "layer_norm2",
-    "c_fc": "fc1",
-    "c_proj": "fc2",
-}
-
-
-KEYS_TO_IGNORE = [
-    # this buffer in the original code is only used to send weights to the desired device
-    "gpt_model.decoder.embed_positions._float_tensor",
-    # this weight is never used in the forward in the original KOSMOS-2)
-    "gpt_model.decoder.self_attn_sope.scale",
-]
-
-
-def rename_key(key):
-    for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-        if key_to_modify in key:
-            key = key.replace(key_to_modify, new_key)
-
-    return key
-
-
-def convert_kosmos2_checkpoint_to_pytorch(checkpoint_path, pytorch_dump_folder_path):
-    state = load_checkpoint_to_cpu(checkpoint_path)
-    state_dict = state["model"]
-    state_dict_keys = list(state_dict.keys())
-
-    config = Kosmos2Config()
-    # This is necessary to match the results given by the original demo
-    config.text_config.no_repeat_ngram_size = 3
-    model = Kosmos2ForConditionalGeneration(config)
-
-    # convert (by renaming keys)
-    converted_state_dict = {}
-    for key in state_dict_keys:
-        if key in KEYS_TO_IGNORE:
-            continue
-        renamed_key = rename_key(key)
-        converted_state_dict[renamed_key] = state_dict[key]
-
-    # check weight loading
-    model.load_state_dict(converted_state_dict, strict=True)
-    # save the result
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--kosmos2_checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_kosmos2_checkpoint_to_pytorch(args.kosmos2_checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/levit/convert_levit_timm_to_pytorch.py b/src/transformers/models/levit/convert_levit_timm_to_pytorch.py
deleted file mode 100644
index 0d5731bf7bef..000000000000
--- a/src/transformers/models/levit/convert_levit_timm_to_pytorch.py
+++ /dev/null
@@ -1,181 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert LeViT checkpoints from timm."""
-
-import argparse
-import json
-from collections import OrderedDict
-from functools import partial
-from pathlib import Path
-from typing import Optional
-
-import timm
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import LevitConfig, LevitForImageClassificationWithTeacher, LevitImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger()
-
-
-def convert_weight_and_push(
-    hidden_sizes: int, name: str, config: LevitConfig, save_directory: Path, push_to_hub: bool = True
-):
-    print(f"Converting {name}...")
-
-    with torch.no_grad():
-        if hidden_sizes == 128:
-            if name[-1] == "S":
-                from_model = timm.create_model("levit_128s", pretrained=True)
-            else:
-                from_model = timm.create_model("levit_128", pretrained=True)
-        if hidden_sizes == 192:
-            from_model = timm.create_model("levit_192", pretrained=True)
-        if hidden_sizes == 256:
-            from_model = timm.create_model("levit_256", pretrained=True)
-        if hidden_sizes == 384:
-            from_model = timm.create_model("levit_384", pretrained=True)
-
-        from_model.eval()
-        our_model = LevitForImageClassificationWithTeacher(config).eval()
-        huggingface_weights = OrderedDict()
-
-        weights = from_model.state_dict()
-        og_keys = list(from_model.state_dict().keys())
-        new_keys = list(our_model.state_dict().keys())
-        print(len(og_keys), len(new_keys))
-        for i in range(len(og_keys)):
-            huggingface_weights[new_keys[i]] = weights[og_keys[i]]
-        our_model.load_state_dict(huggingface_weights)
-
-        x = torch.randn((2, 3, 224, 224))
-        out1 = from_model(x)
-        out2 = our_model(x).logits
-
-    assert torch.allclose(out1, out2), "The model logits don't match the original one."
-
-    checkpoint_name = name
-    print(checkpoint_name)
-
-    if push_to_hub:
-        our_model.save_pretrained(save_directory / checkpoint_name)
-        image_processor = LevitImageProcessor()
-        image_processor.save_pretrained(save_directory / checkpoint_name)
-
-        print(f"Pushed {checkpoint_name}")
-
-
-def convert_weights_and_push(save_directory: Path, model_name: Optional[str] = None, push_to_hub: bool = True):
-    filename = "imagenet-1k-id2label.json"
-    num_labels = 1000
-    expected_shape = (1, num_labels)
-
-    repo_id = "huggingface/label-files"
-    num_labels = num_labels
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    id2label = id2label
-    label2id = {v: k for k, v in id2label.items()}
-
-    ImageNetPreTrainedConfig = partial(LevitConfig, num_labels=num_labels, id2label=id2label, label2id=label2id)
-
-    names_to_hidden_sizes = {
-        "levit-128S": 128,
-        "levit-128": 128,
-        "levit-192": 192,
-        "levit-256": 256,
-        "levit-384": 384,
-    }
-
-    names_to_config = {
-        "levit-128S": ImageNetPreTrainedConfig(
-            hidden_sizes=[128, 256, 384],
-            num_attention_heads=[4, 6, 8],
-            depths=[2, 3, 4],
-            key_dim=[16, 16, 16],
-            drop_path_rate=0,
-        ),
-        "levit-128": ImageNetPreTrainedConfig(
-            hidden_sizes=[128, 256, 384],
-            num_attention_heads=[4, 8, 12],
-            depths=[4, 4, 4],
-            key_dim=[16, 16, 16],
-            drop_path_rate=0,
-        ),
-        "levit-192": ImageNetPreTrainedConfig(
-            hidden_sizes=[192, 288, 384],
-            num_attention_heads=[3, 5, 6],
-            depths=[4, 4, 4],
-            key_dim=[32, 32, 32],
-            drop_path_rate=0,
-        ),
-        "levit-256": ImageNetPreTrainedConfig(
-            hidden_sizes=[256, 384, 512],
-            num_attention_heads=[4, 6, 8],
-            depths=[4, 4, 4],
-            key_dim=[32, 32, 32],
-            drop_path_rate=0,
-        ),
-        "levit-384": ImageNetPreTrainedConfig(
-            hidden_sizes=[384, 512, 768],
-            num_attention_heads=[6, 9, 12],
-            depths=[4, 4, 4],
-            key_dim=[32, 32, 32],
-            drop_path_rate=0.1,
-        ),
-    }
-
-    if model_name:
-        convert_weight_and_push(
-            names_to_hidden_sizes[model_name], model_name, names_to_config[model_name], save_directory, push_to_hub
-        )
-    else:
-        for model_name, config in names_to_config.items():
-            convert_weight_and_push(names_to_hidden_sizes[model_name], model_name, config, save_directory, push_to_hub)
-    return config, expected_shape
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default=None,
-        type=str,
-        help="The name of the model you wish to convert, it must be one of the supported Levit* architecture,",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="levit-dump-folder/",
-        type=Path,
-        required=False,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--push_to_hub", action="store_true", help="Push model and image processor to the hub")
-    parser.add_argument(
-        "--no-push_to_hub",
-        dest="push_to_hub",
-        action="store_false",
-        help="Do not push model and image processor to the hub",
-    )
-
-    args = parser.parse_args()
-    pytorch_dump_folder_path: Path = args.pytorch_dump_folder_path
-    pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
-    convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
diff --git a/src/transformers/models/llama/convert_llama_weights_to_hf.py b/src/transformers/models/llama/convert_llama_weights_to_hf.py
deleted file mode 100644
index eb2862eb203d..000000000000
--- a/src/transformers/models/llama/convert_llama_weights_to_hf.py
+++ /dev/null
@@ -1,601 +0,0 @@
-# Copyright 2022 EleutherAI and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import gc
-import json
-import os
-import tempfile
-import warnings
-from typing import List
-
-import torch
-from tokenizers import AddedToken, processors
-
-from transformers import GenerationConfig, LlamaConfig, LlamaForCausalLM, LlamaTokenizer, PreTrainedTokenizerFast
-from transformers.convert_slow_tokenizer import TikTokenConverter
-
-
-try:
-    from transformers import LlamaTokenizerFast
-except ImportError as e:
-    warnings.warn(e)
-    warnings.warn(
-        "The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion"
-    )
-    LlamaTokenizerFast = None
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/llama/convert_llama_weights_to_hf.py \
-    --input_dir /path/to/downloaded/llama/weights --model_size 1B --llama_version 3.2 --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import LlamaForCausalLM, LlamaTokenizer
-
-model = LlamaForCausalLM.from_pretrained("/output/path")
-tokenizer = LlamaTokenizer.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-
-If you want your tokenizer to add a bos automatically you should update the tokenizer._tokenizers.post_processor:
-
-```py
-from tokenizers import processors
-bos = "<|begin_of_text|>"
-tokenizer._tokenizers.post_processor = processors.Sequence(
-    [
-        processors.ByteLevel(trim_offsets=False),
-        processors.TemplateProcessing(
-            single=f"{bos}:0 $A:0",
-            pair=f"{bos}:0 $A:0 {bos}:1 $B:1",
-            special_tokens=[
-                (bos, tokenizer.encode(bos)),
-            ],
-        ),
-    ]
-)
-```
-"""
-
-NUM_SHARDS = {
-    "1B": 1,
-    "3B": 1,
-    "7B": 1,
-    "8B": 1,
-    "8Bf": 1,
-    "7Bf": 1,
-    "13B": 2,
-    "13Bf": 2,
-    "34B": 4,
-    "30B": 4,
-    "65B": 8,
-    "70B": 8,
-    "70Bf": 8,
-    "405B": 8,
-    "405B-MP16": 16,
-}
-
-CONTEXT_LENGTH_FOR_VERSION = {"Guard-3": 131072, "3.2": 131072, "3.1": 131072, "3": 8192, "2": 4096, "1": 2048}
-
-BOS_ADDED_TOKEN = AddedToken(
-    "<|begin_of_text|>", single_word=False, lstrip=False, rstrip=False, normalized=False, special=True
-)
-EOS_ADDED_TOKEN = AddedToken(
-    "<|end_of_text|>", single_word=False, lstrip=False, rstrip=False, normalized=False, special=True
-)
-EOT_ADDED_TOKEN = AddedToken(
-    "<|eot_id|>", single_word=False, lstrip=False, rstrip=False, normalized=False, special=True
-)
-
-DEFAULT_LLAMA_SPECIAL_TOKENS = {
-    "3": [
-        "<|begin_of_text|>",
-        "<|end_of_text|>",
-        "<|reserved_special_token_0|>",
-        "<|reserved_special_token_1|>",
-        "<|reserved_special_token_2|>",
-        "<|reserved_special_token_3|>",
-        "<|start_header_id|>",
-        "<|end_header_id|>",
-        "<|reserved_special_token_4|>",
-        "<|eot_id|>",  # end of turn
-    ]
-    + [f"<|reserved_special_token_{i}|>" for i in range(5, 256 - 5)],
-    "3.1": [
-        "<|begin_of_text|>",
-        "<|end_of_text|>",
-        "<|reserved_special_token_0|>",
-        "<|reserved_special_token_1|>",
-        "<|finetune_right_pad_id|>",
-        "<|reserved_special_token_2|>",
-        "<|start_header_id|>",
-        "<|end_header_id|>",
-        "<|eom_id|>",  # end of message
-        "<|eot_id|>",  # end of turn
-        "<|python_tag|>",
-    ]
-    + [f"<|reserved_special_token_{i}|>" for i in range(3, 256 - 8)],
-    "3.2": [
-        "<|begin_of_text|>",
-        "<|end_of_text|>",
-        "<|reserved_special_token_0|>",
-        "<|reserved_special_token_1|>",
-        "<|finetune_right_pad_id|>",
-        "<|reserved_special_token_2|>",
-        "<|start_header_id|>",
-        "<|end_header_id|>",
-        "<|eom_id|>",  # end of message
-        "<|eot_id|>",  # end of turn
-        "<|python_tag|>",
-    ]
-    + [f"<|reserved_special_token_{i}|>" for i in range(3, 256 - 8)],
-    "Guard-3": [
-        "<|begin_of_text|>",
-        "<|end_of_text|>",
-        "<|reserved_special_token_0|>",
-        "<|reserved_special_token_1|>",
-        "<|finetune_right_pad_id|>",
-        "<|reserved_special_token_2|>",
-        "<|start_header_id|>",
-        "<|end_header_id|>",
-        "<|eom_id|>",  # end of message
-        "<|eot_id|>",  # end of turn
-        "<|python_tag|>",
-    ]
-    + [f"<|reserved_special_token_{i}|>" for i in range(3, 256 - 8)],
-}
-
-
-def is_llama_3(version):
-    return version in ["3", "3.1", "3.2", "Guard-3"]
-
-
-def compute_intermediate_size(n, ffn_dim_multiplier=1, multiple_of=256):
-    return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3)) + multiple_of - 1) // multiple_of)
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def write_json(text, path):
-    with open(path, "w") as f:
-        json.dump(text, f)
-
-
-def write_model(
-    model_path,
-    input_base_path,
-    model_size=None,
-    safe_serialization=True,
-    llama_version="1",
-    vocab_size=None,
-    num_shards=None,
-    instruct=False,
-    push_to_hub=False,
-):
-    print("Converting the model.")
-    params = read_json(os.path.join(input_base_path, "params.json"))
-    num_shards = NUM_SHARDS[model_size] if num_shards is None else num_shards
-    params = params.get("model", params)
-    n_layers = params["n_layers"]
-    n_heads = params["n_heads"]
-    n_heads_per_shard = n_heads // num_shards
-    dim = params["dim"]
-    dims_per_head = dim // n_heads
-    base = params.get("rope_theta", 10000.0)
-    inv_freq = 1.0 / (base ** (torch.arange(0, dims_per_head, 2).float() / dims_per_head))
-    if base > 10000.0 and not is_llama_3(llama_version):
-        max_position_embeddings = 16384
-    else:
-        max_position_embeddings = CONTEXT_LENGTH_FOR_VERSION[llama_version]
-
-    if params.get("n_kv_heads", None) is not None:
-        num_key_value_heads = params["n_kv_heads"]  # for GQA / MQA
-        num_key_value_heads_per_shard = num_key_value_heads // num_shards
-        key_value_dim = dims_per_head * num_key_value_heads
-    else:  # compatibility with other checkpoints
-        num_key_value_heads = n_heads
-        num_key_value_heads_per_shard = n_heads_per_shard
-        key_value_dim = dim
-
-    # permute for sliced rotary
-    def permute(w, n_heads, dim1=dim, dim2=dim):
-        return w.view(n_heads, dim1 // n_heads // 2, 2, dim2).transpose(1, 2).reshape(dim1, dim2)
-
-    with tempfile.TemporaryDirectory() as tmp_model_path:
-        print(f"Fetching all parameters from the checkpoint at {input_base_path}.")
-        # Load weights
-        if num_shards == 1:
-            # Not sharded
-            # (The sharded implementation would also work, but this is simpler.)
-            loaded = torch.load(os.path.join(input_base_path, "consolidated.00.pth"), map_location="cpu")
-        else:
-            # Sharded
-            checkpoint_list = sorted([file for file in os.listdir(input_base_path) if file.endswith(".pth")])
-            print("Loading in order:", checkpoint_list)
-            loaded = [torch.load(os.path.join(input_base_path, file), map_location="cpu") for file in checkpoint_list]
-        param_count = 0
-        index_dict = {"weight_map": {}}
-        for layer_i in range(n_layers):
-            filename = f"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
-            if num_shards == 1:
-                # Unsharded
-                state_dict = {
-                    f"model.layers.{layer_i}.self_attn.q_proj.weight": permute(
-                        loaded[f"layers.{layer_i}.attention.wq.weight"], n_heads=n_heads
-                    ),
-                    f"model.layers.{layer_i}.self_attn.k_proj.weight": permute(
-                        loaded[f"layers.{layer_i}.attention.wk.weight"],
-                        n_heads=num_key_value_heads,
-                        dim1=key_value_dim,
-                    ),
-                    f"model.layers.{layer_i}.self_attn.v_proj.weight": loaded[f"layers.{layer_i}.attention.wv.weight"],
-                    f"model.layers.{layer_i}.self_attn.o_proj.weight": loaded[f"layers.{layer_i}.attention.wo.weight"],
-                    f"model.layers.{layer_i}.mlp.gate_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w1.weight"],
-                    f"model.layers.{layer_i}.mlp.down_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w2.weight"],
-                    f"model.layers.{layer_i}.mlp.up_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w3.weight"],
-                    f"model.layers.{layer_i}.input_layernorm.weight": loaded[
-                        f"layers.{layer_i}.attention_norm.weight"
-                    ],
-                    f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[
-                        f"layers.{layer_i}.ffn_norm.weight"
-                    ],
-                }
-            else:
-                # Sharded
-                # Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
-                # the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
-                # redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.
-
-                state_dict = {
-                    f"model.layers.{layer_i}.input_layernorm.weight": loaded[0][
-                        f"layers.{layer_i}.attention_norm.weight"
-                    ].clone(),
-                    f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[0][
-                        f"layers.{layer_i}.ffn_norm.weight"
-                    ].clone(),
-                }
-                state_dict[f"model.layers.{layer_i}.self_attn.q_proj.weight"] = permute(
-                    torch.cat(
-                        [
-                            loaded[i][f"layers.{layer_i}.attention.wq.weight"].view(
-                                n_heads_per_shard, dims_per_head, dim
-                            )
-                            for i in range(len(loaded))
-                        ],
-                        dim=0,
-                    ).reshape(dim, dim),
-                    n_heads=n_heads,
-                )
-                state_dict[f"model.layers.{layer_i}.self_attn.k_proj.weight"] = permute(
-                    torch.cat(
-                        [
-                            loaded[i][f"layers.{layer_i}.attention.wk.weight"].view(
-                                num_key_value_heads_per_shard, dims_per_head, dim
-                            )
-                            for i in range(len(loaded))
-                        ],
-                        dim=0,
-                    ).reshape(key_value_dim, dim),
-                    num_key_value_heads,
-                    key_value_dim,
-                    dim,
-                )
-                state_dict[f"model.layers.{layer_i}.self_attn.v_proj.weight"] = torch.cat(
-                    [
-                        loaded[i][f"layers.{layer_i}.attention.wv.weight"].view(
-                            num_key_value_heads_per_shard, dims_per_head, dim
-                        )
-                        for i in range(len(loaded))
-                    ],
-                    dim=0,
-                ).reshape(key_value_dim, dim)
-
-                state_dict[f"model.layers.{layer_i}.self_attn.o_proj.weight"] = torch.cat(
-                    [loaded[i][f"layers.{layer_i}.attention.wo.weight"] for i in range(len(loaded))], dim=1
-                )
-                state_dict[f"model.layers.{layer_i}.mlp.gate_proj.weight"] = torch.cat(
-                    [loaded[i][f"layers.{layer_i}.feed_forward.w1.weight"] for i in range(len(loaded))], dim=0
-                )
-                state_dict[f"model.layers.{layer_i}.mlp.down_proj.weight"] = torch.cat(
-                    [loaded[i][f"layers.{layer_i}.feed_forward.w2.weight"] for i in range(len(loaded))], dim=1
-                )
-                state_dict[f"model.layers.{layer_i}.mlp.up_proj.weight"] = torch.cat(
-                    [loaded[i][f"layers.{layer_i}.feed_forward.w3.weight"] for i in range(len(loaded))], dim=0
-                )
-
-            state_dict[f"model.layers.{layer_i}.self_attn.rotary_emb.inv_freq"] = inv_freq
-            for k, v in state_dict.items():
-                index_dict["weight_map"][k] = filename
-                param_count += v.numel()
-            torch.save(state_dict, os.path.join(tmp_model_path, filename))
-
-        filename = f"pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"
-        if num_shards == 1:
-            # Unsharded
-            state_dict = {
-                "model.embed_tokens.weight": loaded["tok_embeddings.weight"],
-                "model.norm.weight": loaded["norm.weight"],
-                "lm_head.weight": loaded["output.weight"],
-            }
-        else:
-            concat_dim = 0 if is_llama_3(llama_version) else 1
-            state_dict = {
-                "model.norm.weight": loaded[0]["norm.weight"],
-                "model.embed_tokens.weight": torch.cat(
-                    [loaded[i]["tok_embeddings.weight"] for i in range(len(loaded))], dim=concat_dim
-                ),
-                "lm_head.weight": torch.cat([loaded[i]["output.weight"] for i in range(len(loaded))], dim=0),
-            }
-
-        for k, v in state_dict.items():
-            index_dict["weight_map"][k] = filename
-            param_count += v.numel()
-        torch.save(state_dict, os.path.join(tmp_model_path, filename))
-
-        # Write configs
-        index_dict["metadata"] = {"total_size": param_count * 2}
-        write_json(index_dict, os.path.join(tmp_model_path, "pytorch_model.bin.index.json"))
-        ffn_dim_multiplier = params["ffn_dim_multiplier"] if "ffn_dim_multiplier" in params else 1
-        multiple_of = params["multiple_of"] if "multiple_of" in params else 256
-
-        if is_llama_3(llama_version):
-            bos_token_id = 128000
-
-            if instruct:
-                eos_token_id = [128001, 128008, 128009]
-            else:
-                eos_token_id = 128001
-        else:
-            bos_token_id = 1
-            eos_token_id = 2
-
-        if llama_version in ["3.1", "3.2", "Guard-3"]:
-            rope_scaling = {
-                "factor": 32.0 if llama_version == "3.2" else 8.0,
-                "low_freq_factor": 1.0,
-                "high_freq_factor": 4.0,
-                "original_max_position_embeddings": 8192,
-                "rope_type": "llama3",
-            }
-        else:
-            rope_scaling = None
-
-        config = LlamaConfig(
-            hidden_size=dim,
-            intermediate_size=compute_intermediate_size(dim, ffn_dim_multiplier, multiple_of),
-            num_attention_heads=params["n_heads"],
-            num_hidden_layers=params["n_layers"],
-            rms_norm_eps=params["norm_eps"],
-            num_key_value_heads=num_key_value_heads,
-            vocab_size=vocab_size,
-            rope_theta=base,
-            rope_scaling=rope_scaling,
-            max_position_embeddings=max_position_embeddings,
-            bos_token_id=bos_token_id,
-            eos_token_id=eos_token_id,
-            tie_word_embeddings=True if llama_version in ["3.2"] else False,
-        )
-
-        config.save_pretrained(tmp_model_path)
-
-        generation_config = GenerationConfig(
-            do_sample=True,
-            temperature=0.6,
-            top_p=0.9,
-            bos_token_id=bos_token_id,
-            eos_token_id=eos_token_id,
-        )
-        generation_config.save_pretrained(tmp_model_path)
-
-        # Make space so we can load the model properly now.
-        del state_dict
-        del loaded
-        gc.collect()
-
-        print("Loading the checkpoint in a Llama model.")
-        model = LlamaForCausalLM.from_pretrained(tmp_model_path, torch_dtype=torch.bfloat16, low_cpu_mem_usage=True)
-
-        # Avoid saving this as part of the config.
-        del model.config._name_or_path
-        model.config.torch_dtype = torch.float16
-
-        print("Saving in the Transformers format.")
-        if push_to_hub:
-            print("Pushing to the hub.")
-            model.push_to_hub(model_path, safe_serialization=safe_serialization, private=True, use_temp_dir=True)
-        else:
-            print("Saving to disk.")
-            model.save_pretrained(model_path, safe_serialization=safe_serialization)
-
-
-class Llama3Converter(TikTokenConverter):
-    def __init__(self, vocab_file, special_tokens=None, instruct=False, llama_version="3.2", **kwargs):
-        super().__init__(vocab_file, additional_special_tokens=special_tokens, **kwargs)
-        tokenizer = self.converted()
-
-        # References for chat templates in instruct models
-        templates_for_version = {
-            "2": ("meta-llama/Llama-2-7b-chat-hf", "f5db02db724555f92da89c216ac04704f23d4590"),
-            "3": ("meta-llama/Meta-Llama-3-8B-Instruct", "5f0b02c75b57c5855da9ae460ce51323ea669d8a"),
-            "3.1": ("meta-llama/Llama-3.1-8B-Instruct", "0e9e39f249a16976918f6564b8830bc894c89659"),
-            "3.2": ("meta-llama/Llama-3.2-1B-Instruct", "e9f8effbab1cbdc515c11ee6e098e3d5a9f51e14"),
-            "Guard-3": ("meta-llama/Llama-Guard-3-1B", "acf7aafa60f0410f8f42b1fa35e077d705892029"),
-        }
-
-        # Add chat_template only if instruct is True.
-        # Prevents a null chat_template, which triggers
-        # a parsing warning in the Hub.
-        additional_kwargs = {}
-        if instruct or llama_version in ["Guard-3"]:
-            model_id, revision = templates_for_version.get(llama_version, (None, None))
-            if model_id is not None:
-                from transformers import AutoTokenizer
-
-                t = AutoTokenizer.from_pretrained(model_id, revision=revision)
-                additional_kwargs["chat_template"] = t.chat_template
-
-        self.converted_tokenizer = PreTrainedTokenizerFast(
-            tokenizer_object=tokenizer,
-            bos_token="<|begin_of_text|>",
-            eos_token="<|end_of_text|>" if not instruct else "<|eot_id|>",
-            model_input_names=["input_ids", "attention_mask"],
-            model_max_length=CONTEXT_LENGTH_FOR_VERSION[llama_version],
-            clean_up_tokenization_spaces=True,
-            **additional_kwargs,
-        )
-        self.update_post_processor(self.converted_tokenizer)
-        # finer special_tokens_map.json
-        self.converted_tokenizer._bos_token = BOS_ADDED_TOKEN
-        self.converted_tokenizer._eos_token = EOT_ADDED_TOKEN if instruct else EOS_ADDED_TOKEN
-
-    # We can't do this while building the tokenizer because we have no easy access to the bos token id
-    def update_post_processor(self, tokenizer):
-        tokenizer._tokenizer.post_processor = processors.Sequence(
-            [
-                processors.ByteLevel(trim_offsets=False),
-                processors.TemplateProcessing(
-                    single="<|begin_of_text|> $A",
-                    pair="<|begin_of_text|>:0 $A:0 <|begin_of_text|>:1 $B:1",
-                    special_tokens=[
-                        ("<|begin_of_text|>", tokenizer.convert_tokens_to_ids("<|begin_of_text|>")),
-                    ],
-                ),
-            ]
-        )
-
-
-def write_tokenizer(
-    tokenizer_path, input_tokenizer_path, llama_version="2", special_tokens=None, instruct=False, push_to_hub=False
-):
-    print("Converting the tokenizer.")
-    tokenizer_class = LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
-    if is_llama_3(llama_version):
-        tokenizer = Llama3Converter(
-            input_tokenizer_path,
-            special_tokens,
-            instruct,
-            llama_version,
-        ).converted_tokenizer
-    else:
-        try:
-            tokenizer = tokenizer_class(input_tokenizer_path)
-        except Exception:
-            raise ValueError(
-                "Failed to instantiate tokenizer. Please, make sure you have sentencepiece and protobuf installed."
-            )
-
-    if push_to_hub:
-        print(f"Pushing a {tokenizer_class.__name__} to the Hub repo - {tokenizer_path}.")
-        tokenizer.push_to_hub(tokenizer_path, private=True, use_temp_dir=True)
-    else:
-        print(f"Saving a {tokenizer_class.__name__} to {tokenizer_path}.")
-        tokenizer.save_pretrained(tokenizer_path)
-    return tokenizer
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        help="Location of Llama weights, which contains tokenizer.model and model folders",
-    )
-    parser.add_argument(
-        "--model_size",
-        default=None,
-        help="'f' Deprecated in favor of `num_shards`: models correspond to the finetuned versions, and are specific to the Llama2 official release. For more details on Llama2, checkout the original repo: https://huggingface.co/meta-llama",
-    )
-    parser.add_argument(
-        "--output_dir",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        help="Whether or not to push the model to the hub at `output_dir` instead of saving it locally.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--safe_serialization", action="store_true", default=True, help="Whether or not to save using `safetensors`."
-    )
-    # Different Llama versions used different default values for max_position_embeddings, hence the need to be able to specify which version is being used.
-    parser.add_argument(
-        "--llama_version",
-        choices=["1", "2", "3", "3.1", "3.2", "Guard-3"],
-        default="1",
-        type=str,
-        help="Version of the Llama model to convert. Currently supports Llama1 and Llama2. Controls the context size",
-    )
-    parser.add_argument(
-        "--num_shards",
-        default=None,
-        type=int,
-        help="The number of individual shards used for the model. Does not have to be the same as the number of consolidated_xx.pth",
-    )
-    parser.add_argument(
-        "--special_tokens",
-        default=None,
-        type=List[str],
-        help="The list of special tokens that should be added to the model.",
-    )
-    parser.add_argument(
-        "--instruct",
-        action="store_true",
-        default=False,
-        help="Whether the model is an instruct model or not. Will affect special tokens and chat template.",
-    )
-    args = parser.parse_args()
-    if args.model_size is None and args.num_shards is None:
-        raise ValueError("You have to set at least `num_shards` if you are not giving the `model_size`")
-    if args.special_tokens is None:
-        # no special tokens by default
-        args.special_tokens = DEFAULT_LLAMA_SPECIAL_TOKENS.get(str(args.llama_version), [])
-
-    spm_path = os.path.join(args.input_dir, "tokenizer.model")
-    vocab_size = len(
-        write_tokenizer(
-            args.output_dir,
-            spm_path,
-            llama_version=args.llama_version,
-            special_tokens=args.special_tokens,
-            instruct=args.instruct,
-            push_to_hub=args.push_to_hub,
-        )
-    )
-
-    if args.model_size != "tokenizer_only":
-        write_model(
-            model_path=args.output_dir,
-            input_base_path=args.input_dir,
-            model_size=args.model_size,
-            safe_serialization=args.safe_serialization,
-            llama_version=args.llama_version,
-            vocab_size=vocab_size,
-            num_shards=args.num_shards,
-            instruct=args.instruct,
-            push_to_hub=args.push_to_hub,
-        )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/llama4/convert_llama4_weights_to_hf.py b/src/transformers/models/llama4/convert_llama4_weights_to_hf.py
deleted file mode 100644
index d1cd6b19933a..000000000000
--- a/src/transformers/models/llama4/convert_llama4_weights_to_hf.py
+++ /dev/null
@@ -1,736 +0,0 @@
-import argparse
-import gc
-import io
-import json
-import os
-import re
-from typing import List, Optional
-
-import torch
-from tokenizers import AddedToken, processors
-from tqdm import tqdm
-
-from transformers import (
-    GenerationConfig,
-    Llama4Config,
-    Llama4ForConditionalGeneration,
-    Llama4ImageProcessorFast,
-    Llama4Processor,
-    Llama4TextConfig,
-    Llama4VisionConfig,
-    PreTrainedTokenizerFast,
-)
-from transformers.integrations.tiktoken import TikTokenConverter
-
-
-_OFFLINE_QUANT_COMPATIBLE = os.environ.get("OFFLINE_QUANT_COMPATIBLE", "0") == "1"
-
-torch.serialization.add_safe_globals([io.BytesIO])
-# fmt: off
-# `None` means we drop the key
-
-
-weight_postfix = ".weight" if _OFFLINE_QUANT_COMPATIBLE else ""
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    # CausalLM keys
-    r"output.weight":                                        r"language_model.lm_head.weight",
-    r"\nnorm.weight":                                        r"\nlanguage_model.model.norm.weight",
-    # Model keys
-    r"tok_embeddings.weight":                                r"language_model.model.embed_tokens.weight",
-    r"freq_cis":                                             None,
-    r"rope.freqs":                                           None,
-    r"layers.(\d+).attention_norm.weight":                   r"language_model.model.layers.\1.input_layernorm.weight",
-    r"layers.(\d+).attention.wqkv.layer_norm_weight":        r"language_model.model.layers.\1.input_layernorm.weight",
-    r"layers.(\d+).feed_forward.norm.weight":                r"language_model.model.layers.\1.post_attention_layernorm.weight",
-    r"layers.(\d+).attention.wo.weight":                     r"language_model.model.layers.\1.self_attn.o_proj.weight",
-    r"layers.(\d+).attention.wqkv.weight":                   r"language_model.model.layers.\1.self_attn.qkv_proj.weight",
-
-    # MoE keys: no simple MLPmodel.
-    r"layers.(\d+).feed_forward.experts.moe_w_in_eD_F":      r"language_model.model.layers.\1.feed_forward.experts.gate_proj" + weight_postfix,       # will be fused with up
-    r"layers.(\d+).feed_forward.experts.moe_w_out_eF_D":     r"language_model.model.layers.\1.feed_forward.experts.down_proj" + weight_postfix,       # expert win
-    r"layers.(\d+).feed_forward.experts.moe_w_swiglu_eD_F":  r"language_model.model.layers.\1.feed_forward.experts.up_proj" + weight_postfix,         # fused with up
-    r"layers.(\d+).feed_forward.router_DE":                  r"language_model.model.layers.\1.feed_forward.router.weight",           # used for top
-    r"layers.(\d+).feed_forward.w_in_shared_FD":             r"language_model.model.layers.\1.feed_forward.shared_expert.gate_proj", # might need to be fused for efficiency?
-    r"layers.(\d+).feed_forward.w_out_shared_DF":            r"language_model.model.layers.\1.feed_forward.shared_expert.down_proj", # might need to be fused for efficiency?
-    r"layers.(\d+).feed_forward.w_swiglu_FD":                r"language_model.model.layers.\1.feed_forward.shared_expert.up_proj",   # might need to be fused for efficiency?
-    r"layers.(\d+).feed_forward.global_gate_stats_3E":       None,
-    # Unused keys in load hooks (explicitly removed)
-    r'layers.(\d+).attention.wqkv._extra_state':             None,
-    r'layers.(\d+).attention.wo._extra_state':               None,
-    # Key apparently unused in base models
-    r'layers.(\d+).feed_forward.expert_activation_DE':       None,
-
-    # MLP layer variant
-    r"layers.(\d+).feed_forward.w1.weight":                  r"language_model.model.layers.\1.feed_forward.gate_proj.weight",               # might need to be fused for efficiency?
-    r"layers.(\d+).feed_forward.w3.weight":                  r"language_model.model.layers.\1.feed_forward.up_proj.weight",                 # might need to be fused for efficiency?
-    # r"layers.(\d+).feed_forward.mlp.fc1_weight":             r"language_model.model.layers.\1.feed_forward.gate_up_proj.weight",
-    r"layers.(\d+).feed_forward.mlp.fc2_weight":             r"language_model.model.layers.\1.feed_forward.down_proj.weight",
-    r"layers.(\d+).feed_forward.mlp.layer_norm.weight":      r"language_model.model.layers.\1.post_attention_layernorm.weight",
-
-    # Vision encoder mapping
-    r"vision_embeddings.vision_encoder.conv1._linear":                                            r"vision_model.patch_embedding.linear",
-    r'vision_embeddings.vision_adapter.mlp.c_fc':                                                 r"vision_model.vision_adapter.mlp.fc1",
-    r'vision_embeddings.vision_adapter.mlp.c_proj':                                               r"vision_model.vision_adapter.mlp.fc2",
-    r"vision_embeddings.vision_encoder.transformer.resblocks.(\d+).attn.wq.(weight|bias)":        r"vision_model.model.layers.\1.self_attn.q_proj.\2",
-    r"vision_embeddings.vision_encoder.transformer.resblocks.(\d+).attn.wk.(weight|bias)":        r"vision_model.model.layers.\1.self_attn.k_proj.\2",
-    r"vision_embeddings.vision_encoder.transformer.resblocks.(\d+).attn.wv.(weight|bias)":        r"vision_model.model.layers.\1.self_attn.v_proj.\2",
-    r"vision_embeddings.vision_encoder.transformer.resblocks.(\d+).attn.wo.(weight|bias)":        r"vision_model.model.layers.\1.self_attn.o_proj.\2",
-    r"vision_embeddings.vision_encoder.transformer.resblocks.(\d+).mlp.c_fc":                     r"vision_model.model.layers.\1.mlp.fc1",
-    r"vision_embeddings.vision_encoder.transformer.resblocks.(\d+).mlp.c_proj":                   r"vision_model.model.layers.\1.mlp.fc2",
-    r"vision_embeddings.vision_encoder.transformer.resblocks.(\d+).ln_1.(weight|bias)":           r"vision_model.model.layers.\1.input_layernorm.\2",
-    r"vision_embeddings.vision_encoder.transformer.resblocks.(\d+).ln_2.(weight|bias)":           r"vision_model.model.layers.\1.post_attention_layernorm.\2",
-    # r'vision_embeddings.vision_encoder.ln_(1|2).(weight|bias)':                                   r'vision_model.transformer.vision_encoder.layernorm_\1.\2',
-    r'vision_embeddings.vision_encoder.ln_post':                                                  r'vision_model.layernorm_post',
-    r'vision_embeddings.vision_encoder.ln_pre':                                                   r'vision_model.layernorm_pre',
-    r'vision_embeddings.vision_encoder.class_embedding':                                          r'vision_model.class_embedding',
-    r"vision_embeddings.vision_encoder.positional_embedding_vlm":                                 r"vision_model.positional_embedding_vlm",
-    r"vision_embeddings.vision_encoder.(?=\w)":                                                   r"vision_model.model.",
-    r"vision_projection.weight":                                                                  r"multi_modal_projector.linear_1.weight",
-}
-# fmt: on
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    """
-    This function should be applied only once, on the concatenated keys to efficiently rename using
-    the key mappings.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-        for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-            if replacement is None:
-                new_text = re.sub(pattern, "", new_text)  # an empty line
-                continue
-            new_text = re.sub(pattern, replacement, new_text)
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-    return output_dict
-
-
-def permute_for_rope(input_tensor, n_heads, dim1, dim2):
-    """
-    When you go from the complex ROPE formulation to sin and cos one, you need
-    to permute the query and key weights (to avoid doing it on the fly)
-    """
-    input_tensor = input_tensor.view(n_heads, dim1 // n_heads // 2, 2, dim2)
-    input_tensor = input_tensor.transpose(1, 2).reshape(dim1, dim2)
-    return input_tensor
-
-
-def is_param_same_across_shards(key):
-    """
-    Return `False` if the parameter is different across checkpoint shards
-    and needs to be concatenated.
-    """
-    patterns = [
-        r"language_model.layers.(\d+).(.*)layernorm.weight",
-        r"language_model.norm.weight",
-        r"router.weight",
-        r"feed_forward.global_gate_stats",
-        # not all vision weights are sharded, some are repeated
-        r"vision_model.class_embedding",
-        r"vision_model.positional_embedding_vlm",
-        r"vision_embeddings.vision_encoder.positional_embedding_vlm",
-        r"vision_model.model.layers.(\d+).self_attn.o_proj.bias",
-        r"vision_model.model.layers.(\d+).input_layernorm",
-        r"vision_model.model.layers.(\d+).post_attention_layernorm",
-        r"vision_model.layernorm_pre",
-        r"vision_model.layernorm_post",
-        r"vision_model.model.layers.(\d+).mlp.fc2.bias",
-        r"norm.weight",
-        ]  # fmt: skip
-    return any(re.search(pattern, key) for pattern in patterns)
-
-
-def get_concat_dim(key):
-    """
-    Return the dimension to concatenate the weights on.
-    """
-    concat_dim_1 = [
-        # language dim 1 sharded weights
-        "feed_forward.router.weight",
-        "self_attn.o_proj",
-        "experts.gate_proj",
-        "experts.up_proj",
-        "expert.down_proj",
-        # "feed_forward.up_proj",
-        # "feed_forward.gate_proj",
-        "feed_forward.down_proj",
-        "global_gate_stats",
-        # vision dim1 sharded stuff
-        "mlp.fc2.weight", # covers all rowparallels across vis
-        ]  # fmt: off
-    if any(re.search(pattern, key) for pattern in concat_dim_1):
-        return 1
-    return 0
-
-
-def compute_intermediate_size(hidden_dim, multiple_of=1024, ffn_dim_multiplier=1.3):
-    hidden_dim = 4 * int(2 * hidden_dim / 3)
-    hidden_dim = int(ffn_dim_multiplier * hidden_dim)
-    hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of)
-    return hidden_dim
-
-
-# Ignore extra info - h/t Aritra
-def safe_load(filename):
-    # Can use weights_only because io.BytesIO was registered, but we still need to skip those objects
-    shard = torch.load(filename, weights_only=True, map_location="cpu", mmap=True)
-    shard = {k: v for k, v in shard.items() if not isinstance(v, io.BytesIO)}
-    return shard
-
-
-# Unpack mlp projections - possibly to be removed when they are fused
-def preprocess_keys(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if "mlp.fc1_weight" in key:
-            prefix = key.split("mlp.fc1_weight")[0]
-            w1, w3 = value.chunk(2, dim=0)
-            new_state_dict[prefix + "w1.weight"] = w1
-            new_state_dict[prefix + "w3.weight"] = w3
-        else:
-            new_state_dict[key] = value
-    return new_state_dict
-
-
-def max_context_length(model_path, instruct=False):
-    """256K for base, 1M for 128E instruct, 10M for 16E instruct."""
-    if not instruct:
-        return 256 * 1024
-
-    with open(os.path.join(model_path, "params.json"), "r") as f:
-        params = json.load(f)
-    params = params.get("model", params)
-    num_experts = params["moe_args"]["num_experts"]
-    return 10485760 if num_experts == 16 else 1048576
-
-
-def write_model(
-    model_path,
-    input_base_path,
-    num_shards,
-    convert_checkpoints,
-    safe_serialization=True,
-    instruct=False,
-):
-    os.makedirs(model_path, exist_ok=True)
-
-    with open(os.path.join(input_base_path, "params.json"), "r") as f:
-        params = json.load(f)
-
-    params = params.get("model", params)
-    torch_dtype = "bfloat16"
-
-    # ------------------------------------------------------------
-    # Text model params and config
-    # ------------------------------------------------------------
-
-    # params from config
-    vocab_size = 202048  # params["vocab_size"] # seems like the lm head is 25256 so padded instead of 202048
-    num_layers = params["n_layers"]
-    dim = params["dim"]
-    num_heads = params["n_heads"]
-    rms_norm_eps = params["norm_eps"]
-    rope_theta = params["rope_theta"]
-    no_rope_layer_interval = params["nope_layer_interval"]
-    attention_chunk_size = params["attention_chunk_size"]
-
-    config_kwargs = {}
-    if params["use_scaled_rope"]:
-        # some constans from original code
-        rope_scaling = {
-            "rope_type": "llama3",
-            "factor": 8.0,
-            "low_freq_factor": 1.0,
-            "high_freq_factor": 4.0,
-            "original_max_position_embeddings": 8192,
-        }
-        config_kwargs.update({"rope_scaling": rope_scaling})
-
-    # compute additional params for weight conversion
-    num_heads_per_shard = num_heads // num_shards
-    dim_per_head = dim // num_heads
-    # intermediate_size = compute_intermediate_size(dim, multiple_of=params["multiple_of"])
-
-    num_key_value_heads = params["n_kv_heads"]  # for GQA / MQA
-
-    num_experts = params["moe_args"]["num_experts"]
-    interleave_moe_layer_step = params["moe_args"].get("interleave_moe_layer_step", 1)
-
-    no_rope_layer_interval = params["nope_layer_interval"]
-
-    bos_token_id = 200000
-    eos_token_id = [200001, 200007, 200008] if instruct else 200001
-    pad_token_id = 200018
-
-    text_config = Llama4TextConfig(
-        num_attention_heads=num_heads,
-        vocab_size=vocab_size,
-        hidden_size=dim,
-        rms_norm_eps=rms_norm_eps,
-        rope_theta=rope_theta,
-        num_hidden_layers=num_layers,
-        intermediate_size=8192,
-        intermediate_size_mlp=16384,
-        max_position_embeddings=max_context_length(input_base_path, instruct),
-        num_local_experts=num_experts,
-        interleave_moe_layer_step=interleave_moe_layer_step,
-        use_qk_norm=params["use_qk_norm"],
-        no_rope_layer_interval=no_rope_layer_interval,
-        attention_chunk_size=attention_chunk_size,
-        bos_token_id=bos_token_id,
-        eos_token_id=eos_token_id,
-        pad_token_id=pad_token_id,
-        tie_word_embeddings=False,  # Constant set to False
-        torch_dtype=torch_dtype,
-        for_llm_compressor=_OFFLINE_QUANT_COMPATIBLE,
-        no_rope_layers=no_rope_layer_interval,
-        **config_kwargs,
-    )
-    # default vision config frmo params
-
-    vision_params = params["vision_args"]
-    vision_dim = vision_params["dim"]
-    vision_num_layers = vision_params["n_layers"]
-    image_size = vision_params["image_size"]["height"]  # siglip config is outdated
-    vision_num_heads = vision_params["n_heads"]
-
-    vision_output_dim = vision_params["output_dim"]
-
-    vision_config = Llama4VisionConfig(
-        hidden_act="gelu",
-        num_hidden_layers=vision_num_layers,
-        image_size=image_size,
-        num_attention_heads=vision_num_heads,
-        hidden_size=vision_dim,
-        vision_output_dim=vision_output_dim,
-    )
-
-    config = Llama4Config(text_config=text_config, vision_config=vision_config)
-    config.save_pretrained(model_path)
-
-    print("Model config saved successfully...")
-
-    # ------------------------------------------------------------
-    # Convert weights
-    # ------------------------------------------------------------
-
-    if convert_checkpoints:
-        print(f"Fetching all parameters from the checkpoint at {input_base_path}...")
-        if num_shards == 1:
-            if os.path.exists(os.path.join(input_base_path, "consolidated.00.pth")):
-                path = os.path.join(input_base_path, "consolidated.00.pth")
-            else:
-                path = os.path.join(input_base_path, "consolidated.pth")
-            loaded = [safe_load(path)]
-        else:
-            loaded = [
-                safe_load(os.path.join(input_base_path, f"consolidated.{i:02d}.pth"))
-                for i in tqdm(range(num_shards), desc="Loading shards", unit="shard")
-            ]
-        loaded = [preprocess_keys(d) for d in loaded]
-
-        all_keys_raw = list(loaded[0].keys())
-        repeated_keys = []
-        sharded_keys = []
-        for _key in all_keys_raw:
-            try:
-                if (loaded[0][_key] == loaded[1][_key]).all():
-                    repeated_keys.append(_key)
-                else:
-                    sharded_keys.append(_key)
-            except Exception as e:
-                print(f"Encountered exception {e} for {_key}")
-        print("Initializing an empty model")
-        with torch.device("meta"):
-            model = Llama4ForConditionalGeneration(config)
-
-        print("Converting model...")
-        all_keys = list(loaded[0].keys())
-        new_keys = convert_old_keys_to_new_keys(all_keys)
-        state_dict = {}
-        replicated_params = []  # To keep track of replicated weights.
-        for key in tqdm(all_keys, desc="Renaming and processing all keys", unit="key"):
-            new_key = new_keys[key]
-            print(key, new_key)
-            if not is_param_same_across_shards(new_key):
-                current_parameter = [chunk.pop(key) for chunk in loaded if not isinstance(chunk[key], io.BytesIO)]
-            else:
-                print(f"{key} (now {new_key}) is the same across all shards.")
-                replicated_params.append((key, new_key))
-                current_parameter = [loaded[0].pop(key)] if not isinstance(loaded[0][key], io.BytesIO) else []
-
-            if "running_gate_stats_3E" in key:
-                new_keys.pop(new_key)
-                continue
-
-            concat_dim = get_concat_dim(new_key)
-
-            # Post-process the current_parameter.
-            if "qkv_proj" in new_key:
-                queries = []
-                keys = []
-                values = []
-                for param in current_parameter:
-                    query, key_, value = param.split(
-                        [
-                            num_heads * dim_per_head // num_shards,
-                            num_key_value_heads * dim_per_head // num_shards,
-                            num_key_value_heads * dim_per_head // num_shards,
-                        ]
-                    )
-                    queries.append(query.reshape(num_heads_per_shard, -1, dim))
-                    keys.append(key_.reshape(num_key_value_heads // num_shards, -1, dim))
-                    values.append(value.reshape(num_key_value_heads // num_shards, -1, dim))
-
-                queries = torch.cat(queries, dim=0).reshape(dim, dim)
-                keys = torch.cat(keys, dim=0).reshape(num_key_value_heads * dim_per_head, dim)
-                values = torch.cat(values, dim=0).reshape(num_key_value_heads * dim_per_head, dim)
-                # queries = permute_for_rope(queries, num_heads, dim, dim)
-                # keys = permute_for_rope(keys, num_key_value_heads, num_key_value_heads*dim_per_head, dim)
-
-                q = new_key.replace("qkv", "q")
-                tqdm.write(f"Processing: {key.ljust(50)}  ->\t {q}, {queries.shape}")
-                state_dict[q] = queries
-
-                k = new_key.replace("qkv", "k")
-                tqdm.write(f"Processing: {key.ljust(50)}  ->\t {k}, {keys.shape}")
-                state_dict[k] = keys
-
-                v = new_key.replace("qkv", "v")
-                tqdm.write(f"Processing: {key.ljust(50)}  ->\t {v}, {values.shape}")
-                state_dict[v] = values
-            elif _OFFLINE_QUANT_COMPATIBLE and "feed_forward.experts." in new_key:
-                # for experts, we need to split expert for offline quantiation purpose and don't need to fuse
-                expert_lists = []
-                for k in current_parameter:
-                    expert_lists.append(
-                        list(k.reshape(num_experts, -1, k.shape[-1]).unbind(0))
-                    )  # [#expert * IN, OUT] -> #experts * [IN, OUT]
-                for i in range(num_experts):
-                    expert = torch.cat([expert_list[i] for expert_list in expert_lists], dim=concat_dim)
-                    expert_key = new_key.replace("experts.", f"experts.{i}.")
-                    state_dict[expert_key] = expert.transpose(0, 1).contiguous()  # [OUT, IN]
-                    tqdm.write(f"Processing: {key.ljust(50)}  ->\t {expert_key}, {state_dict[expert_key].shape}")
-            elif re.search(r"(gate|up)_proj", new_key):
-                path = new_key.split(".")
-                gate_key = re.sub(r"(gate|up)_proj", lambda m: "gate_proj", new_key)
-                up_key = re.sub(r"(gate|up)_proj", lambda m: "up_proj", new_key)
-                if gate_key == new_key:
-                    state_dict[new_key] = torch.cat(current_parameter, dim=concat_dim)
-                elif new_key == up_key:
-                    if "experts" not in new_key:
-                        state_dict[new_key] = torch.cat(current_parameter, dim=concat_dim)
-                    else:
-                        gate_proj = state_dict.pop(gate_key)
-                        gate_proj = [
-                            gate_proj.reshape(num_experts, -1, 8, 1024)[:, :, k, :].reshape(num_experts, -1, 1024)
-                            for k in range(8)
-                        ]
-                        gate_proj = torch.cat(gate_proj, dim=-1)
-
-                        up_proj = [
-                            k.reshape(num_experts, -1, 8, 1024).reshape(num_experts, -1, 1024)
-                            for k in current_parameter
-                        ]
-                        up_proj = torch.cat(up_proj, dim=-1)
-
-                        gate_up_proj = torch.cat((gate_proj, up_proj), dim=-1)
-                        new_key = new_key.replace("up_proj", "gate_up_proj")
-                        state_dict[new_key] = gate_up_proj.contiguous()
-
-                    tqdm.write(f"Processing: {key.ljust(50)}  ->\t {new_key}, {state_dict[new_key].shape}")
-            elif "down_proj" in new_key:
-                current_parameter = torch.cat(current_parameter, dim=concat_dim)
-                if "experts" in new_key:
-                    p = []
-                    for i in range(8):
-                        p += [current_parameter.reshape(8, -1, 5120)[i, :, :].view(num_experts, -1, 5120)]
-                    current_parameter = torch.cat(p, dim=1)
-                state_dict[new_key] = current_parameter.contiguous()
-                tqdm.write(f"Processing: {key.ljust(50)}  ->\t {new_key}, {state_dict[new_key].shape}")
-            elif "router" in new_key:
-                current_parameter = torch.cat(current_parameter, dim=concat_dim)
-                state_dict[new_key] = current_parameter.transpose(0, 1)
-            elif "lm_head" in new_key:
-                current_parameter = torch.cat(current_parameter, dim=concat_dim).clone()
-                # TODO we need to do better than mean, works for now
-                # if (vocab_size - current_parameter.shape[0]) > 0:
-                #     mean_embedding = torch.mean(current_parameter, dim=0)[:, None].repeat(vocab_size-current_parameter.shape[0],1)
-                #     print(mean_embedding.shape)
-                #     current_parameter = torch.cat((current_parameter, mean_embedding), dim=0)
-                state_dict[new_key] = current_parameter
-                tqdm.write(
-                    f"Processing: {key.ljust(50)}  ->\t {new_key}, {state_dict[new_key].shape}, concat dim = {concat_dim}"
-                )
-            elif new_key == "vision_model.patch_embedding.linear.weight":
-                current_parameter = torch.cat(current_parameter, dim=concat_dim).clone()
-                # We don't reshape the patch embedding as we're using unfolded convolution as well
-                state_dict[new_key] = current_parameter  # .reshape(-1, 3, vision_patch_size, vision_patch_size)
-            # generic concat for weights/select one for biases
-            elif isinstance(current_parameter, list) and len(current_parameter) > 0:
-                if not is_param_same_across_shards(new_key):
-                    current_parameter = torch.cat(current_parameter, dim=concat_dim)
-                    state_dict[new_key] = current_parameter
-                    tqdm.write(
-                        f"Processing: {key.ljust(50)}  ->\t {new_key}, {state_dict[new_key].shape}, concat dim = {concat_dim}"
-                    )
-                elif is_param_same_across_shards(new_key):
-                    state_dict[new_key] = current_parameter[0]
-                    tqdm.write(
-                        f"Processing: {key.ljust(50)}  ->\t {new_key}, {state_dict[new_key].shape}, concat dim = {concat_dim}"
-                    )
-
-            elif new_key == "":
-                # skip empty keys
-                continue
-            else:
-                # just load the parameter
-                state_dict[new_key] = current_parameter
-                tqdm.write(
-                    f"Processing: {key.ljust(50)}  ->\t {new_key}, {state_dict[new_key].shape}, concat dim = {concat_dim}"
-                )
-        del loaded
-        gc.collect()
-
-        print("Loading the checkpoint in a Llama4 model.")
-        state_dict.pop("")
-        model.load_state_dict(state_dict, strict=True, assign=True)
-        print("Model reloaded successfully.")
-        print("Saving the model.")
-        model.save_pretrained(model_path, safe_serialization=safe_serialization)
-        del state_dict, model
-
-        # Safety check: reload the converted model
-        gc.collect()
-    print("Reloading the model to check if it's saved correctly.")
-    with torch.no_grad():
-        # TODO test if we can do `tp_plan="auto"``
-        model = Llama4ForConditionalGeneration.from_pretrained(
-            model_path, torch_dtype=torch.bfloat16, device_map="auto", attn_implementation="eager"
-        )
-
-        model.generation_config.top_p = 0.9
-        model.generation_config.temperature = 0.6
-        print("Model reloaded successfully.")
-
-        from transformers import AutoTokenizer
-
-        tokenizer = AutoTokenizer.from_pretrained(model_path)
-        inputs = tokenizer(["Roses are red,"], return_tensors="pt").to(model.device)
-        out = model.generate(**inputs, max_new_tokens=4)
-        print(tokenizer.batch_decode(out))
-    # generation config
-    if instruct:
-        print("Saving generation config...")
-        generation_config = GenerationConfig(
-            do_sample=True,
-            temperature=0.6,
-            top_p=0.9,
-            bos_token_id=bos_token_id,
-            eos_token_id=eos_token_id,
-            pad_token_id=pad_token_id,
-        )
-        generation_config.save_pretrained(model_path)
-
-
-BOS_ADDED_TOKEN = AddedToken(
-    "<|begin_of_text|>", single_word=False, lstrip=False, rstrip=False, normalized=False, special=True
-)
-EOS_ADDED_TOKEN = AddedToken(
-    "<|end_of_text|>", single_word=False, lstrip=False, rstrip=False, normalized=False, special=True
-)
-EOT_ADDED_TOKEN = AddedToken("<|eot|>", single_word=False, lstrip=False, rstrip=False, normalized=False, special=True)
-
-
-def get_reserved_special_tokens(name, count, start_index=0):
-    return [f"<|{name}_reserved_special_token_{i}|>" for i in range(start_index, start_index + count)]
-
-
-# 200005, ..., 200079
-LLAMA4_TEXT_POST_TRAIN_SPECIAL_TOKENS = [
-    "<|header_start|>",
-    "<|header_end|>",
-    "<|eom|>",
-    "<|eot|>",
-    "<|step|>",
-    "<|text_post_train_reserved_special_token_0|>",
-    "<|text_post_train_reserved_special_token_1|>",
-    "<|text_post_train_reserved_special_token_2|>",
-    "<|text_post_train_reserved_special_token_3|>",
-    "<|text_post_train_reserved_special_token_4|>",
-    "<|text_post_train_reserved_special_token_5|>",
-    "<|python_start|>",
-    "<|python_end|>",
-    "<|finetune_right_pad|>",
-] + get_reserved_special_tokens(
-    "text_post_train", 61, 6
-)  # <|text_post_train_reserved_special_token_6|>, ..., <|text_post_train_reserved_special_token_66|>
-
-# 200080, ..., 201133
-LLAMA4_VISION_SPECIAL_TOKENS = [
-    "<|image_start|>",
-    "<|image_end|>",
-    "<|vision_reserved_special_token_0|>",
-    "<|vision_reserved_special_token_1|>",
-    "<|tile_x_separator|>",
-    "<|tile_y_separator|>",
-    "<|vision_reserved_special_token_2|>",
-    "<|vision_reserved_special_token_3|>",
-    "<|vision_reserved_special_token_4|>",
-    "<|vision_reserved_special_token_5|>",
-    "<|image|>",
-    "<|vision_reserved_special_token_6|>",
-    "<|patch|>",
-] + get_reserved_special_tokens(
-    "vision", 1041, 7
-)  # <|vision_reserved_special_token_7|>, ..., <|vision_reserved_special_token_1047|>
-
-LLAMA4_SPECIAL_TOKENS = LLAMA4_TEXT_POST_TRAIN_SPECIAL_TOKENS + LLAMA4_VISION_SPECIAL_TOKENS
-
-BASIC_SPECIAL_TOKENS = [
-    "<|begin_of_text|>",
-    "<|end_of_text|>",
-    "<|fim_prefix|>",
-    "<|fim_middle|>",
-    "<|fim_suffix|>",
-]
-
-
-class Llama4Converter(TikTokenConverter):
-    def __init__(
-        self,
-        vocab_file,
-        special_tokens: List[str],
-        pattern: str,
-        model_max_length: int = 0,
-        chat_template: Optional[str] = None,
-        **kwargs,
-    ):
-        super().__init__(vocab_file, pattern=pattern)
-        self.additional_special_tokens = special_tokens
-        tokenizer = self.converted()
-        if chat_template is not None:
-            kwargs["chat_template"] = chat_template
-
-        self.converted_tokenizer = PreTrainedTokenizerFast(
-            tokenizer_object=tokenizer,
-            model_input_names=["input_ids", "attention_mask"],
-            model_max_length=model_max_length,
-            **kwargs,
-        )
-
-        # to check
-        # import tiktoken
-        # model = tiktoken.Encoding(
-        #     name=Path(model_path).name,
-        #     pat_str=self.O200K_PATTERN,
-        #     mergeable_ranks=mergeable_ranks,
-        #     special_tokens=self.special_tokens,
-        # )
-
-        instruct = chat_template is not None
-        self.update_post_processor(self.converted_tokenizer)
-        # finer special_tokens_map.json
-        self.converted_tokenizer._bos_token = BOS_ADDED_TOKEN
-        self.converted_tokenizer._eos_token = EOT_ADDED_TOKEN if instruct else EOS_ADDED_TOKEN
-
-    # We can't do this while building the tokenizer because we have no easy access to the bos token id
-    def update_post_processor(self, tokenizer):
-        tokenizer._tokenizer.post_processor = processors.Sequence(
-            [
-                processors.ByteLevel(trim_offsets=False),
-                processors.TemplateProcessing(
-                    single="<|begin_of_text|> $A",
-                    pair="<|begin_of_text|>:0 $A:0 <|begin_of_text|>:1 $B:1",
-                    special_tokens=[
-                        ("<|begin_of_text|>", tokenizer.convert_tokens_to_ids("<|begin_of_text|>")),
-                    ],
-                ),
-            ]
-        )
-
-
-O200K_PATTERN = r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?|[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]+[\p{Ll}\p{Lm}\p{Lo}\p{M}]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n/]*|\s*[\r\n]+|\s+(?!\S)|\s+"""  # noqa: E501
-
-
-def write_tokenizer(args):
-    tokenizer_path = os.path.join(args.input_dir, "tokenizer.model")
-    chat_template = "{{- bos_token }}\n{%- if custom_tools is defined %}\n    {%- set tools = custom_tools %}\n{%- endif %}\n{%- if not tools_in_user_message is defined %}\n    {%- set tools_in_user_message = true %}\n{%- endif %}\n{%- if not date_string is defined %}\n    {%- if strftime_now is defined %}\n        {%- set date_string = strftime_now(\"%d %b %Y\") %}\n    {%- else %}\n        {%- set date_string = \"26 Jul 2024\" %}\n    {%- endif %}\n{%- endif %}\n{%- if not tools is defined %}\n    {%- set tools = none %}\n{%- endif %}\n\n{#- This block extracts the system message, so we can slot it into the right place. #}\n{%- if messages[0]['role'] == 'system' %}    \n    {%- if messages[0]['content'] is string %}\n        {%- set system_message = messages[0]['content']|trim %}\n    {%- else %}\n        {#- FIXME: The processor requires an array, always. #}\n        {%- set system_message = messages[0]['content'][0]['text']|trim %}\n    {%- endif %}\n    {%- set messages = messages[1:] %}\n    {%- set user_supplied_system_message = true %}\n{%- else %}\n    {%- set system_message = \"\" %}\n    {%- set user_supplied_system_message = false %}\n{%- endif %}\n\n{#- System message if the user supplied one #}\n{%- if user_supplied_system_message %}\n    {{- \"<|header_start|>system<|header_end|>\n\n\" }}\n    {%- if tools is not none %}\n        {{- \"Environment: ipython\n\" }}\n    {%- endif %}\n    {%- if tools is not none and not tools_in_user_message %}\n        {{- \"You have access to the following functions. To call a function, please respond with JSON for a function call.\" }}\n        {{- 'Respond in the format {\"name\": function name, \"parameters\": dictionary of argument name and its value}.' }}\n        {{- \"Do not use variables.\n\n\" }}\n        {%- for t in tools %}\n            {{- t | tojson(indent=4) }}\n            {{- \"\n\n\" }}\n        {%- endfor %}\n    {%- endif %}\n    {{- system_message }}\n    {{- \"<|eot|>\" }}\n{%- endif %}\n\n{#- Custom tools are passed in a user message with some extra guidance #}\n{%- if tools_in_user_message and not tools is none %}\n    {#- Extract the first user message so we can plug it in here #}\n    {%- if messages | length != 0 %}\n        {%- set first_user_message = messages[0]['content']|trim %}\n        {%- set messages = messages[1:] %}\n    {%- else %}\n        {{- raise_exception(\"Cannot put tools in the first user message when there's no first user message!\") }}\n{%- endif %}\n    {{- '<|header_start|>user<|header_end|>\n\n' -}}\n    {{- \"Given the following functions, please respond with a JSON for a function call \" }}\n    {{- \"with its proper arguments that best answers the given prompt.\n\n\" }}\n    {{- 'Respond in the format {\"name\": function name, \"parameters\": dictionary of argument name and its value}.' }}\n    {{- \"Do not use variables.\n\n\" }}\n    {%- for t in tools %}\n        {{- t | tojson(indent=4) }}\n        {{- \"\n\n\" }}\n    {%- endfor %}\n    {{- first_user_message + \"<|eot|>\"}}\n{%- endif %}\n\n{%- for message in messages %}\n    {%- if not (message.role == 'ipython' or message.role == 'tool' or 'tool_calls' in message) %}\n    {{- '<|header_start|>' + message['role'] + '<|header_end|>\n\n' }}\n        {%- if message['content'] is string %}\n            {{- message['content'] }}\n        {%- else %}\n            {%- for content in message['content'] %}\n                {%- if content['type'] == 'image' %}\n                    {{- '<|image|>' }}\n                {%- elif content['type'] == 'text' %}\n                    {{- content['text'] }}\n                {%- endif %}\n            {%- endfor %}\n        {%- endif %}\n        {{- \"<|eot|>\" }}\n    {%- elif 'tool_calls' in message and message.tool_calls|length > 0 %}\n       {{- '<|header_start|>assistant<|header_end|>\n\n' -}}\n       {{- '<|python_start|>' }}\n        {%- if message['content'] is string %}\n            {{- message['content'] }}\n        {%- else %}\n            {%- for content in message['content'] %}\n                {%- if content['type'] == 'image' %}\n                    {{- '<|image|>' }}\n                {%- elif content['type'] == 'text' %}\n                    {{- content['text'] }}\n                {%- endif %}\n            {%- endfor %}\n        {%- endif %}\n       {{- '<|python_end|>' }}\n        {%- for tool_call in message.tool_calls %}\n           {{- '{\"name\": \"' + tool_call.function.name + '\", ' }}\n           {{- '\"parameters\": ' }}\n           {{- tool_call.function.arguments | tojson }}\n           {{- \"}\" }}\n        {%- endfor %}\n       {{- \"<|eot|>\" }}\n    {%- elif message.role == \"tool\" or message.role == \"ipython\" %}\n        {{- \"<|header_start|>ipython<|header_end|>\n\n\" }}\n        {%- if message.content is mapping or message.content is iterable %}\n            {{- message.content | tojson }}\n        {%- else %}\n            {{- message.content }}\n        {%- endif %}\n        {{- \"<|eot|>\" }}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|header_start|>assistant<|header_end|>\n\n' }}\n{%- endif %}\n"
-
-    special_tokens = BASIC_SPECIAL_TOKENS + LLAMA4_SPECIAL_TOKENS
-    converter = Llama4Converter(
-        vocab_file=tokenizer_path,
-        pattern=O200K_PATTERN,
-        special_tokens=special_tokens,
-        chat_template=chat_template if args.instruct else None,
-        bos_token="<|begin_of_text|>",
-        eos_token="<|end_of_text|>" if not args.instruct else "<|eot|>",
-        pad_token="<|finetune_right_pad_id|>",
-        model_max_length=max_context_length(args.input_dir, args.instruct),
-    )
-    tokenizer = converter.converted_tokenizer
-
-    image_processor = Llama4ImageProcessorFast()
-    processor = Llama4Processor(
-        image_processor=image_processor,
-        tokenizer=tokenizer,
-        chat_template=tokenizer.chat_template,
-    )
-    processor.save_pretrained(args.output_dir)
-    del processor
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        type=str,
-        default="/fsx/arthur/Llama-4-17B-Omni-Instruct-Original",
-        help="Location of the local folder copied from the Hub.",
-    )
-    parser.add_argument(
-        "--output_dir",
-        default="llama4_hf_vision",
-        type=str,
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--safe_serialization", default=True, type=bool, help="Whether or not to save using `safetensors`."
-    )
-    parser.add_argument(
-        "--special_tokens",
-        default=None,
-        type=List[str],
-        help="The list of special tokens that should be added to the model.",
-    )
-    parser.add_argument(
-        "--num_shards",
-        default=8,
-        type=int,
-        help="The number of individual shards used for the model. Does not have to be the same as the number of consolidated_xx.pth",
-    )
-    parser.add_argument(
-        "--instruct",
-        action="store_true",
-        help="Whether the model is an instruct model",
-    )
-    parser.add_argument(
-        "--convert_checkpoints",
-        action="store_true",
-        help="Whether to convert the original weights (or skip if previously converted)",
-    )
-
-    args = parser.parse_args()
-    write_tokenizer(args)
-
-    write_model(
-        model_path=args.output_dir,
-        input_base_path=args.input_dir,
-        safe_serialization=args.safe_serialization,
-        num_shards=args.num_shards,
-        instruct=args.instruct,
-        convert_checkpoints=args.convert_checkpoints,
-    )
diff --git a/src/transformers/models/llava/convert_llava_weights_to_hf.py b/src/transformers/models/llava/convert_llava_weights_to_hf.py
deleted file mode 100644
index 3582b9772c9c..000000000000
--- a/src/transformers/models/llava/convert_llava_weights_to_hf.py
+++ /dev/null
@@ -1,204 +0,0 @@
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import glob
-
-import torch
-from huggingface_hub import file_exists, hf_hub_download, snapshot_download
-from safetensors import safe_open
-
-from transformers import (
-    AddedToken,
-    AutoConfig,
-    AutoImageProcessor,
-    AutoTokenizer,
-    LlavaConfig,
-    LlavaForConditionalGeneration,
-    LlavaProcessor,
-    SiglipVisionConfig,
-)
-
-
-EPILOG_TXT = """Example:
-    python transformers/src/transformers/models/llava/convert_llava_weights_to_hf.py --text_model_id lmsys/vicuna-7b-v1.5 --vision_model_id openai/clip-vit-large-patch14-336 --output_hub_path org/llava-v1.5-7b-conv --old_state_dict_id liuhaotian/llava-v1.5-7b
-
-Example for creating the old state dict file with Python:
-
-    import torch
-    from llava.model.language_model.llava_llama import LlavaLlamaForCausalLM
-
-    # load model
-    kwargs = {"device_map": "auto", "torch_dtype": torch.float16}
-    model = LlavaLlamaForCausalLM.from_pretrained("liuhaotian/llava-v1.5-7b", low_cpu_mem_usage=True, **kwargs)
-
-    # load vision tower
-    model.get_vision_tower().load_model()
-
-    # Save state dict
-    torch.save(model.state_dict(), "tmp/hf_models/llava-v1.5-7b/model_state_dict.bin")
-"""
-
-KEYS_TO_MODIFY_MAPPING = {
-    "model.vision_tower.": "",
-    ".vision_resampler": "",  # all lmms-lab models do avg pooling, so no vision_resampler
-    "model.mm_projector": "multi_modal_projector",
-    "model": "model.model",
-    "vision_model.model": "vision_model",
-    "lm_head": "language_model.lm_head",
-    "model.model": "language_model.model",
-    "multi_modal_projector.0": "multi_modal_projector.linear_1",
-    "multi_modal_projector.2": "multi_modal_projector.linear_2",
-}
-
-
-def load_original_state_dict(model_id):
-    directory_path = snapshot_download(repo_id=model_id, allow_patterns=["*.safetensors"])
-
-    original_state_dict = {}
-    for path in glob.glob(f"{directory_path}/*"):
-        if path.endswith(".safetensors"):
-            with safe_open(path, framework="pt", device="cpu") as f:
-                for key in f.keys():
-                    original_state_dict[key] = f.get_tensor(key)
-
-    # tied wieghts so lm.head is not saved. Let's clone to load state dict
-    if "lm_head.weight" not in original_state_dict:
-        original_state_dict["lm_head.weight"] = original_state_dict["model.embed_tokens.weight"].clone()
-
-    if "model.image_newline" in original_state_dict:
-        # not used in the original implementation because "merge_type=flat"
-        del original_state_dict["model.image_newline"]
-    return original_state_dict
-
-
-# used only for llava-interlave
-# for ex: Qwen/Qwen1.5-0.5B-Chat google/siglip-so400m-patch14-384 lmms-lab/llava-next-interleave-qwen-0.5b
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if key.endswith(".inv_freq"):
-            continue
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        new_state_dict[key] = value
-    return new_state_dict
-
-
-def convert_llava_llama_to_hf(text_model_id, vision_model_id, output_hub_path, old_state_dict_id):
-    torch.set_default_dtype(torch.float16)
-    text_config = AutoConfig.from_pretrained(text_model_id)
-
-    tokenizer = AutoTokenizer.from_pretrained(text_model_id)
-    tokenizer.add_tokens(AddedToken("<image>", special=True, normalized=False), special_tokens=True)
-    if "Qwen" not in text_model_id:  # qwen already has a pad token
-        tokenizer.add_special_tokens({"pad_token": "<pad>"})
-
-    image_processor = AutoImageProcessor.from_pretrained(vision_model_id)
-    processor = LlavaProcessor(tokenizer=tokenizer, image_processor=image_processor)
-
-    if "siglip" in vision_model_id:
-        vision_config = SiglipVisionConfig(
-            hidden_size=1152,
-            image_size=384,
-            intermediate_size=4304,
-            num_attention_heads=16,
-            num_hidden_layers=26,
-            patch_size=14,
-            vision_use_head=False,
-        ).to_dict()
-    else:
-        vision_config = None
-
-    config = LlavaConfig(
-        text_config=text_config,
-        vision_config=vision_config,
-    )
-
-    # llms-lab interleeave models do not use any selection startegy except for last hidden state
-    if "Qwen" in text_model_id:
-        config.image_token_index = 151646
-        if "siglip" in vision_model_id:
-            config.vision_feature_select_strategy = "full"
-            config.vision_feature_layer = -1
-    else:
-        config.pad_token_id = 32001
-        config.image_token_index = 32000
-
-    with torch.device("meta"):
-        model = LlavaForConditionalGeneration(config)
-
-    # Some llava variants like microsoft/llava-med-v1.5-mistral-7b use safetensors to store weights
-    if file_exists(old_state_dict_id, "model_state_dict.bin"):
-        state_dict_path = hf_hub_download(old_state_dict_id, "model_state_dict.bin")
-        state_dict = torch.load(state_dict_path, map_location="cpu", weights_only=True)
-    else:
-        state_dict = load_original_state_dict(old_state_dict_id)
-
-    state_dict = convert_state_dict_to_hf(state_dict)
-    model.load_state_dict(state_dict, strict=True, assign=True)
-
-    pre_expansion_embeddings = model.language_model.model.embed_tokens.weight.data
-    mu = torch.mean(pre_expansion_embeddings, dim=0).float()
-    n = pre_expansion_embeddings.size()[0]
-    sigma = ((pre_expansion_embeddings - mu).T @ (pre_expansion_embeddings - mu)) / n
-    dist = torch.distributions.multivariate_normal.MultivariateNormal(mu, covariance_matrix=1e-5 * sigma)
-
-    # We add an image token so we resize the model and pad to 64 for performance reasons
-    pad_shape = 64
-    vocab_size = config.text_config.vocab_size
-    model.resize_token_embeddings(config.text_config.vocab_size + 2, pad_shape)
-    model.language_model.model.embed_tokens.weight.data[vocab_size:] = torch.stack(
-        tuple(
-            (dist.sample() for _ in range(model.language_model.model.embed_tokens.weight.data[vocab_size:].shape[0]))
-        ),
-        dim=0,
-    )
-    model.language_model.lm_head.weight.data[vocab_size:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.lm_head.weight.data[vocab_size:].shape[0]))),
-        dim=0,
-    )
-
-    model.push_to_hub(output_hub_path)
-    processor.push_to_hub(output_hub_path)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        epilog=EPILOG_TXT,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument(
-        "--text_model_id",
-        help="Hub location of the text model",
-    )
-    parser.add_argument(
-        "--vision_model_id",
-        help="Hub location of the vision model",
-    )
-    parser.add_argument(
-        "--output_hub_path",
-        help="Location on the hub of the converted model",
-    )
-    parser.add_argument(
-        "--old_state_dict_id",
-        help="Location on the hub of the raw state dict of the original model. The filename needs to be `model_state_dict.bin`",
-    )
-    args = parser.parse_args()
-    convert_llava_llama_to_hf(args.text_model_id, args.vision_model_id, args.output_hub_path, args.old_state_dict_id)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/llava_next/convert_llava_next_weights_to_hf.py b/src/transformers/models/llava_next/convert_llava_next_weights_to_hf.py
deleted file mode 100644
index 06edc5c9b1ad..000000000000
--- a/src/transformers/models/llava_next/convert_llava_next_weights_to_hf.py
+++ /dev/null
@@ -1,397 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert LLaVa-NeXT (LLaVa-1.6) checkpoints from the original repository.
-
-URL: https://github.com/haotian-liu/LLaVA/tree/main.
-
-
-The command used to obtain original logits is the following:
-python llava/eval/run_llava.py --model-path "liuhaotian/llava-v1.6-mistral-7b" --image-file "images/llava_v1_5_radar.jpg" --query "What is shown in this image?" --max_new_tokens 100 --temperature 0
-
-Note: logits are tested with torch==2.1.2.
-"""
-
-import argparse
-import gc
-import glob
-import json
-from pathlib import Path
-
-import requests
-import torch
-from accelerate import init_empty_weights
-from huggingface_hub import hf_hub_download, snapshot_download
-from PIL import Image
-from safetensors import safe_open
-
-from transformers import (
-    AddedToken,
-    AutoConfig,
-    AutoTokenizer,
-    LlavaNextConfig,
-    LlavaNextForConditionalGeneration,
-    LlavaNextImageProcessor,
-    LlavaNextProcessor,
-)
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "model.vision_tower.": "",
-    "model.mm_projector": "multi_modal_projector",
-    "model": "model.model",
-    "vision_model.model": "vision_model",
-    "lm_head": "language_model.lm_head",
-    "model.model": "language_model.model",
-    "multi_modal_projector.0": "multi_modal_projector.linear_1",
-    "multi_modal_projector.2": "multi_modal_projector.linear_2",
-    "language_model.model.image_newline": "image_newline",
-}
-
-
-def load_original_state_dict(model_id):
-    directory_path = snapshot_download(repo_id=model_id, allow_patterns=["*.safetensors"])
-
-    original_state_dict = {}
-    for path in glob.glob(f"{directory_path}/*"):
-        if path.endswith(".safetensors"):
-            with safe_open(path, framework="pt", device="cpu") as f:
-                for key in f.keys():
-                    original_state_dict[key] = f.get_tensor(key)
-
-    return original_state_dict
-
-
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if key.endswith(".inv_freq"):
-            continue
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        new_state_dict[key] = value.to(torch.float16)
-    return new_state_dict
-
-
-def load_image():
-    url = "https://github.com/haotian-liu/LLaVA/blob/1a91fc274d7c35a9b50b3cb29c4247ae5837ce39/images/llava_v1_5_radar.jpg?raw=true"
-    image = Image.open(requests.get(url, stream=True).raw)
-    return image
-
-
-def convert_llava_to_hf(model_id, pytorch_dump_folder_path, push_to_hub=False):
-    # load original config
-    filepath = hf_hub_download(repo_id=model_id, filename="config.json", repo_type="model")
-    # read json
-    with open(filepath) as f:
-        data = json.load(f)
-        print(data)
-
-    if model_id == "liuhaotian/llava-v1.6-mistral-7b":
-        text_model_id = "mistralai/Mistral-7B-Instruct-v0.2"
-        image_token_index = 32000
-    elif model_id == "liuhaotian/llava-v1.6-vicuna-7b":
-        text_model_id = "lmsys/vicuna-7b-v1.5"
-        image_token_index = 32000
-    elif model_id == "liuhaotian/llava-v1.6-vicuna-13b":
-        text_model_id = "lmsys/vicuna-13b-v1.5"
-        image_token_index = 32000
-    elif model_id == "liuhaotian/llava-v1.6-34b":
-        text_model_id = "NousResearch/Nous-Hermes-2-Yi-34B"
-        image_token_index = 64000
-    elif model_id == "lmms-lab/llama3-llava-next-8b":
-        text_model_id = "meta-llama/Meta-Llama-3-8B-Instruct"
-        image_token_index = 128256
-    elif model_id == "lmms-lab/llava-next-72b":
-        text_model_id = "Qwen/Qwen1.5-72B-Chat"
-        image_token_index = 151646
-    elif model_id == "lmms-lab/llava-next-110b":
-        text_model_id = "Qwen/Qwen1.5-110B-Chat"
-        image_token_index = 151646
-
-    vision_model_id = data["mm_vision_tower"]
-
-    torch.set_default_dtype(torch.float16)
-    text_config = AutoConfig.from_pretrained(text_model_id)
-
-    use_fast = False if model_id == "liuhaotian/llava-v1.6-34b" else True
-    tokenizer = AutoTokenizer.from_pretrained(text_model_id, use_fast=use_fast)
-    tokenizer.add_tokens(AddedToken("<image>", special=True, normalized=False), special_tokens=True)
-
-    if model_id in ("liuhaotian/llava-v1.6-mistral-7b", "lmms-lab/llama3-llava-next-8b"):
-        # Mistral-7B doesn't have a padding token set yet
-        tokenizer.add_special_tokens({"pad_token": "<pad>"})
-
-    image_processor = LlavaNextImageProcessor.from_pretrained(vision_model_id)
-    processor = LlavaNextProcessor(tokenizer=tokenizer, image_processor=image_processor)
-
-    config = LlavaNextConfig(
-        text_config=text_config.to_dict(),
-        image_grid_pinpoints=image_processor.image_grid_pinpoints,
-        use_image_newline_parameter=True,
-        image_token_index=image_token_index,
-    )
-
-    with init_empty_weights():
-        model = LlavaNextForConditionalGeneration(config)
-
-    # load original state dict
-    state_dict = load_original_state_dict(model_id)
-    state_dict = convert_state_dict_to_hf(state_dict)
-    model.load_state_dict(state_dict, assign=True)
-    model.eval()
-
-    pre_expansion_embeddings = model.language_model.model.embed_tokens.weight.data
-    mu = torch.mean(pre_expansion_embeddings, dim=0).float()
-    n = pre_expansion_embeddings.size()[0]
-    sigma = ((pre_expansion_embeddings - mu).T @ (pre_expansion_embeddings - mu)) / n
-    dist = torch.distributions.multivariate_normal.MultivariateNormal(mu, covariance_matrix=1e-5 * sigma)
-
-    # We add an image token so we resize the model
-    # Pad to 64 for performance reasons
-    # Qwen-based models have extra unused space in the vocab size already, so no need to resize
-    if model_id not in ["lmms-lab/llava-next-72b", "lmms-lab/llava-next-110b"]:
-        pad_shape = 64
-        vocab_size = config.text_config.vocab_size
-        if model_id == "liuhaotian/llava-v1.6-34b":
-            # this one has 3 additional tokens, namely <|startoftext|>, <|endoftext|> and <image>
-            num_tokens = vocab_size + 3
-        else:
-            # this one has 2 additional tokens, namely <image> and <pad>
-            num_tokens = vocab_size + 2
-        model.resize_token_embeddings(num_tokens, pad_to_multiple_of=pad_shape)
-        model.language_model.model.embed_tokens.weight.data[vocab_size:] = torch.stack(
-            tuple(
-                (
-                    dist.sample()
-                    for _ in range(model.language_model.model.embed_tokens.weight.data[vocab_size:].shape[0])
-                )
-            ),
-            dim=0,
-        )
-        model.language_model.lm_head.weight.data[vocab_size:] = torch.stack(
-            tuple((dist.sample() for _ in range(model.language_model.lm_head.weight.data[vocab_size:].shape[0]))),
-            dim=0,
-        )
-
-    print(f"Saving model and processor for {model_id} to {pytorch_dump_folder_path}")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-    processor.save_pretrained(pytorch_dump_folder_path)
-
-    # Make space so we can load the model properly now.
-    del state_dict
-    gc.collect()
-
-    # Load everything back for inference tests in float32 because prev script was written as that
-    # Though it's mostly loaded in fp16 as original weights are in fp16
-    model = LlavaNextForConditionalGeneration.from_pretrained(pytorch_dump_folder_path, device_map="auto")
-    processor = LlavaNextProcessor.from_pretrained(pytorch_dump_folder_path)
-    device = model.device
-
-    # prepare inputs
-    image = load_image()
-    if model_id == "liuhaotian/llava-v1.6-mistral-7b":
-        prompt = "[INST] <image>\nWhat is shown in this image? [/INST]"
-    elif model_id in ["liuhaotian/llava-v1.6-vicuna-7b", "liuhaotian/llava-v1.6-vicuna-13b"]:
-        prompt = "A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions. USER: <image>\nWhat is shown in this image? ASSISTANT:"
-    elif model_id == "liuhaotian/llava-v1.6-34b":
-        prompt = "<|im_start|>system\nAnswer the questions.<|im_end|><|im_start|>user\n<image>\nWhat is shown in this image?<|im_end|><|im_start|>assistant\n"
-    elif model_id == "lmms-lab/llama3-llava-next-8b":
-        prompt = "<|start_header_id|>system<|end_header_id|>\n\nYou are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.<|eot_id|><|start_header_id|><|start_header_id|>user<|end_header_id|>\n\n<image>\nWhat is shown in this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
-    elif model_id in ["lmms-lab/llava-next-72b", "lmms-lab/llava-next-110b"]:
-        prompt = "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<image>\nWhat is shown in this image?<|im_end|>\n<|im_start|>assistant\n"
-
-    inputs = processor(images=image, text=prompt, return_tensors="pt")
-
-    # verify inputs
-    filepath = hf_hub_download(repo_id="nielsr/test-image", filename="llava_1_6_pixel_values.pt", repo_type="dataset")
-    original_pixel_values = torch.load(filepath, map_location="cpu")
-    assert torch.allclose(original_pixel_values, inputs.pixel_values.half())
-
-    if model_id == "liuhaotian/llava-v1.6-mistral-7b":
-        filepath = hf_hub_download(repo_id="nielsr/test-image", filename="llava_1_6_input_ids.pt", repo_type="dataset")
-        original_input_ids = torch.load(filepath, map_location="cpu")
-        # replace -200 by image_token_index (since we use token ID = 32000 for the image token)
-        original_input_ids[original_input_ids == -200] = image_token_index
-        assert original_input_ids[0].tolist() == inputs.input_ids[0].tolist()
-
-    elif model_id == "liuhaotian/llava-v1.6-34b":
-        filepath = hf_hub_download(
-            repo_id="nielsr/test-image", filename="llava_1_6_34b_input_ids.pt", repo_type="dataset"
-        )
-        original_input_ids = torch.load(filepath, map_location="cpu")
-        # replace -200 by image_token_index
-        original_input_ids[original_input_ids == -200] = image_token_index
-
-        assert original_input_ids[0].tolist() == inputs.input_ids[0].tolist()
-
-    image_sizes = torch.tensor([[899, 1024]])
-    assert image_sizes[0].tolist() == inputs.image_sizes[0].tolist()
-
-    # verify single forward pass
-    print("Single forward pass")
-    with torch.inference_mode():
-        inputs = inputs.to(device)
-        outputs = model(**inputs)
-        print("Shape of logits:", outputs.logits.shape)
-        print("First values of logits:", outputs.logits[0, :3, :3])
-
-        if model_id == "liuhaotian/llava-v1.6-mistral-7b":
-            expected_slice = torch.tensor(
-                [[-4.8555, -4.6992, -0.1996], [-10.5703, -10.7344, -2.7246], [-7.0391, -7.3672, -0.2634]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "liuhaotian/llava-v1.6-vicuna-7b":
-            expected_slice = torch.tensor(
-                [[1.4883, 0.9976, -0.6992], [-9.7031, -5.7031, -1.5557], [-5.1328, -5.5586, 8.8281]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "liuhaotian/llava-v1.6-vicuna-13b":
-            expected_slice = torch.tensor(
-                [[-0.9614, 7.3125, 0.2106], [-7.2695, -8.5469, 3.6211], [-6.3750, -8.1875, 5.4688]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "liuhaotian/llava-v1.6-34b":
-            expected_slice = torch.tensor(
-                [[-9.0859, -9.1406, 5.9453], [-5.9570, -5.9766, 2.2754], [-5.7305, -5.7539, 4.0000]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llama3-llava-next-8b":
-            expected_slice = torch.tensor(
-                [[-3.9648, 1.1396, 3.3145], [-5.3594, -1.5654, -1.9619], [-12.3750, -10.6797, -9.3125]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-next-72b":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[3.7148, 3.9277, 3.4395], [-0.4341, 1.1387, 6.5117], [3.2324, 3.4688, 4.1133]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-next-110b":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[-2.5449, -1.6738, -2.0371], [1.0811, 3.4961, 5.0312], [1.7803, 2.5137, 2.4277]],
-                dtype=torch.float32,
-                device=device,
-            )
-        else:
-            raise ValueError(f"Model {model_id} not supported")
-
-        assert torch.allclose(outputs.logits[0, :3, :3], expected_slice, atol=1e-4)
-        print("Logits are ok!")
-
-    # verify generation
-    output_ids = model.generate(
-        **inputs,
-        max_new_tokens=100,
-        use_cache=True,
-    )
-
-    generated_text = processor.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
-
-    print("Generated text:", repr(generated_text))
-
-    if model_id == "liuhaotian/llava-v1.6-mistral-7b":
-        expected_text = '[INST]  \nWhat is shown in this image? [/INST] The image appears to be a radar chart, which is a type of multi-dimensional plot that displays data in the form of a two-dimensional chart of three or more quantitative variables represented on axes starting from the same point.\n\nIn this particular radar chart, there are several axes labeled with different metrics or benchmarks, such as "MMM-Vet," "MMM-Bench," "LLaVA-Bench," "SLED-Bench," "'
-    elif model_id == "liuhaotian/llava-v1.6-vicuna-7b":
-        expected_text = """A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human\'s questions. USER:  \nWhat is shown in this image? ASSISTANT: The image appears to be a graphical representation of a benchmarking study comparing the performance of various models or systems. It\'s a scatter plot with a circular layout, where each point represents a different model or system, and the axes represent different metrics or dimensions of comparison.\n\nThe metrics are likely related to machine learning or artificial intelligence performance, as indicated by the terms like "BLIP-2," "Instruct BLIP," "POE," "QWA," "V"""
-    elif model_id == "liuhaotian/llava-v1.6-vicuna-13b":
-        expected_text = "A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions. USER:  \nWhat is shown in this image? ASSISTANT: The image appears to be a radar chart, also known as a spider chart or star chart, which is a graphical method of displaying multivariate data in the form of a two-dimensional chart of three or more quantitative variables represented on axes starting from the same point.\n\nIn this particular radar chart, there are several variables represented:\n\n- MM-Vet\n- LLa-Va-Bench\n- SEED-Bench\n- MM"
-    elif model_id == "liuhaotian/llava-v1.6-34b":
-        expected_text = "<|im_start|> system\nAnswer the questions. <|im_start|> user\n\nWhat is shown in this image? <|im_start|> assistant\nThe image appears to be a radar chart, also known as a spider chart, which is a graphical method of displaying multivariate data in the form of a two-dimensional chart of three or more quantitative variables represented on axes starting from the same point.\n\nIn this particular chart, there are several datasets represented by different colors and labeled with various acronyms such as MM-Vet, LLaVA-Bench, SEED-Bench, MM-Bench-CN, MM-"
-    elif model_id == "lmms-lab/llama3-llava-next-8b":
-        expected_text = 'system\n\nYou are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.user\n\n\nWhat is shown in this image?assistant\n\n\nThe image shows a radar chart, also known as a spider chart or a web chart, which is a type of graph used to display multivariate data in the form of a two-dimensional chart of three or more quantitative variables represented on axes starting from the same point. Each axis represents a different variable, and the values are plotted along each axis and connected to form a polygon.\n\nIn this particular radar chart, there are several axes labeled with different variables, such as "MM-Vet," "LL'
-    elif model_id == "lmms-lab/llava-next-72b":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image displays a radar chart, also known as a spider chart or a star chart, which is a graphical method of displaying multivariate data in the form of a two-dimensional chart of three or more quantitative variables represented on axes starting from the same point. Each axis represents a different variable, and the value of each variable is represented by the distance from the center of the chart to the point where the axis intersects with the line representing that variable's value.\n\nIn this particular chart, there are several axes"
-    elif model_id == "lmms-lab/llava-next-110b":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image shows a radar chart comparing the performance of different models on various visual question answering (VQA) benchmarks. Each colored line represents a different model, and the distance from the center of the chart indicates the score or performance level of the model on a particular benchmark. The benchmarks are labeled around the edges of the chart, and include VQA v2, GQA, VizWiz, TextVQA, MMBench-CN, MME, and others. The chart allows for a"
-    else:
-        raise ValueError(f"Model {model_id} not supported")
-
-    assert generated_text == expected_text
-    print("Generated text is ok!")
-
-    # verify batched generation
-    print("Batched generation...")
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    cats_image = Image.open(requests.get(url, stream=True).raw)
-
-    inputs = processor(
-        images=[image, cats_image],
-        text=[prompt, prompt],
-        padding=True,
-        return_tensors="pt",
-    ).to(device)
-
-    for k, v in inputs.items():
-        print(k, v.shape)
-
-    print("Image sizes:", inputs.image_sizes)
-
-    # make sure image_sizes are the same
-    # as otherwise batched generation doesn't work
-    inputs.image_sizes[1] = inputs.image_sizes[0]
-
-    print("Batched generation...")
-    output_ids = model.generate(
-        **inputs,
-        max_new_tokens=20,
-        use_cache=True,
-    )
-
-    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
-    print(outputs)
-
-    if push_to_hub:
-        checkpoint_name = model_id.split("/")[-1]
-        print(f"Pushing to repo llava-hf/{checkpoint_name}-hf")
-        model.push_to_hub(f"llava-hf/{checkpoint_name}-hf")
-        processor.push_to_hub(f"llava-hf/{checkpoint_name}-hf")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model_id",
-        help="Hub location of the model to convert",
-        default="liuhaotian/llava-v1.6-mistral-7b",
-        choices=[
-            "liuhaotian/llava-v1.6-mistral-7b",
-            "liuhaotian/llava-v1.6-vicuna-7b",
-            "liuhaotian/llava-v1.6-vicuna-13b",
-            "liuhaotian/llava-v1.6-34b",
-            "lmms-lab/llama3-llava-next-8b",
-            "lmms-lab/llava-next-72b",
-            "lmms-lab/llava-next-110b",
-        ],
-        required=False,
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", type=str, required=True, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-
-    convert_llava_to_hf(args.model_id, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/llava_next_video/convert_llava_next_video_weights_to_hf.py b/src/transformers/models/llava_next_video/convert_llava_next_video_weights_to_hf.py
deleted file mode 100644
index aae44eee97a0..000000000000
--- a/src/transformers/models/llava_next_video/convert_llava_next_video_weights_to_hf.py
+++ /dev/null
@@ -1,276 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert LLaVa-NeXT-Video checkpoints from the original repository.
-
-URL: https://github.com/LLaVA-VL/LLaVA-NeXT/tree/inference
-"""
-
-import argparse
-import glob
-import json
-from pathlib import Path
-
-import torch
-from accelerate import init_empty_weights
-from huggingface_hub import hf_hub_download, snapshot_download
-from safetensors import safe_open
-
-from transformers import (
-    AddedToken,
-    AutoConfig,
-    AutoTokenizer,
-    LlavaNextImageProcessor,
-    LlavaNextVideoConfig,
-    LlavaNextVideoForConditionalGeneration,
-    LlavaNextVideoImageProcessor,
-    LlavaNextVideoProcessor,
-)
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "model.vision_tower.": "",
-    ".vision_resampler": "",  # all lmms-lab models do avg pooling, so no vision_resampler
-    "model.mm_projector": "multi_modal_projector",
-    "model": "model.model",
-    "vision_model.model": "vision_model",
-    "lm_head": "language_model.lm_head",
-    "model.model": "language_model.model",
-    "multi_modal_projector.0": "multi_modal_projector.linear_1",
-    "multi_modal_projector.2": "multi_modal_projector.linear_2",
-    "language_model.model.image_newline": "image_newline",
-}
-
-# {{SYSTEM_PROMPT}} USER: <image>\n{{PROMPT}} ASSISTANT:" assistant end with "</s> "
-chat_vicuna = (
-    "{% for message in messages %}"
-    "{% if message['role'] == 'system' %}"
-    "{{ message['content'][0]['text'] }}"
-    "{% else %}"
-    "{{ message['role'].upper() + ': '}}"
-    "{% endif %}"
-    "{# Render all images first #}"
-    "{% for content in message['content'] | selectattr('type', 'equalto', 'image') %}"
-    "{{ '<image>\n' }}"
-    "{% endfor %}"
-    "{# Render all text next #}"
-    "{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}"
-    "{{ content['text'] + ' '}}"
-    "{% endfor %}"
-    "{% endfor %}"
-    "{% if add_generation_prompt %}"
-    "{{ 'ASSISTANT:' }}"
-    "{% endif %}"
-)
-
-# "[INST] <image>\nWhat is shown in this image? [/INST]" assistant end with "</s> "
-chat_mistral = (
-    "{% for message in messages %}"
-    "{% if message['role'] == 'user' %}"
-    "{{ '[INST] ' }}"
-    "{# Render all images first #}"
-    "{% for content in message['content'] | selectattr('type', 'equalto', 'image') %}"
-    "{{ '<image>\n' }}"
-    "{% endfor %}"
-    "{# Render all text next #}"
-    "{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}"
-    "{{ content['text'] }}"
-    "{% endfor %}"
-    "{{' [/INST]' }}"
-    "{% elif message['role'] == 'assistant' %}"
-    r"{{ ' ' + message['content'][0]['text'] + '<\s> '}}"
-    "{% else %}"
-    "{{ raise_exception('Only user and assistant roles are supported!') }}"
-    "{% endif %}"
-    "{% endfor %}"
-)
-
-# "<|im_start|>system\nAnswer the questions.<|im_end|><|im_start|>user\n<image>\nWhat is shown in this image?<|im_end|><|im_start|>assistant\n"
-chat_yi = (
-    "{% for message in messages %}"
-    "{{'<|im_start|>' + message['role'] + '\n'}}"
-    "{# Render all images first #}"
-    "{% for content in message['content'] | selectattr('type', 'equalto', 'image') %}"
-    "{{ '<image>\n' }}"
-    "{% endfor %}"
-    "{# Render all text next #}"
-    "{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}"
-    "{{ content['text'] }}"
-    "{% endfor %}"
-    "{{'<|im_end|>' + '\n'}}"
-    "{% endfor %}"
-    "{% if add_generation_prompt %}"
-    "{{ '<|im_start|>assistant\n' }}"
-    "{% endif %}"
-)
-
-model2template = {
-    "lmms-lab/LLaVA-NeXT-Video-7B-32K": chat_mistral,
-    "lmms-lab/LLaVA-NeXT-Video-7B": chat_vicuna,
-    "lmms-lab/LLaVA-NeXT-Video-7B-DPO": chat_vicuna,
-    "lmms-lab/LLaVA-NeXT-Video-34B": chat_yi,
-    "lmms-lab/LLaVA-NeXT-Video-34B-DPO": chat_yi,
-}
-
-
-def load_original_state_dict(model_id):
-    directory_path = snapshot_download(repo_id=model_id, allow_patterns=["*.safetensors"])
-
-    original_state_dict = {}
-    for path in glob.glob(f"{directory_path}/*"):
-        if path.endswith(".safetensors"):
-            with safe_open(path, framework="pt", device="cpu") as f:
-                for key in f.keys():
-                    original_state_dict[key] = f.get_tensor(key)
-
-    return original_state_dict
-
-
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if key.endswith(".inv_freq"):
-            continue
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        new_state_dict[key] = value.to(torch.bfloat16)
-    return new_state_dict
-
-
-def convert_llava_to_hf(model_id, pytorch_dump_folder_path, push_to_hub=False):
-    # load original config
-    filepath = hf_hub_download(repo_id=model_id, filename="config.json", repo_type="model")
-    with open(filepath) as f:
-        data = json.load(f)
-        print(data)
-
-    if model_id == "lmms-lab/LLaVA-NeXT-Video-7B-32K":
-        text_model_id = "mistralai/Mistral-7B-Instruct-v0.2"
-        video_token_index = 32000
-        image_token_index = 32001
-        overwrite_text_config = {}
-    elif model_id in ["lmms-lab/LLaVA-NeXT-Video-7B", "lmms-lab/LLaVA-NeXT-Video-7B-DPO"]:
-        text_model_id = "lmsys/vicuna-7b-v1.5"
-        video_token_index = 32000
-        image_token_index = 32001
-        overwrite_text_config = {"factor": 2.0, "type": "linear"}
-    elif model_id in ["lmms-lab/LLaVA-NeXT-Video-34B", "lmms-lab/LLaVA-NeXT-Video-34B-DPO"]:
-        text_model_id = "NousResearch/Nous-Hermes-2-Yi-34B"
-        video_token_index = 64000
-        image_token_index = 64001
-        overwrite_text_config = {}
-    else:
-        raise ValueError("Incorrect checkpoint referenced. Text model-id not identified!")
-
-    vision_model_id = data["mm_vision_tower"]
-
-    torch.set_default_dtype(torch.bfloat16)
-    text_config = AutoConfig.from_pretrained(text_model_id)
-    text_config = text_config.to_dict()
-    text_config.update(overwrite_text_config)
-
-    tokenizer = AutoTokenizer.from_pretrained(text_model_id, use_fast=True, padding_side="left")
-    tokenizer.add_tokens(AddedToken("<video>", special=True, normalized=False), special_tokens=True)
-    tokenizer.add_tokens(AddedToken("<image>", special=True, normalized=False), special_tokens=True)
-
-    image_processor = LlavaNextImageProcessor.from_pretrained(vision_model_id)
-    video_processor = LlavaNextVideoImageProcessor.from_pretrained(vision_model_id)
-    processor = LlavaNextVideoProcessor(
-        tokenizer=tokenizer,
-        video_processor=video_processor,
-        image_processor=image_processor,
-        chat_template=model2template[model_id],
-    )
-
-    config = LlavaNextVideoConfig(
-        text_config=text_config,
-        image_grid_pinpoints=image_processor.image_grid_pinpoints,
-        use_image_newline_parameter=True,
-        video_token_index=video_token_index,
-        image_token_index=image_token_index,
-    )
-
-    with init_empty_weights():
-        model = LlavaNextVideoForConditionalGeneration(config)
-
-    # load original state dict
-    state_dict = load_original_state_dict(model_id)
-    state_dict = convert_state_dict_to_hf(state_dict)
-    model.load_state_dict(state_dict, assign=True, strict=True)
-
-    # See https://nlp.stanford.edu/~johnhew/vocab-expansion.html for why we get mean/stdev this way to expand embeddings
-    pre_expansion_embeddings = model.language_model.model.embed_tokens.weight.data
-    mu = torch.mean(pre_expansion_embeddings, dim=0).float()
-    n = pre_expansion_embeddings.size()[0]
-    sigma = ((pre_expansion_embeddings - mu).T @ (pre_expansion_embeddings - mu)) / n
-    dist = torch.distributions.multivariate_normal.MultivariateNormal(mu, covariance_matrix=1e-5 * sigma)
-
-    # We add an image token so we resize the model
-    # Pad to 64 for performance reasons
-    pad_shape = 64
-    vocab_size = config.text_config.vocab_size
-
-    # this one has 2 additional tokens, namely <image>, <video> and <pad>
-    num_tokens = vocab_size + 3
-    model.resize_token_embeddings(num_tokens, pad_to_multiple_of=pad_shape)
-    model.language_model.model.embed_tokens.weight.data[vocab_size:] = torch.stack(
-        tuple(
-            (dist.sample() for _ in range(model.language_model.model.embed_tokens.weight.data[vocab_size:].shape[0]))
-        ),
-        dim=0,
-    )
-    model.language_model.lm_head.weight.data[vocab_size:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.lm_head.weight.data[vocab_size:].shape[0]))),
-        dim=0,
-    )
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor for {model_id} to {pytorch_dump_folder_path}")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        repo_id = model_id.split("/")[-1]
-        print(f"Pushing model to hub repo: {repo_id}")
-        model.push_to_hub(f"llava-hf/{repo_id}-hf")
-        processor.push_to_hub(f"llava-hf/{repo_id}-hf")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model_id",
-        help="Hub location of the model to convert",
-        default="lmms-lab/LLaVA-NeXT-Video-7B",
-        choices=[
-            "lmms-lab/LLaVA-NeXT-Video-7B",
-            "lmms-lab/LLaVA-NeXT-Video-7B-DPO",
-            "lmms-lab/LLaVA-NeXT-Video-7B-32K",
-            "lmms-lab/LLaVA-NeXT-Video-34B",
-            "lmms-lab/LLaVA-NeXT-Video-34B-DPO",
-        ],
-        required=False,
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-
-    convert_llava_to_hf(args.model_id, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/llava_onevision/convert_llava_onevision_weights_to_hf.py b/src/transformers/models/llava_onevision/convert_llava_onevision_weights_to_hf.py
deleted file mode 100644
index 65c57f624f54..000000000000
--- a/src/transformers/models/llava_onevision/convert_llava_onevision_weights_to_hf.py
+++ /dev/null
@@ -1,388 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert LLaVa-Onevision checkpoints from the original repository.
-
-URL: https://github.com/LLaVA-VL/LLaVA-NeXT/tree/main
-
-"""
-
-import argparse
-import gc
-import glob
-import json
-from pathlib import Path
-
-import requests
-import torch
-from accelerate import init_empty_weights
-from huggingface_hub import hf_hub_download, snapshot_download
-from PIL import Image
-from safetensors import safe_open
-
-from transformers import (
-    AddedToken,
-    AutoConfig,
-    AutoTokenizer,
-    LlavaOnevisionConfig,
-    LlavaOnevisionForConditionalGeneration,
-    LlavaOnevisionImageProcessor,
-    LlavaOnevisionProcessor,
-    LlavaOnevisionVideoProcessor,
-    SiglipVisionConfig,
-)
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "model.vision_tower.": "",
-    "model.mm_projector": "multi_modal_projector",
-    "model": "model.model",
-    "vision_model.model": "vision_model",
-    "lm_head": "language_model.lm_head",
-    "model.model": "language_model.model",
-    "multi_modal_projector.0": "multi_modal_projector.linear_1",
-    "multi_modal_projector.2": "multi_modal_projector.linear_2",
-    "language_model.model.image_newline": "image_newline",
-}
-
-chat_template = "{% for message in messages %}{{'<|im_start|>' + message['role'] + '\n'}}{# Render all images first #}{% for content in message['content'] | selectattr('type', 'equalto', 'image') %}{{ '<image>\n' }}{% endfor %}{# Render all video then #}{% for content in message['content'] | selectattr('type', 'equalto', 'video') %}{{ '<video>\n' }}{% endfor %}{# Render all text next #}{% if message['role'] != 'assistant' %}{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}{{ content['text'] }}{% endfor %}{% else %}{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}{% generation %}{{ content['text'] }}{% endgeneration %}{% endfor %}{% endif %}{{'<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}"
-
-
-def load_original_state_dict(model_id):
-    directory_path = snapshot_download(repo_id=model_id, allow_patterns=["*.safetensors"])
-
-    original_state_dict = {}
-    for path in glob.glob(f"{directory_path}/*"):
-        if path.endswith(".safetensors"):
-            with safe_open(path, framework="pt", device="cpu") as f:
-                for key in f.keys():
-                    original_state_dict[key] = f.get_tensor(key)
-
-    # tied wieghts so lm.head is not saved. Let's clone to load state dict
-    if "lm_head.weight" not in original_state_dict:
-        original_state_dict["lm_head.weight"] = original_state_dict["model.embed_tokens.weight"].clone()
-
-    return original_state_dict
-
-
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if key.endswith(".inv_freq"):
-            continue
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        new_state_dict[key] = value.to(torch.float16)
-    return new_state_dict
-
-
-def load_image():
-    url = "https://github.com/haotian-liu/LLaVA/blob/1a91fc274d7c35a9b50b3cb29c4247ae5837ce39/images/llava_v1_5_radar.jpg?raw=true"
-    image = Image.open(requests.get(url, stream=True).raw)
-    return image
-
-
-def convert_llava_to_hf(model_id, pytorch_dump_folder_path, push_to_hub=False):
-    # load original config
-    filepath = hf_hub_download(repo_id=model_id, filename="config.json", repo_type="model")
-    # read json
-    with open(filepath) as f:
-        data = json.load(f)
-        print(data)
-
-    if model_id in ["lmms-lab/llava-onevision-qwen2-0.5b-ov", "lmms-lab/llava-onevision-qwen2-0.5b-si"]:
-        text_model_id = "Qwen/Qwen2-0.5B-Instruct"
-    elif model_id in [
-        "lmms-lab/llava-onevision-qwen2-7b-ov",
-        "lmms-lab/llava-onevision-qwen2-7b-si",
-        "lmms-lab/llava-onevision-qwen2-7b-ov-chat",
-    ]:
-        text_model_id = "Qwen/Qwen2-7B-Instruct"
-    elif model_id in [
-        "lmms-lab/llava-onevision-qwen2-72b-ov",
-        "lmms-lab/llava-onevision-qwen2-72b-si",
-        "lmms-lab/llava-onevision-qwen2-72b-ov-chat",
-    ]:
-        text_model_id = "Qwen/Qwen2-72B-Instruct"
-
-    vision_model_id = data["mm_vision_tower"]
-    torch.set_default_dtype(torch.float16)
-    text_config = AutoConfig.from_pretrained(text_model_id)
-
-    tokenizer = AutoTokenizer.from_pretrained(text_model_id, use_fast=True)
-    tokenizer.add_tokens(AddedToken("<image>", special=True, normalized=False), special_tokens=True)
-    tokenizer.add_tokens(AddedToken("<video>", special=True, normalized=False), special_tokens=True)
-
-    image_processor = LlavaOnevisionImageProcessor.from_pretrained(vision_model_id)
-    video_processor = LlavaOnevisionVideoProcessor.from_pretrained(vision_model_id)
-    processor = LlavaOnevisionProcessor(
-        tokenizer=tokenizer,
-        video_processor=video_processor,
-        image_processor=image_processor,
-        num_image_tokens=729,
-        vision_feature_select_strategy="full",
-        chat_template=chat_template,
-    )
-
-    vision_config = SiglipVisionConfig(
-        hidden_size=1152,
-        image_size=384,
-        intermediate_size=4304,
-        num_attention_heads=16,
-        num_hidden_layers=26,  # drop the last layer
-        patch_size=14,
-        vision_use_head=False,  # no head
-    ).to_dict()
-
-    config = LlavaOnevisionConfig(
-        text_config=text_config.to_dict(),
-        vision_config=vision_config,
-        use_image_newline_parameter=True,
-    )
-
-    with init_empty_weights():
-        model = LlavaOnevisionForConditionalGeneration(config)
-
-    # load original state dict
-    state_dict = load_original_state_dict(model_id)
-    state_dict = convert_state_dict_to_hf(state_dict)
-    model.load_state_dict(state_dict, assign=True)
-    model.eval()
-
-    pre_expansion_embeddings = model.language_model.model.embed_tokens.weight.data
-    mu = torch.mean(pre_expansion_embeddings, dim=0).float()
-    n = pre_expansion_embeddings.size()[0]
-    sigma = ((pre_expansion_embeddings - mu).T @ (pre_expansion_embeddings - mu)) / n
-    dist = torch.distributions.multivariate_normal.MultivariateNormal(mu, covariance_matrix=1e-5 * sigma)
-
-    # We add an image token so we resize the model
-    # Pad to 64 for performance reasons
-    # Qwen-based models have extra unused space in the vocab size already, so no need to resize
-    pad_shape = 64
-    vocab_size = config.text_config.vocab_size
-    num_tokens = vocab_size + 2
-    model.resize_token_embeddings(num_tokens, pad_to_multiple_of=pad_shape)
-    model.language_model.model.embed_tokens.weight.data[vocab_size:] = torch.stack(
-        tuple(
-            (dist.sample() for _ in range(model.language_model.model.embed_tokens.weight.data[vocab_size:].shape[0]))
-        ),
-        dim=0,
-    )
-    model.language_model.lm_head.weight.data[vocab_size:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.lm_head.weight.data[vocab_size:].shape[0]))),
-        dim=0,
-    )
-
-    print(f"Saving model and processor for {model_id} to {pytorch_dump_folder_path}")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-    processor.save_pretrained(pytorch_dump_folder_path)
-
-    # Make space so we can load the model properly now.
-    del state_dict
-    gc.collect()
-
-    # Load everything back for inference tests in float32 because prev script was written as that
-    # Though it's mostly loaded in fp16 as original weights are in fp16
-    model = LlavaOnevisionForConditionalGeneration.from_pretrained(
-        pytorch_dump_folder_path, torch_dtype="float16", device_map="auto"
-    )
-    processor = LlavaOnevisionProcessor.from_pretrained(pytorch_dump_folder_path)
-    device = model.device
-
-    # prepare inputs
-    image = load_image()
-    prompt = "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<image>\nWhat is shown in this image?<|im_end|>\n<|im_start|>assistant\n"
-    inputs = processor(images=image, text=prompt, return_tensors="pt").to(torch.float16)
-
-    # verify inputs
-    filepath = hf_hub_download(
-        repo_id="RaushanTurganbay/test-image", filename="llava_onevision_pixel_values.pt", repo_type="dataset"
-    )
-    original_pixel_values = torch.load(filepath, map_location="cpu")
-    assert torch.allclose(original_pixel_values, inputs.pixel_values.half())
-
-    image_sizes = torch.tensor([[899, 1024]])
-    assert image_sizes[0].tolist() == inputs.image_sizes[0].tolist()
-
-    # verify single forward pass
-    print("Single forward pass")
-    with torch.inference_mode():
-        inputs = inputs.to(device)
-        outputs = model(**inputs)
-        print("Shape of logits:", outputs.logits.shape)
-        print("First values of logits:", outputs.logits[0, :3, :3])
-
-        if model_id == "lmms-lab/llava-onevision-qwen2-0.5b-si":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[-12.1953, -14.6797, -12.7891], [0.5840, -0.8467, 1.3799], [3.6055, 4.5430, 9.9062]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-onevision-qwen2-0.5b-ov":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[-12.0234, -14.3828, -12.7500], [2.3594, 1.0000, 3.9336], [3.6582, 4.7148, 9.1172]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-onevision-qwen2-7b-si":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[1.7656, 3.3418, 1.4033], [0.0757, 0.7427, 3.5098], [6.7109, 5.6797, 9.3828]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-onevision-qwen2-7b-ov":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[1.8496, 3.4219, 1.3135], [3.0996, 3.0117, 3.1484], [4.2422, 4.7109, 9.9688]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-onevision-qwen2-72b-si":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[4.1875, 4.4883, 2.7910], [1.2949, 5.1328, 3.1582], [0.9390, 6.4531, 8.4375]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-onevision-qwen2-72b-ov":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[4.2930, 4.7305, 2.7363], [1.7529, 5.0742, 3.9590], [1.3936, 6.3438, 9.3984]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-onevision-qwen2-7b-ov-chat":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[1.8662, 3.4316, 1.3174], [2.7109, 2.5488, 3.0117], [4.4648, 4.9648, 10.3359]],
-                dtype=torch.float32,
-                device=device,
-            )
-        elif model_id == "lmms-lab/llava-onevision-qwen2-72b-ov-chat":
-            # Not yet checked against reference
-            expected_slice = torch.tensor(
-                [[4.3086, 4.7344, 2.6953], [1.7090, 5.1719, 4.0234], [1.3057, 6.3438, 9.5469]],
-                dtype=torch.float32,
-                device=device,
-            )
-        else:
-            raise ValueError(f"Model {model_id} not supported")
-
-        assert torch.allclose(outputs.logits[0, :3, :3], expected_slice, atol=1e-4)
-        print("Logits are ok!")
-
-    # verify generation
-    output_ids = model.generate(
-        **inputs,
-        max_new_tokens=100,
-        use_cache=True,
-    )
-
-    generated_text = processor.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
-
-    print("Generated text:", repr(generated_text))
-
-    if model_id == "lmms-lab/llava-onevision-qwen2-0.5b-si":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image is a radar chart that shows the performance of different algorithms or models in a specific domain, such as image classification or natural language processing. The chart is color-coded to represent different algorithms, with each color corresponding to a specific algorithm. The algorithms are labeled as BLIP-2, InstructBLIP, Owen-VL-Chat, and LLaVA-1.5. The chart also includes a legend at the bottom that explains the color coding and the algorithms represented."
-    elif model_id == "lmms-lab/llava-onevision-qwen2-0.5b-ov":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image is a radar chart that compares the performance of different models in a specific task, likely related to natural language processing or machine learning. The chart is divided into different categories, each represented by a different color and labeled with the name of the model or technique used. The models are evaluated based on their performance metrics, such as BLEU-2, InstructBLIP, Qwen-VL-Chat, and LLaVA-1.5. The radar chart helps to visualize the relative"
-    elif model_id == "lmms-lab/llava-onevision-qwen2-7b-si":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThis image is a radar chart that compares the performance of different models on various metrics. The models being compared are BLIP-2, InstructBLIP, and Qwen-VL-Chat. The metrics being compared are VQA, QA, GQA, VQA-av2, and VQA-av2. The chart shows that BLIP-2 performs the best on all metrics, followed by InstructBLIP and Qwen-VL-Chat."
-    elif model_id == "lmms-lab/llava-onevision-qwen2-7b-ov":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image shows a radar chart, also known as a spider chart or a star chart, which is used to compare multiple quantitative variables. Each axis represents a different variable, and the chart is filled with data points that represent the performance or values of different entities across these variables.\n\nIn this particular radar chart, the variables are represented on the axes, and the performance of different models or systems is shown by the lines connecting the data points. The models or systems are labeled along the bottom of the chart,"
-    elif model_id == "lmms-lab/llava-onevision-qwen2-72b-si":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image shows a radar chart, which is a graphical method of displaying multivariate data in the form of a two-dimensional chart of three or more quantitative variables represented on axes starting from the same point. The chart is used to compare the performance of different models or systems across various benchmarks or metrics.\n\nIn this specific radar chart, there are multiple axes, each representing a different benchmark or metric, such as VQA2, GQA, TextVQA, and others. The chart includes several colored lines"
-    elif model_id == "lmms-lab/llava-onevision-qwen2-72b-ov":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image is a radar chart comparing the performance of different models on various multimodal benchmarks. The models compared are BLIP-2, InstructBLIP, POPE, QWen-VL-Chat, and LLava-1.5. The benchmarks include VQAv2, GQA, TextVQA, SQA-IMG, VizWiz, MM-IMDb, MM-VQA, MM-IMDb-CN, MM-IMDb-EN, MM-"
-    elif model_id == "lmms-lab/llava-onevision-qwen2-7b-ov-chat":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image shows a radar chart, also known as a spider chart or a star chart, which is used to display multivariate data in the form of a two-dimensional chart of three or more quantitative variables represented on axes starting from the same point. Each axis represents a different variable, and the values are plotted along these axes.\n\nIn this particular radar chart, there are multiple lines representing different models or systems, each distinguished by a different color and labeled with a name such as BLIP-2, In"
-    elif model_id == "lmms-lab/llava-onevision-qwen2-72b-ov-chat":
-        expected_text = "system\nYou are a helpful assistant.\nuser\n\nWhat is shown in this image?\nassistant\nThe image is a radar chart comparing the performance of different models on various multimodal benchmarks. The models compared are BLIP-2, InstructBLIP, POPE, QWen-VL-Chat, and LLava-1.5. The benchmarks include VQAv2, GQA, TextVQA, SQA-IMG, VizWiz, MM-IMDb, MM-VQA, MM-IMDb-CN, MM-IMDb-EN, MM-"
-    else:
-        raise ValueError(f"Model {model_id} not supported")
-
-    assert generated_text == expected_text
-    print("Generated text is ok!")
-
-    # verify batched generation
-    print("Batched generation...")
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    cats_image = Image.open(requests.get(url, stream=True).raw)
-
-    inputs = processor(
-        images=[image, cats_image],
-        text=[prompt, prompt],
-        padding=True,
-        return_tensors="pt",
-    ).to(device, torch.float16)
-
-    for k, v in inputs.items():
-        print(k, v.shape)
-
-    print("Image sizes:", inputs.image_sizes)
-
-    # make sure image_sizes are the same
-    # as otherwise batched generation doesn't work
-    inputs.image_sizes[1] = inputs.image_sizes[0]
-
-    print("Batched generation...")
-    output_ids = model.generate(
-        **inputs,
-        max_new_tokens=20,
-        use_cache=True,
-    )
-
-    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
-    print(outputs)
-
-    if push_to_hub:
-        checkpoint_name = model_id.split("/")[-1]
-        print(f"Pushing to repo llava-hf/{checkpoint_name}-hf")
-        model.push_to_hub(f"llava-hf/{checkpoint_name}-hf")
-        processor.push_to_hub(f"llava-hf/{checkpoint_name}-hf")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model_id",
-        help="Hub location of the model to convert",
-        default="lmms-lab/llava-onevision-qwen2-0.5b-ov",
-        choices=[
-            "lmms-lab/llava-onevision-qwen2-0.5b-ov",
-            "lmms-lab/llava-onevision-qwen2-0.5b-si",
-            "lmms-lab/llava-onevision-qwen2-7b-si",
-            "lmms-lab/llava-onevision-qwen2-7b-ov",
-            "lmms-lab/llava-onevision-qwen2-72b-si",
-            "lmms-lab/llava-onevision-qwen2-72b-ov",
-            "lmms-lab/llava-onevision-qwen2-7b-ov-chat",
-            "lmms-lab/llava-onevision-qwen2-72b-ov-chat",
-        ],
-        required=False,
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", type=str, required=True, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-
-    convert_llava_to_hf(args.model_id, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/longformer/convert_longformer_original_pytorch_lightning_to_pytorch.py b/src/transformers/models/longformer/convert_longformer_original_pytorch_lightning_to_pytorch.py
deleted file mode 100644
index 4ef2131228b6..000000000000
--- a/src/transformers/models/longformer/convert_longformer_original_pytorch_lightning_to_pytorch.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RoBERTa checkpoint."""
-
-import argparse
-
-import pytorch_lightning as pl
-import torch
-from torch import nn
-
-from transformers import LongformerForQuestionAnswering, LongformerModel
-
-
-class LightningModel(pl.LightningModule):
-    def __init__(self, model):
-        super().__init__()
-        self.model = model
-        self.num_labels = 2
-        self.qa_outputs = nn.Linear(self.model.config.hidden_size, self.num_labels)
-
-    # implement only because lightning requires to do so
-    def forward(self):
-        pass
-
-
-def convert_longformer_qa_checkpoint_to_pytorch(
-    longformer_model: str, longformer_question_answering_ckpt_path: str, pytorch_dump_folder_path: str
-):
-    # load longformer model from model identifier
-    longformer = LongformerModel.from_pretrained(longformer_model)
-    lightning_model = LightningModel(longformer)
-
-    ckpt = torch.load(longformer_question_answering_ckpt_path, map_location=torch.device("cpu"))
-    lightning_model.load_state_dict(ckpt["state_dict"])
-
-    # init longformer question answering model
-    longformer_for_qa = LongformerForQuestionAnswering.from_pretrained(longformer_model)
-
-    # transfer weights
-    longformer_for_qa.longformer.load_state_dict(lightning_model.model.state_dict())
-    longformer_for_qa.qa_outputs.load_state_dict(lightning_model.qa_outputs.state_dict())
-    longformer_for_qa.eval()
-
-    # save model
-    longformer_for_qa.save_pretrained(pytorch_dump_folder_path)
-
-    print(f"Conversion successful. Model saved under {pytorch_dump_folder_path}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--longformer_model",
-        default=None,
-        type=str,
-        required=True,
-        help="model identifier of longformer. Should be either `longformer-base-4096` or `longformer-large-4096`.",
-    )
-    parser.add_argument(
-        "--longformer_question_answering_ckpt_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path the official PyTorch Lightning Checkpoint.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_longformer_qa_checkpoint_to_pytorch(
-        args.longformer_model, args.longformer_question_answering_ckpt_path, args.pytorch_dump_folder_path
-    )
diff --git a/src/transformers/models/longt5/convert_longt5x_checkpoint_to_flax.py b/src/transformers/models/longt5/convert_longt5x_checkpoint_to_flax.py
deleted file mode 100644
index cf5c2d52d8ea..000000000000
--- a/src/transformers/models/longt5/convert_longt5x_checkpoint_to_flax.py
+++ /dev/null
@@ -1,215 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert T5/LongT5X checkpoints from the original repository to JAX/FLAX model. This script is an extension of
-'src/transformers/models/t5/convert_t5x_checkpoint_to_flax.
-"""
-
-import argparse
-
-from t5x import checkpoints
-
-from transformers import AutoConfig, FlaxAutoModelForSeq2SeqLM
-
-
-def convert_t5x_checkpoint_to_flax(t5x_checkpoint_path, config_name, flax_dump_folder_path):
-    config = AutoConfig.from_pretrained(config_name)
-    flax_model = FlaxAutoModelForSeq2SeqLM.from_config(config=config)
-    t5x_model = checkpoints.load_t5x_checkpoint(t5x_checkpoint_path)
-
-    split_mlp_wi = "wi_0" in t5x_model["target"]["encoder"]["layers_0"]["mlp"]
-
-    if config.model_type == "t5":
-        encoder_attn_name = "SelfAttention"
-    if config.model_type == "longt5" and config.encoder_attention_type == "local":
-        encoder_attn_name = "LocalSelfAttention"
-    elif config.model_type == "longt5" and config.encoder_attention_type == "transient-global":
-        encoder_attn_name = "TransientGlobalSelfAttention"
-    else:
-        raise ValueError(
-            "Given config is expected to have `model_type='t5'`, or `model_type='longt5` with `encoder_attention_type`"
-            " attribute with a value from ['local', 'transient-global]."
-        )
-
-    # Encoder
-    for layer_index in range(config.num_layers):
-        layer_name = f"layers_{str(layer_index)}"
-
-        # Self-Attention
-        t5x_attention_key = t5x_model["target"]["encoder"][layer_name]["attention"]["key"]["kernel"]
-        t5x_attention_out = t5x_model["target"]["encoder"][layer_name]["attention"]["out"]["kernel"]
-        t5x_attention_query = t5x_model["target"]["encoder"][layer_name]["attention"]["query"]["kernel"]
-        t5x_attention_value = t5x_model["target"]["encoder"][layer_name]["attention"]["value"]["kernel"]
-
-        # Global input layer norm
-        if config.model_type == "longt5" and config.encoder_attention_type == "transient-global":
-            t5x_global_layer_norm = t5x_model["target"]["encoder"][layer_name]["attention"]["T5LayerNorm_0"]["scale"]
-
-        # Layer Normalization
-        t5x_attention_layer_norm = t5x_model["target"]["encoder"][layer_name]["pre_attention_layer_norm"]["scale"]
-
-        if split_mlp_wi:
-            t5x_mlp_wi_0 = t5x_model["target"]["encoder"][layer_name]["mlp"]["wi_0"]["kernel"]
-            t5x_mlp_wi_1 = t5x_model["target"]["encoder"][layer_name]["mlp"]["wi_1"]["kernel"]
-        else:
-            t5x_mlp_wi = t5x_model["target"]["encoder"][layer_name]["mlp"]["wi"]["kernel"]
-
-        t5x_mlp_wo = t5x_model["target"]["encoder"][layer_name]["mlp"]["wo"]["kernel"]
-
-        # Layer Normalization
-        t5x_mlp_layer_norm = t5x_model["target"]["encoder"][layer_name]["pre_mlp_layer_norm"]["scale"]
-
-        # Assigning
-        flax_model_encoder_layer_block = flax_model.params["encoder"]["block"][str(layer_index)]["layer"]
-        flax_model_encoder_layer_block["0"][encoder_attn_name]["k"]["kernel"] = t5x_attention_key
-        flax_model_encoder_layer_block["0"][encoder_attn_name]["o"]["kernel"] = t5x_attention_out
-        flax_model_encoder_layer_block["0"][encoder_attn_name]["q"]["kernel"] = t5x_attention_query
-        flax_model_encoder_layer_block["0"][encoder_attn_name]["v"]["kernel"] = t5x_attention_value
-
-        flax_model_encoder_layer_block["0"]["layer_norm"]["weight"] = t5x_attention_layer_norm
-
-        # Global input layer norm
-        if config.model_type == "longt5" and config.encoder_attention_type == "transient-global":
-            flax_model_encoder_layer_block["0"][encoder_attn_name]["global_input_layer_norm"]["weight"] = (
-                t5x_global_layer_norm
-            )
-
-        if split_mlp_wi:
-            flax_model_encoder_layer_block["1"]["DenseReluDense"]["wi_0"]["kernel"] = t5x_mlp_wi_0
-            flax_model_encoder_layer_block["1"]["DenseReluDense"]["wi_1"]["kernel"] = t5x_mlp_wi_1
-        else:
-            flax_model_encoder_layer_block["1"]["DenseReluDense"]["wi"]["kernel"] = t5x_mlp_wi
-
-        flax_model_encoder_layer_block["1"]["DenseReluDense"]["wo"]["kernel"] = t5x_mlp_wo
-        flax_model_encoder_layer_block["1"]["layer_norm"]["weight"] = t5x_mlp_layer_norm
-
-        flax_model.params["encoder"]["block"][str(layer_index)]["layer"] = flax_model_encoder_layer_block
-
-    # Only for layer 0:
-    t5x_encoder_rel_embedding = t5x_model["target"]["encoder"]["relpos_bias"]["rel_embedding"].T
-    flax_model.params["encoder"]["block"]["0"]["layer"]["0"][encoder_attn_name]["relative_attention_bias"][
-        "embedding"
-    ] = t5x_encoder_rel_embedding
-
-    # Side/global relative position_bias + layer norm
-    if config.model_type == "longt5" and config.encoder_attention_type == "transient-global":
-        t5x_encoder_global_rel_embedding = t5x_model["target"]["encoder"]["side_relpos_bias"]["rel_embedding"].T
-        flax_model.params["encoder"]["block"]["0"]["layer"]["0"][encoder_attn_name]["global_relative_attention_bias"][
-            "embedding"
-        ] = t5x_encoder_global_rel_embedding
-
-    # Assigning
-    t5x_encoder_norm = t5x_model["target"]["encoder"]["encoder_norm"]["scale"]
-    flax_model.params["encoder"]["final_layer_norm"]["weight"] = t5x_encoder_norm
-
-    # Decoder
-    for layer_index in range(config.num_layers):
-        layer_name = f"layers_{str(layer_index)}"
-
-        # Self-Attention
-        t5x_attention_key = t5x_model["target"]["decoder"][layer_name]["self_attention"]["key"]["kernel"]
-        t5x_attention_out = t5x_model["target"]["decoder"][layer_name]["self_attention"]["out"]["kernel"]
-        t5x_attention_query = t5x_model["target"]["decoder"][layer_name]["self_attention"]["query"]["kernel"]
-        t5x_attention_value = t5x_model["target"]["decoder"][layer_name]["self_attention"]["value"]["kernel"]
-
-        # Layer Normalization
-        t5x_pre_attention_layer_norm = t5x_model["target"]["decoder"][layer_name]["pre_self_attention_layer_norm"][
-            "scale"
-        ]
-
-        # Encoder-Decoder-Attention
-        t5x_enc_dec_attention_module = t5x_model["target"]["decoder"][layer_name]["encoder_decoder_attention"]
-        t5x_enc_dec_attention_key = t5x_enc_dec_attention_module["key"]["kernel"]
-        t5x_enc_dec_attention_out = t5x_enc_dec_attention_module["out"]["kernel"]
-        t5x_enc_dec_attention_query = t5x_enc_dec_attention_module["query"]["kernel"]
-        t5x_enc_dec_attention_value = t5x_enc_dec_attention_module["value"]["kernel"]
-
-        # Layer Normalization
-        t5x_cross_layer_norm = t5x_model["target"]["decoder"][layer_name]["pre_cross_attention_layer_norm"]["scale"]
-
-        # MLP
-        if split_mlp_wi:
-            t5x_mlp_wi_0 = t5x_model["target"]["decoder"][layer_name]["mlp"]["wi_0"]["kernel"]
-            t5x_mlp_wi_1 = t5x_model["target"]["decoder"][layer_name]["mlp"]["wi_1"]["kernel"]
-        else:
-            t5x_mlp_wi = t5x_model["target"]["decoder"][layer_name]["mlp"]["wi"]["kernel"]
-
-        t5x_mlp_wo = t5x_model["target"]["decoder"][layer_name]["mlp"]["wo"]["kernel"]
-
-        # Layer Normalization
-        tx5_mlp_layer_norm = t5x_model["target"]["decoder"][layer_name]["pre_mlp_layer_norm"]["scale"]
-
-        # Assigning
-        flax_model_decoder_layer_block = flax_model.params["decoder"]["block"][str(layer_index)]["layer"]
-        flax_model_decoder_layer_block["0"]["SelfAttention"]["k"]["kernel"] = t5x_attention_key
-        flax_model_decoder_layer_block["0"]["SelfAttention"]["o"]["kernel"] = t5x_attention_out
-        flax_model_decoder_layer_block["0"]["SelfAttention"]["q"]["kernel"] = t5x_attention_query
-        flax_model_decoder_layer_block["0"]["SelfAttention"]["v"]["kernel"] = t5x_attention_value
-
-        flax_model_decoder_layer_block["0"]["layer_norm"]["weight"] = t5x_pre_attention_layer_norm
-
-        flax_model_decoder_layer_block["1"]["EncDecAttention"]["k"]["kernel"] = t5x_enc_dec_attention_key
-        flax_model_decoder_layer_block["1"]["EncDecAttention"]["o"]["kernel"] = t5x_enc_dec_attention_out
-        flax_model_decoder_layer_block["1"]["EncDecAttention"]["q"]["kernel"] = t5x_enc_dec_attention_query
-        flax_model_decoder_layer_block["1"]["EncDecAttention"]["v"]["kernel"] = t5x_enc_dec_attention_value
-
-        flax_model_decoder_layer_block["1"]["layer_norm"]["weight"] = t5x_cross_layer_norm
-
-        if split_mlp_wi:
-            flax_model_decoder_layer_block["2"]["DenseReluDense"]["wi_0"]["kernel"] = t5x_mlp_wi_0
-            flax_model_decoder_layer_block["2"]["DenseReluDense"]["wi_1"]["kernel"] = t5x_mlp_wi_1
-        else:
-            flax_model_decoder_layer_block["2"]["DenseReluDense"]["wi"]["kernel"] = t5x_mlp_wi
-
-        flax_model_decoder_layer_block["2"]["DenseReluDense"]["wo"]["kernel"] = t5x_mlp_wo
-
-        flax_model_decoder_layer_block["2"]["layer_norm"]["weight"] = tx5_mlp_layer_norm
-
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"] = flax_model_decoder_layer_block
-
-    # Decoder Normalization
-    tx5_decoder_norm = t5x_model["target"]["decoder"]["decoder_norm"]["scale"]
-    flax_model.params["decoder"]["final_layer_norm"]["weight"] = tx5_decoder_norm
-
-    # Only for layer 0:
-    t5x_decoder_rel_embedding = t5x_model["target"]["decoder"]["relpos_bias"]["rel_embedding"].T
-    flax_model.params["decoder"]["block"]["0"]["layer"]["0"]["SelfAttention"]["relative_attention_bias"][
-        "embedding"
-    ] = t5x_decoder_rel_embedding
-
-    # Token Embeddings
-    tx5_token_embeddings = t5x_model["target"]["token_embedder"]["embedding"]
-    flax_model.params["shared"]["embedding"] = tx5_token_embeddings
-
-    # LM Head (only in v1.1 and LongT5 checkpoints)
-    if "logits_dense" in t5x_model["target"]["decoder"]:
-        flax_model.params["lm_head"]["kernel"] = t5x_model["target"]["decoder"]["logits_dense"]["kernel"]
-
-    flax_model.save_pretrained(flax_dump_folder_path)
-    print("T5X Model was sucessfully converted!")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--t5x_checkpoint_path", default=None, type=str, required=True, help="Path the T5X checkpoint."
-    )
-    parser.add_argument("--config_name", default=None, type=str, required=True, help="Config name of LongT5/T5 model.")
-    parser.add_argument(
-        "--flax_dump_folder_path", default=None, type=str, required=True, help="Path to the output FLAX model."
-    )
-    args = parser.parse_args()
-    convert_t5x_checkpoint_to_flax(args.t5x_checkpoint_path, args.config_name, args.flax_dump_folder_path)
diff --git a/src/transformers/models/luke/convert_luke_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/luke/convert_luke_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index c86fa6e30890..000000000000
--- a/src/transformers/models/luke/convert_luke_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,170 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert LUKE checkpoint."""
-
-import argparse
-import json
-import os
-
-import torch
-
-from transformers import LukeConfig, LukeModel, LukeTokenizer, RobertaTokenizer
-from transformers.tokenization_utils_base import AddedToken
-
-
-@torch.no_grad()
-def convert_luke_checkpoint(checkpoint_path, metadata_path, entity_vocab_path, pytorch_dump_folder_path, model_size):
-    # Load configuration defined in the metadata file
-    with open(metadata_path) as metadata_file:
-        metadata = json.load(metadata_file)
-    config = LukeConfig(use_entity_aware_attention=True, **metadata["model_config"])
-
-    # Load in the weights from the checkpoint_path
-    state_dict = torch.load(checkpoint_path, map_location="cpu")
-
-    # Load the entity vocab file
-    entity_vocab = load_entity_vocab(entity_vocab_path)
-
-    tokenizer = RobertaTokenizer.from_pretrained(metadata["model_config"]["bert_model_name"])
-
-    # Add special tokens to the token vocabulary for downstream tasks
-    entity_token_1 = AddedToken("<ent>", lstrip=False, rstrip=False)
-    entity_token_2 = AddedToken("<ent2>", lstrip=False, rstrip=False)
-    tokenizer.add_special_tokens({"additional_special_tokens": [entity_token_1, entity_token_2]})
-    config.vocab_size += 2
-
-    print(f"Saving tokenizer to {pytorch_dump_folder_path}")
-    tokenizer.save_pretrained(pytorch_dump_folder_path)
-    with open(os.path.join(pytorch_dump_folder_path, LukeTokenizer.vocab_files_names["entity_vocab_file"]), "w") as f:
-        json.dump(entity_vocab, f)
-
-    tokenizer = LukeTokenizer.from_pretrained(pytorch_dump_folder_path)
-
-    # Initialize the embeddings of the special tokens
-    word_emb = state_dict["embeddings.word_embeddings.weight"]
-    ent_emb = word_emb[tokenizer.convert_tokens_to_ids(["@"])[0]].unsqueeze(0)
-    ent2_emb = word_emb[tokenizer.convert_tokens_to_ids(["#"])[0]].unsqueeze(0)
-    state_dict["embeddings.word_embeddings.weight"] = torch.cat([word_emb, ent_emb, ent2_emb])
-
-    # Initialize the query layers of the entity-aware self-attention mechanism
-    for layer_index in range(config.num_hidden_layers):
-        for matrix_name in ["query.weight", "query.bias"]:
-            prefix = f"encoder.layer.{layer_index}.attention.self."
-            state_dict[prefix + "w2e_" + matrix_name] = state_dict[prefix + matrix_name]
-            state_dict[prefix + "e2w_" + matrix_name] = state_dict[prefix + matrix_name]
-            state_dict[prefix + "e2e_" + matrix_name] = state_dict[prefix + matrix_name]
-
-    # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks
-    entity_emb = state_dict["entity_embeddings.entity_embeddings.weight"]
-    entity_emb[entity_vocab["[MASK2]"]] = entity_emb[entity_vocab["[MASK]"]]
-
-    model = LukeModel(config=config).eval()
-
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    if not (len(missing_keys) == 1 and missing_keys[0] == "embeddings.position_ids"):
-        raise ValueError(f"Missing keys {', '.join(missing_keys)}. Expected only missing embeddings.position_ids")
-    if not (all(key.startswith("entity_predictions") or key.startswith("lm_head") for key in unexpected_keys)):
-        raise ValueError(
-            "Unexpected keys"
-            f" {', '.join([key for key in unexpected_keys if not (key.startswith('entity_predictions') or key.startswith('lm_head'))])}"
-        )
-
-    # Check outputs
-    tokenizer = LukeTokenizer.from_pretrained(pytorch_dump_folder_path, task="entity_classification")
-
-    text = (
-        "Top seed Ana Ivanovic said on Thursday she could hardly believe her luck as a fortuitous netcord helped the"
-        " new world number one avoid a humiliating second- round exit at Wimbledon ."
-    )
-    span = (39, 42)
-    encoding = tokenizer(text, entity_spans=[span], add_prefix_space=True, return_tensors="pt")
-
-    outputs = model(**encoding)
-
-    # Verify word hidden states
-    if model_size == "large":
-        expected_shape = torch.Size((1, 42, 1024))
-        expected_slice = torch.tensor(
-            [[0.0133, 0.0865, 0.0095], [0.3093, -0.2576, -0.7418], [-0.1720, -0.2117, -0.2869]]
-        )
-    else:  # base
-        expected_shape = torch.Size((1, 42, 768))
-        expected_slice = torch.tensor([[0.0037, 0.1368, -0.0091], [0.1099, 0.3329, -0.1095], [0.0765, 0.5335, 0.1179]])
-
-    if not (outputs.last_hidden_state.shape == expected_shape):
-        raise ValueError(
-            f"Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}"
-        )
-    if not torch.allclose(outputs.last_hidden_state[0, :3, :3], expected_slice, atol=1e-4):
-        raise ValueError
-
-    # Verify entity hidden states
-    if model_size == "large":
-        expected_shape = torch.Size((1, 1, 1024))
-        expected_slice = torch.tensor([[0.0466, -0.0106, -0.0179]])
-    else:  # base
-        expected_shape = torch.Size((1, 1, 768))
-        expected_slice = torch.tensor([[0.1457, 0.1044, 0.0174]])
-
-    if not (outputs.entity_last_hidden_state.shape != expected_shape):
-        raise ValueError(
-            f"Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is"
-            f" {expected_shape}"
-        )
-    if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3], expected_slice, atol=1e-4):
-        raise ValueError
-
-    # Finally, save our PyTorch model and tokenizer
-    print("Saving PyTorch model to {}".format(pytorch_dump_folder_path))
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-def load_entity_vocab(entity_vocab_path):
-    entity_vocab = {}
-    with open(entity_vocab_path, "r", encoding="utf-8") as f:
-        for index, line in enumerate(f):
-            title, _ = line.rstrip().split("\t")
-            entity_vocab[title] = index
-
-    return entity_vocab
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("--checkpoint_path", type=str, help="Path to a pytorch_model.bin file.")
-    parser.add_argument(
-        "--metadata_path", default=None, type=str, help="Path to a metadata.json file, defining the configuration."
-    )
-    parser.add_argument(
-        "--entity_vocab_path",
-        default=None,
-        type=str,
-        help="Path to an entity_vocab.tsv file, containing the entity vocabulary.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to where to dump the output PyTorch model."
-    )
-    parser.add_argument(
-        "--model_size", default="base", type=str, choices=["base", "large"], help="Size of the model to be converted."
-    )
-    args = parser.parse_args()
-    convert_luke_checkpoint(
-        args.checkpoint_path,
-        args.metadata_path,
-        args.entity_vocab_path,
-        args.pytorch_dump_folder_path,
-        args.model_size,
-    )
diff --git a/src/transformers/models/lxmert/convert_lxmert_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/lxmert/convert_lxmert_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index 1dd77bc36f80..000000000000
--- a/src/transformers/models/lxmert/convert_lxmert_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert LXMERT checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = LxmertConfig.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = LxmertForPreTraining(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_lxmert(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/m2m_100/convert_m2m100_original_checkpoint_to_pytorch.py b/src/transformers/models/m2m_100/convert_m2m100_original_checkpoint_to_pytorch.py
deleted file mode 100644
index 97265fbdcf93..000000000000
--- a/src/transformers/models/m2m_100/convert_m2m100_original_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# Copyright 2021 The Fairseq Authors and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import torch
-from torch import nn
-
-from transformers import M2M100Config, M2M100ForConditionalGeneration
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = [
-        "encoder.version",
-        "decoder.version",
-        "model.encoder.version",
-        "model.decoder.version",
-        "decoder.output_projection.weight",
-        "_float_tensor",
-        "encoder.embed_positions._float_tensor",
-        "decoder.embed_positions._float_tensor",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-def convert_fairseq_m2m100_checkpoint_from_disk(checkpoint_path):
-    m2m_100 = torch.load(checkpoint_path, map_location="cpu")
-    args = m2m_100["args"] or m2m_100["cfg"]["model"]
-    state_dict = m2m_100["model"]
-    remove_ignore_keys_(state_dict)
-    vocab_size = state_dict["encoder.embed_tokens.weight"].shape[0]
-
-    config = M2M100Config(
-        vocab_size=vocab_size,
-        max_position_embeddings=1024,
-        encoder_layers=args.encoder_layers,
-        decoder_layers=args.decoder_layers,
-        encoder_attention_heads=args.encoder_attention_heads,
-        decoder_attention_heads=args.decoder_attention_heads,
-        encoder_ffn_dim=args.encoder_ffn_embed_dim,
-        decoder_ffn_dim=args.decoder_ffn_embed_dim,
-        d_model=args.encoder_embed_dim,
-        encoder_layerdrop=args.encoder_layerdrop,
-        decoder_layerdrop=args.decoder_layerdrop,
-        dropout=args.dropout,
-        attention_dropout=args.attention_dropout,
-        activation_dropout=args.activation_dropout,
-        activation_function="relu",
-    )
-
-    state_dict["shared.weight"] = state_dict["decoder.embed_tokens.weight"]
-    model = M2M100ForConditionalGeneration(config)
-    model.model.load_state_dict(state_dict, strict=False)
-    model.lm_head = make_linear_from_emb(model.model.shared)
-
-    return model
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("fairseq_path", type=str, help="path to a model.pt on local filesystem.")
-    parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    args = parser.parse_args()
-    model = convert_fairseq_m2m100_checkpoint_from_disk(args.fairseq_pathß)
-    model.save_pretrained(args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/mamba/convert_mamba_ssm_checkpoint_to_pytorch.py b/src/transformers/models/mamba/convert_mamba_ssm_checkpoint_to_pytorch.py
deleted file mode 100644
index 0cf7dcc0edaf..000000000000
--- a/src/transformers/models/mamba/convert_mamba_ssm_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,153 +0,0 @@
-# coding=utf-8
-# Copyright 2024 state-spaces/mamba org and HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""This script can be used to convert checkpoints provided in the `mamba_ssm` library into the format provided in HuggingFace `transformers`. It depends on the `mamba_ssm` package to be installed."""
-
-import argparse
-import json
-import math
-from typing import Tuple
-
-import torch
-
-from transformers import AutoTokenizer, MambaConfig, MambaForCausalLM
-from transformers.utils import logging
-from transformers.utils.import_utils import is_mamba_ssm_available
-
-
-if is_mamba_ssm_available():
-    from mamba_ssm.models.config_mamba import MambaConfig as MambaConfigSSM
-    from mamba_ssm.models.mixer_seq_simple import MambaLMHeadModel
-
-    def convert_ssm_config_to_hf_config(config_ssm: MambaConfigSSM) -> MambaConfig:
-        """Convert a MambaConfig from mamba_ssm to a MambaConfig from transformers."""
-        hf_config = MambaConfig()
-        # Set config hidden size, num hidden layers, and vocab size directly from the original config
-        hf_config.hidden_size = config_ssm.d_model
-        hf_config.intermediate_size = config_ssm.d_model * 2
-        hf_config.time_step_rank = math.ceil(config_ssm.d_model / 16)
-
-        hf_config.num_hidden_layers = config_ssm.n_layer
-        vocab_size = config_ssm.vocab_size
-        pad_vocab_size_multiple = config_ssm.pad_vocab_size_multiple
-        if (vocab_size % pad_vocab_size_multiple) != 0:
-            vocab_size += pad_vocab_size_multiple - (vocab_size % pad_vocab_size_multiple)
-        hf_config.vocab_size = vocab_size
-        return hf_config
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def convert_mamba_ssm_checkpoint_to_huggingface_model(
-    original_state_dict: dict, original_ssm_config_dict: dict
-) -> Tuple[MambaForCausalLM, AutoTokenizer]:
-    if not is_mamba_ssm_available():
-        raise ImportError(
-            "Calling convert_mamba_ssm_checkpoint_to_huggingface_model requires the mamba_ssm library to be installed. Please install it with `pip install mamba_ssm`."
-        )
-    original_ssm_config = MambaConfigSSM(**original_ssm_config_dict)
-
-    # Convert mamba_ssm config to huggingface MambaConfig
-    hf_config = convert_ssm_config_to_hf_config(original_ssm_config)
-
-    # No weights need to be renamed between the two models.
-    converted_state_dict = original_state_dict
-
-    # Load reshaped state dict into a huggingface model.
-    hf_model = MambaForCausalLM(hf_config)
-    tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b")
-    hf_model.load_state_dict(converted_state_dict)
-    return (hf_model, tokenizer)
-
-
-def validate_converted_model(
-    original_state_dict: dict, original_ssm_config_dict: dict, hf_model: MambaForCausalLM, tokenizer: AutoTokenizer
-) -> None:
-    """Validate the converted model returns the same output as the original model."""
-    torch_device = "cuda"
-
-    original_config = MambaConfigSSM(**original_ssm_config_dict)
-    original_model = MambaLMHeadModel(original_config).to(torch_device)
-    original_model.load_state_dict(original_state_dict)
-
-    hf_model = hf_model.to(torch_device)
-    input_ids = tokenizer("Hey how are you doing?", return_tensors="pt")["input_ids"].to(torch_device)
-    # Assert model logits are close
-    with torch.no_grad():
-        original_model_logits = original_model(input_ids).logits
-        hf_model_logits = hf_model(input_ids).logits
-    if not torch.allclose(original_model_logits, hf_model_logits, atol=1e-3):
-        raise ValueError("The converted model did not return the same logits as the original model.")
-
-    logger.info("Model conversion validated successfully.")
-
-
-def convert_mamba_checkpoint_file_to_huggingface_model_file(
-    mamba_checkpoint_path: str, config_json_file: str, output_dir: str
-) -> None:
-    if not is_mamba_ssm_available():
-        raise ImportError(
-            "Calling convert_mamba_checkpoint_file_to_huggingface_model_file requires the mamba_ssm library to be installed. Please install it with `pip install mamba_ssm`."
-        )
-    if not torch.cuda.is_available():
-        raise ValueError(
-            "This script is to be run with a CUDA device, as the original mamba_ssm model does not support cpu."
-        )
-    logger.info(f"Loading model from {mamba_checkpoint_path} based on config from {config_json_file}")
-    # Load weights and config from paths
-    original_state_dict = torch.load(mamba_checkpoint_path, map_location="cpu")
-    with open(config_json_file, "r", encoding="utf-8") as json_file:
-        original_ssm_config_dict = json.load(json_file)
-
-    # Convert the model
-    hf_model, tokenizer = convert_mamba_ssm_checkpoint_to_huggingface_model(
-        original_state_dict, original_ssm_config_dict
-    )
-
-    # Validate the conversion
-    validate_converted_model(original_state_dict, original_ssm_config_dict, hf_model, tokenizer)
-
-    logger.info(f"Model converted successfully. Saving model to {output_dir}")
-
-    # Save new model to pytorch_dump_path
-    hf_model.save_pretrained(output_dir)
-    tokenizer.save_pretrained(output_dir)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-i",
-        "--mamba_checkpoint_file",
-        type=str,
-        required=True,
-        help="Path to a `pytorch_model.bin` mamba_ssm checkpoint file to be converted.",
-    )
-    parser.add_argument(
-        "-c",
-        "--config_json_file",
-        type=str,
-        required=True,
-        help="Path to a `config.json` file corresponding to a MambaConfig of the original mamba_ssm model.",
-    )
-    parser.add_argument(
-        "-o", "--output_dir", type=str, required=True, help="Path to directory to save the converted output model to."
-    )
-    args = parser.parse_args()
-
-    convert_mamba_checkpoint_file_to_huggingface_model_file(
-        args.mamba_checkpoint_file, args.config_json_file, args.output_dir
-    )
diff --git a/src/transformers/models/mamba2/convert_mamba2_ssm_checkpoint_to_pytorch.py b/src/transformers/models/mamba2/convert_mamba2_ssm_checkpoint_to_pytorch.py
deleted file mode 100644
index f68e9bd4904b..000000000000
--- a/src/transformers/models/mamba2/convert_mamba2_ssm_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,193 +0,0 @@
-# coding=utf-8
-# Copyright 2024 state-spaces/mamba2 org and HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""This script can be used to convert checkpoints provided in the `mamba2_ssm` library into the format provided in HuggingFace `transformers`. It depends on the `mamba2_ssm` package to be installed."""
-
-import argparse
-import json
-from functools import partial
-from os import path
-from typing import Dict, Optional
-
-import torch
-from safetensors import safe_open
-from safetensors.torch import save_model
-
-from transformers import GPTNeoXTokenizerFast, LlamaTokenizerFast, Mamba2Config, Mamba2ForCausalLM
-
-
-def load_state_dict_from_safetensors(mamba2_checkpoint_path: str, ckpt_name: str) -> Dict[str, torch.Tensor]:
-    # Load weights and config from paths
-    original_state_dict = {}
-    with safe_open(path.join(mamba2_checkpoint_path, ckpt_name), framework="pt") as f:
-        for k in f.keys():
-            newk = k.removeprefix("model.")
-            original_state_dict[newk] = f.get_tensor(k).clone()
-    return original_state_dict
-
-
-def load_state_dict_from_torch(mamba2_checkpoint_path: str, ckpt_name: str) -> Dict[str, torch.Tensor]:
-    return torch.load(path.join(mamba2_checkpoint_path, ckpt_name), map_location="cpu")
-
-
-def convert_ssm_config_to_hf_config(config_ssm: Dict, mamba2_model_dict: Dict) -> Mamba2Config:
-    """Convert a Mamba2Config from mamba_ssm to a Mamba2Config from here."""
-    hf_config = Mamba2Config()
-
-    # Switch to a different dict depending on model type
-    config_dict = mamba2_model_dict
-
-    # Set important values from config and recalculate other resulting entries
-    hf_config.hidden_size = config_ssm[config_dict["hidden_size"]]
-    hf_config.num_heads = (hf_config.hidden_size * hf_config.expand) // hf_config.head_dim
-    hf_config.num_hidden_layers = config_ssm[config_dict["num_hidden_layers"]]
-    hf_config.n_groups = config_ssm.get(config_dict["n_groups"], 1)
-    hf_config.tie_word_embeddings = config_ssm["tie_embeddings"]
-    hf_config.bos_token_id = config_dict["bos_token_id"]
-    hf_config.pad_token_id = config_dict["pad_token_id"]
-    hf_config.eos_token_id = config_dict["eos_token_id"]
-
-    # Padded vocab size, mostly of 16 but 32 is also very common in different models
-    vocab_size = config_ssm["vocab_size"]
-    pad_vocab_size_multiple = config_ssm["pad_vocab_size_multiple"]
-    if (vocab_size % pad_vocab_size_multiple) != 0:
-        vocab_size += pad_vocab_size_multiple - (vocab_size % pad_vocab_size_multiple)
-    hf_config.vocab_size = vocab_size
-
-    return hf_config
-
-
-def load_and_save_tokenizer(
-    mamba2_model_type: str,
-    output_dir: str,
-    tokenizer_model_path: Optional[str] = None,
-) -> None:
-    tokenizer = None
-
-    # Load tokenizer
-    if tokenizer_model_path is not None and mamba2_model_type == "codestral":
-        tokenizer_class = LlamaTokenizerFast
-        tokenizer = tokenizer_class(tokenizer_model_path, legacy=False, from_slow=True)
-    elif mamba2_model_type == "mamba_ssm":
-        tokenizer = GPTNeoXTokenizerFast.from_pretrained("state-spaces/mamba-130m-hf", padding_side="left")
-
-    # Save tokenizer
-    if tokenizer is not None:
-        tokenizer.save_pretrained(output_dir)
-
-
-_MAMBA2_MODELS_DICT = {
-    "codestral": {
-        "hidden_size": "dim",
-        "num_hidden_layers": "n_layers",
-        "n_groups": "n_groups",
-        "bos_token_id": 0,
-        "pad_token_id": 1,
-        "eos_token_id": 2,
-        "config_name": "params.json",
-        "load_state_dict": partial(load_state_dict_from_safetensors, ckpt_name="consolidated.safetensors"),
-        "load_and_save_tokenizer": partial(load_and_save_tokenizer, "codestral"),
-    },
-    "mamba_ssm": {
-        "hidden_size": "d_model",
-        "num_hidden_layers": "n_layer",
-        "n_groups": "ngroups",
-        "bos_token_id": 0,
-        "pad_token_id": 0,
-        "eos_token_id": 0,
-        "config_name": "config.json",
-        "load_state_dict": partial(load_state_dict_from_torch, ckpt_name="pytorch_model.bin"),
-        "load_and_save_tokenizer": partial(load_and_save_tokenizer, "mamba_ssm"),
-    },
-}
-
-
-def convert_mamba2_checkpoint_file_to_huggingface_model_file(
-    mamba2_checkpoint_path: str,
-    mamba2_model_type: str,
-    precision: str,
-    output_dir: str,
-    tokenizer_model_path: Optional[str] = None,
-) -> None:
-    mamba2_model_dict = _MAMBA2_MODELS_DICT[mamba2_model_type]
-
-    # Load and save config based on name
-    config_path = path.join(mamba2_checkpoint_path, mamba2_model_dict["config_name"])
-    with open(config_path, "r", encoding="utf-8") as json_file:
-        config = json.load(json_file)
-    hf_config = convert_ssm_config_to_hf_config(config_ssm=config, mamba2_model_dict=mamba2_model_dict)
-    hf_config.save_pretrained(output_dir)
-
-    # Load state dict of the original model and transfer to hf model
-    original_state_dict = mamba2_model_dict["load_state_dict"](mamba2_checkpoint_path=mamba2_checkpoint_path)
-    hf_model = Mamba2ForCausalLM(hf_config)
-    hf_model.load_state_dict(original_state_dict)
-
-    # Save new model to pytorch_dump_path
-    dtype = torch.float32 if precision == "fp32" else (torch.bfloat16 if precision == "bf16" else torch.float16)
-    save_model(hf_model.to(dtype), path.join(output_dir, "model.safetensors"), metadata={"format": "pt"})
-
-    # Load and save tokenizer
-    mamba2_model_dict["load_and_save_tokenizer"](output_dir=output_dir, tokenizer_model_path=tokenizer_model_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-i",
-        "--mamba2_checkpoint_directory",
-        type=str,
-        required=True,
-        help="Path to a directory containing the `pytorch_model.bin` or `.safetensors` mamba2_ssm checkpoint file to be converted.",
-    )
-    parser.add_argument(
-        "-m",
-        "--mamba2_model_type",
-        type=str,
-        default="mamba_ssm",
-        const="mamba_ssm",
-        required=True,
-        choices=("codestral", "mamba_ssm"),
-        help="The model type the conversion will be performed on. Can choose from either `codestral` or `mamba_ssm`.",
-    )
-    parser.add_argument(
-        "-p",
-        "--precision",
-        type=str,
-        default="fp16",
-        const="fp16",
-        required=True,
-        choices=("fp32", "fp16", "bf16"),
-        help="The precision the model will be saved in. Select from fp32, fp16 or bf16.",
-    )
-    parser.add_argument(
-        "-o", "--output_dir", type=str, required=True, help="Path to directory to save the converted output model to."
-    )
-    parser.add_argument(
-        "-t",
-        "--tokenizer_model_path",
-        type=str,
-        default=None,
-        required=False,
-        help="Path to a `codestral` tokenizer file.",
-    )
-    args = parser.parse_args()
-
-    convert_mamba2_checkpoint_file_to_huggingface_model_file(
-        args.mamba2_checkpoint_directory,
-        args.mamba2_model_type,
-        args.precision,
-        args.output_dir,
-        args.tokenizer_model_path,
-    )
diff --git a/src/transformers/models/marian/convert_marian_tatoeba_to_pytorch.py b/src/transformers/models/marian/convert_marian_tatoeba_to_pytorch.py
deleted file mode 100644
index 6181e94c60a3..000000000000
--- a/src/transformers/models/marian/convert_marian_tatoeba_to_pytorch.py
+++ /dev/null
@@ -1,1327 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import datetime
-import json
-import os
-import re
-from pathlib import Path
-from typing import Tuple
-
-import yaml
-from tqdm import tqdm
-
-from transformers.models.marian.convert_marian_to_pytorch import (
-    FRONT_MATTER_TEMPLATE,
-    convert,
-    convert_opus_name_to_hf_name,
-    download_and_unzip,
-    get_system_metadata,
-)
-
-
-DEFAULT_REPO = "Tatoeba-Challenge"
-DEFAULT_MODEL_DIR = os.path.join(DEFAULT_REPO, "models")
-ISO_URL = "https://cdn-datasets.huggingface.co/language_codes/iso-639-3.csv"
-ISO_PATH = "lang_code_data/iso-639-3.csv"
-LANG_CODE_PATH = "lang_code_data/language-codes-3b2.csv"
-TATOEBA_MODELS_URL = "https://object.pouta.csc.fi/Tatoeba-MT-models"
-
-
-class TatoebaConverter:
-    """
-    Convert Tatoeba-Challenge models to huggingface format.
-
-    Steps:
-
-        1. Convert numpy state dict to hf format (same code as OPUS-MT-Train conversion).
-        2. Rename opus model to huggingface format. This means replace each alpha3 code with an alpha2 code if a unique
-           one exists. e.g. aav-eng -> aav-en, heb-eng -> he-en
-        3. Select the best model for a particular pair, parse the yml for it and write a model card. By default the
-           best model is the one listed first in released-model-results, but it's also possible to specify the most
-           recent one.
-    """
-
-    def __init__(self, save_dir="marian_converted"):
-        assert Path(DEFAULT_REPO).exists(), "need git clone git@github.com:Helsinki-NLP/Tatoeba-Challenge.git"
-        self.download_lang_info()
-        self.model_results = json.load(open("Tatoeba-Challenge/models/released-model-results.json"))
-        self.alpha3_to_alpha2 = {}
-        for line in open(ISO_PATH):
-            parts = line.split("\t")
-            if len(parts[0]) == 3 and len(parts[3]) == 2:
-                self.alpha3_to_alpha2[parts[0]] = parts[3]
-        for line in LANG_CODE_PATH:
-            parts = line.split(",")
-            if len(parts[0]) == 3 and len(parts[1]) == 2:
-                self.alpha3_to_alpha2[parts[0]] = parts[1]
-        self.model_card_dir = Path(save_dir)
-        self.tag2name = {}
-        for key, value in GROUP_MEMBERS.items():
-            self.tag2name[key] = value[0]
-
-    def convert_models(self, tatoeba_ids, dry_run=False):
-        models_to_convert = [self.parse_metadata(x) for x in tatoeba_ids]
-        save_dir = Path("marian_ckpt")
-        dest_dir = Path(self.model_card_dir)
-        dest_dir.mkdir(exist_ok=True)
-        for model in tqdm(models_to_convert):  # k, prepro, download, test_set_url in tqdm(model_list):
-            if "SentencePiece" not in model["pre-processing"]:
-                print(f"Skipping {model['release']} because it doesn't appear to use SentencePiece")
-                continue
-            if not os.path.exists(save_dir / model["_name"]):
-                download_and_unzip(f"{TATOEBA_MODELS_URL}/{model['release']}", save_dir / model["_name"])
-            # from convert_marian_to_pytorch
-            opus_language_groups_to_hf = convert_opus_name_to_hf_name
-            pair_name = opus_language_groups_to_hf(model["_name"])
-            convert(save_dir / model["_name"], dest_dir / f"opus-mt-{pair_name}")
-            self.write_model_card(model, dry_run=dry_run)
-
-    def expand_group_to_two_letter_codes(self, grp_name):
-        return [self.alpha3_to_alpha2.get(x, x) for x in GROUP_MEMBERS[grp_name][1]]
-
-    def is_group(self, code, name):
-        return "languages" in name or len(GROUP_MEMBERS.get(code, [])) > 1
-
-    def get_tags(self, code, name):
-        if len(code) == 2:
-            assert "languages" not in name, f"{code}: {name}"
-            return [code]
-        elif self.is_group(code, name):
-            group = self.expand_group_to_two_letter_codes(code)
-            group.append(code)
-            return group
-        else:  # zho-> zh
-            print(f"Three letter monolingual code: {code}")
-            return [code]
-
-    def resolve_lang_code(self, src, tgt) -> Tuple[str, str]:
-        src_tags = self.get_tags(src, self.tag2name[src])
-        tgt_tags = self.get_tags(tgt, self.tag2name[tgt])
-        return src_tags, tgt_tags
-
-    @staticmethod
-    def model_type_info_from_model_name(name):
-        info = {"_has_backtranslated_data": False}
-        if "1m" in name:
-            info["_data_per_pair"] = str(1e6)
-        if "2m" in name:
-            info["_data_per_pair"] = str(2e6)
-        if "4m" in name:
-            info["_data_per_pair"] = str(4e6)
-        if "+bt" in name:
-            info["_has_backtranslated_data"] = True
-        if "tuned4" in name:
-            info["_tuned"] = re.search(r"tuned4[^-]+", name).group()
-        return info
-
-    def write_model_card(self, model_dict, dry_run=False) -> str:
-        """
-        Construct card from data parsed from YAML and the model's name. upload command: aws s3 sync model_card_dir
-        s3://models.huggingface.co/bert/Helsinki-NLP/ --dryrun
-        """
-        model_dir_url = f"{TATOEBA_MODELS_URL}/{model_dict['release']}"
-        long_pair = model_dict["_name"].split("-")
-        assert len(long_pair) == 2, f"got a translation pair {model_dict['_name']} that doesn't appear to be a pair"
-        short_src = self.alpha3_to_alpha2.get(long_pair[0], long_pair[0])
-        short_tgt = self.alpha3_to_alpha2.get(long_pair[1], long_pair[1])
-        model_dict["_hf_model_id"] = f"opus-mt-{short_src}-{short_tgt}"
-
-        a3_src, a3_tgt = model_dict["_name"].split("-")
-        # opus_src_tags, opus_tgt_tags = a3_src.split("+"), a3_tgt.split("+")
-
-        # This messy part tries to deal with language tags in multilingual models, possibly
-        # not all having three-letter codes
-        resolved_src_tags, resolved_tgt_tags = self.resolve_lang_code(a3_src, a3_tgt)
-        a2_src_tags, a2_tgt_tags = [], []
-        for tag in resolved_src_tags:
-            if tag not in self.alpha3_to_alpha2:
-                a2_src_tags.append(tag)
-        for tag in resolved_tgt_tags:
-            if tag not in self.alpha3_to_alpha2:
-                a2_tgt_tags.append(tag)
-
-        lang_tags = dedup(a2_src_tags + a2_tgt_tags)
-        src_multilingual, tgt_multilingual = (len(a2_src_tags) > 1), (len(a2_tgt_tags) > 1)
-        s, t = ",".join(a2_src_tags), ",".join(a2_tgt_tags)
-
-        metadata = {
-            "hf_name": model_dict["_name"],
-            "source_languages": s,
-            "target_languages": t,
-            "opus_readme_url": f"{model_dir_url}/README.md",
-            "original_repo": "Tatoeba-Challenge",
-            "tags": ["translation"],
-            "languages": lang_tags,
-        }
-        lang_tags = l2front_matter(lang_tags)
-
-        metadata["src_constituents"] = list(GROUP_MEMBERS[a3_src][1])
-        metadata["tgt_constituents"] = list(GROUP_MEMBERS[a3_tgt][1])
-        metadata["src_multilingual"] = src_multilingual
-        metadata["tgt_multilingual"] = tgt_multilingual
-
-        backtranslated_data = ""
-        if model_dict["_has_backtranslated_data"]:
-            backtranslated_data = " with backtranslations"
-
-        multilingual_data = ""
-        if "_data_per_pair" in model_dict:
-            multilingual_data = f"* data per pair in multilingual model: {model_dict['_data_per_pair']}\n"
-
-        tuned = ""
-        if "_tuned" in model_dict:
-            tuned = f"* multilingual model tuned for: {model_dict['_tuned']}\n"
-
-        model_base_filename = model_dict["release"].split("/")[-1]
-        download = f"* download original weights: [{model_base_filename}]({model_dir_url}/{model_dict['release']})\n"
-
-        langtoken = ""
-        if tgt_multilingual:
-            langtoken = (
-                "* a sentence-initial language token is required in the form of >>id<<"
-                "(id = valid, usually three-letter target language ID)\n"
-            )
-
-        metadata.update(get_system_metadata(DEFAULT_REPO))
-
-        scorestable = ""
-        for k, v in model_dict.items():
-            if "scores" in k:
-                this_score_table = f"* {k}\n|Test set|score|\n|---|---|\n"
-                pairs = sorted(v.items(), key=lambda x: x[1], reverse=True)
-                for pair in pairs:
-                    this_score_table += f"|{pair[0]}|{pair[1]}|\n"
-                scorestable += this_score_table
-
-        datainfo = ""
-        if "training-data" in model_dict:
-            datainfo += "* Training data: \n"
-            for k, v in model_dict["training-data"].items():
-                datainfo += f"  * {str(k)}: {str(v)}\n"
-        if "validation-data" in model_dict:
-            datainfo += "* Validation data: \n"
-            for k, v in model_dict["validation-data"].items():
-                datainfo += f"  * {str(k)}: {str(v)}\n"
-        if "test-data" in model_dict:
-            datainfo += "* Test data: \n"
-            for k, v in model_dict["test-data"].items():
-                datainfo += f"  * {str(k)}: {str(v)}\n"
-
-        testsetfilename = model_dict["release"].replace(".zip", ".test.txt")
-        testscoresfilename = model_dict["release"].replace(".zip", ".eval.txt")
-        testset = f"* test set translations file: [test.txt]({model_dir_url}/{testsetfilename})\n"
-        testscores = f"* test set scores file: [eval.txt]({model_dir_url}/{testscoresfilename})\n"
-
-        # combine with Tatoeba markdown
-        readme_url = f"{TATOEBA_MODELS_URL}/{model_dict['_name']}/README.md"
-        extra_markdown = f"""
-### {model_dict["_name"]}
-
-* source language name: {self.tag2name[a3_src]}
-* target language name: {self.tag2name[a3_tgt]}
-* OPUS readme: [README.md]({readme_url})
-"""
-
-        content = (
-            f"""
-* model: {model_dict["modeltype"]}
-* source language code{src_multilingual * "s"}: {", ".join(a2_src_tags)}
-* target language code{tgt_multilingual * "s"}: {", ".join(a2_tgt_tags)}
-* dataset: opus {backtranslated_data}
-* release date: {model_dict["release-date"]}
-* pre-processing: {model_dict["pre-processing"]}
-"""
-            + multilingual_data
-            + tuned
-            + download
-            + langtoken
-            + datainfo
-            + testset
-            + testscores
-            + scorestable
-        )
-
-        content = FRONT_MATTER_TEMPLATE.format(lang_tags) + extra_markdown + content
-
-        items = "\n".join([f"* {k}: {v}" for k, v in metadata.items()])
-        sec3 = "\n### System Info: \n" + items
-        content += sec3
-        if dry_run:
-            print("CONTENT:")
-            print(content)
-            print("METADATA:")
-            print(metadata)
-            return
-        sub_dir = self.model_card_dir / model_dict["_hf_model_id"]
-        sub_dir.mkdir(exist_ok=True)
-        dest = sub_dir / "README.md"
-        dest.open("w").write(content)
-        for k, v in metadata.items():
-            if isinstance(v, datetime.date):
-                metadata[k] = datetime.datetime.strftime(v, "%Y-%m-%d")
-        with open(sub_dir / "metadata.json", "w", encoding="utf-8") as writeobj:
-            json.dump(metadata, writeobj)
-
-    def download_lang_info(self):
-        global LANG_CODE_PATH
-        Path(LANG_CODE_PATH).parent.mkdir(exist_ok=True)
-        import wget
-        from huggingface_hub import hf_hub_download
-
-        if not os.path.exists(ISO_PATH):
-            wget.download(ISO_URL, ISO_PATH)
-        if not os.path.exists(LANG_CODE_PATH):
-            LANG_CODE_PATH = hf_hub_download(
-                repo_id="huggingface/language_codes_marianMT", filename="language-codes-3b2.csv", repo_type="dataset"
-            )
-
-    def parse_metadata(self, model_name, repo_path=DEFAULT_MODEL_DIR, method="best"):
-        p = Path(repo_path) / model_name
-
-        def url_to_name(url):
-            return url.split("/")[-1].split(".")[0]
-
-        if model_name not in self.model_results:
-            # This is not a language pair, so model results are ambiguous, go by newest
-            method = "newest"
-
-        if method == "best":
-            # Sort by how early they appear in released-models-results
-            results = [url_to_name(model["download"]) for model in self.model_results[model_name]]
-            ymls = [f for f in os.listdir(p) if f.endswith(".yml") and f[:-4] in results]
-            ymls.sort(key=lambda x: results.index(x[:-4]))
-            metadata = yaml.safe_load(open(p / ymls[0]))
-            metadata.update(self.model_type_info_from_model_name(ymls[0][:-4]))
-        elif method == "newest":
-            ymls = [f for f in os.listdir(p) if f.endswith(".yml")]
-            # Sort by date
-            ymls.sort(
-                key=lambda x: datetime.datetime.strptime(re.search(r"\d\d\d\d-\d\d?-\d\d?", x).group(), "%Y-%m-%d")
-            )
-            metadata = yaml.safe_load(open(p / ymls[-1]))
-            metadata.update(self.model_type_info_from_model_name(ymls[-1][:-4]))
-        else:
-            raise NotImplementedError(f"Don't know argument method='{method}' to parse_metadata()")
-        metadata["_name"] = model_name
-        return metadata
-
-
-GROUP_MEMBERS = {
-    # three letter code -> (group/language name, {constituents...}
-    # if this language is on the target side the constituents can be used as target language codes.
-    # if the language is on the source side they are supported natively without special codes.
-    "aav": ("Austro-Asiatic languages", {"hoc", "hoc_Latn", "kha", "khm", "khm_Latn", "mnw", "vie", "vie_Hani"}),
-    "afa": (
-        "Afro-Asiatic languages",
-        {
-            "acm",
-            "afb",
-            "amh",
-            "apc",
-            "ara",
-            "arq",
-            "ary",
-            "arz",
-            "hau_Latn",
-            "heb",
-            "kab",
-            "mlt",
-            "rif_Latn",
-            "shy_Latn",
-            "som",
-            "thv",
-            "tir",
-        },
-    ),
-    "afr": ("Afrikaans", {"afr"}),
-    "alv": (
-        "Atlantic-Congo languages",
-        {
-            "ewe",
-            "fuc",
-            "fuv",
-            "ibo",
-            "kin",
-            "lin",
-            "lug",
-            "nya",
-            "run",
-            "sag",
-            "sna",
-            "swh",
-            "toi_Latn",
-            "tso",
-            "umb",
-            "wol",
-            "xho",
-            "yor",
-            "zul",
-        },
-    ),
-    "ara": ("Arabic", {"afb", "apc", "apc_Latn", "ara", "ara_Latn", "arq", "arq_Latn", "arz"}),
-    "art": (
-        "Artificial languages",
-        {
-            "afh_Latn",
-            "avk_Latn",
-            "dws_Latn",
-            "epo",
-            "ido",
-            "ido_Latn",
-            "ile_Latn",
-            "ina_Latn",
-            "jbo",
-            "jbo_Cyrl",
-            "jbo_Latn",
-            "ldn_Latn",
-            "lfn_Cyrl",
-            "lfn_Latn",
-            "nov_Latn",
-            "qya",
-            "qya_Latn",
-            "sjn_Latn",
-            "tlh_Latn",
-            "tzl",
-            "tzl_Latn",
-            "vol_Latn",
-        },
-    ),
-    "aze": ("Azerbaijani", {"aze_Latn"}),
-    "bat": ("Baltic languages", {"lit", "lav", "prg_Latn", "ltg", "sgs"}),
-    "bel": ("Belarusian", {"bel", "bel_Latn"}),
-    "ben": ("Bengali", {"ben"}),
-    "bnt": (
-        "Bantu languages",
-        {"kin", "lin", "lug", "nya", "run", "sna", "swh", "toi_Latn", "tso", "umb", "xho", "zul"},
-    ),
-    "bul": ("Bulgarian", {"bul", "bul_Latn"}),
-    "cat": ("Catalan", {"cat"}),
-    "cau": ("Caucasian languages", {"abk", "kat", "che", "ady"}),
-    "ccs": ("South Caucasian languages", {"kat"}),
-    "ceb": ("Cebuano", {"ceb"}),
-    "cel": ("Celtic languages", {"gla", "gle", "bre", "cor", "glv", "cym"}),
-    "ces": ("Czech", {"ces"}),
-    "cpf": ("Creoles and pidgins, French‑based", {"gcf_Latn", "hat", "mfe"}),
-    "cpp": (
-        "Creoles and pidgins, Portuguese-based",
-        {"zsm_Latn", "ind", "pap", "min", "tmw_Latn", "max_Latn", "zlm_Latn"},
-    ),
-    "cus": ("Cushitic languages", {"som"}),
-    "dan": ("Danish", {"dan"}),
-    "deu": ("German", {"deu"}),
-    "dra": ("Dravidian languages", {"tam", "kan", "mal", "tel"}),
-    "ell": ("Modern Greek (1453-)", {"ell"}),
-    "eng": ("English", {"eng"}),
-    "epo": ("Esperanto", {"epo"}),
-    "est": ("Estonian", {"est"}),
-    "euq": ("Basque (family)", {"eus"}),
-    "eus": ("Basque", {"eus"}),
-    "fin": ("Finnish", {"fin"}),
-    "fiu": (
-        "Finno-Ugrian languages",
-        {
-            "est",
-            "fin",
-            "fkv_Latn",
-            "hun",
-            "izh",
-            "kpv",
-            "krl",
-            "liv_Latn",
-            "mdf",
-            "mhr",
-            "myv",
-            "sma",
-            "sme",
-            "udm",
-            "vep",
-            "vro",
-        },
-    ),
-    "fra": ("French", {"fra"}),
-    "gem": (
-        "Germanic languages",
-        {
-            "afr",
-            "ang_Latn",
-            "dan",
-            "deu",
-            "eng",
-            "enm_Latn",
-            "fao",
-            "frr",
-            "fry",
-            "gos",
-            "got_Goth",
-            "gsw",
-            "isl",
-            "ksh",
-            "ltz",
-            "nds",
-            "nld",
-            "nno",
-            "nob",
-            "nob_Hebr",
-            "non_Latn",
-            "pdc",
-            "sco",
-            "stq",
-            "swe",
-            "swg",
-            "yid",
-        },
-    ),
-    "gle": ("Irish", {"gle"}),
-    "glg": ("Galician", {"glg"}),
-    "gmq": ("North Germanic languages", {"dan", "nob", "nob_Hebr", "swe", "isl", "nno", "non_Latn", "fao"}),
-    "gmw": (
-        "West Germanic languages",
-        {
-            "afr",
-            "ang_Latn",
-            "deu",
-            "eng",
-            "enm_Latn",
-            "frr",
-            "fry",
-            "gos",
-            "gsw",
-            "ksh",
-            "ltz",
-            "nds",
-            "nld",
-            "pdc",
-            "sco",
-            "stq",
-            "swg",
-            "yid",
-        },
-    ),
-    "grk": ("Greek languages", {"grc_Grek", "ell"}),
-    "hbs": ("Serbo-Croatian", {"hrv", "srp_Cyrl", "bos_Latn", "srp_Latn"}),
-    "heb": ("Hebrew", {"heb"}),
-    "hin": ("Hindi", {"hin"}),
-    "hun": ("Hungarian", {"hun"}),
-    "hye": ("Armenian", {"hye", "hye_Latn"}),
-    "iir": (
-        "Indo-Iranian languages",
-        {
-            "asm",
-            "awa",
-            "ben",
-            "bho",
-            "gom",
-            "guj",
-            "hif_Latn",
-            "hin",
-            "jdt_Cyrl",
-            "kur_Arab",
-            "kur_Latn",
-            "mai",
-            "mar",
-            "npi",
-            "ori",
-            "oss",
-            "pan_Guru",
-            "pes",
-            "pes_Latn",
-            "pes_Thaa",
-            "pnb",
-            "pus",
-            "rom",
-            "san_Deva",
-            "sin",
-            "snd_Arab",
-            "tgk_Cyrl",
-            "tly_Latn",
-            "urd",
-            "zza",
-        },
-    ),
-    "ilo": ("Iloko", {"ilo"}),
-    "inc": (
-        "Indic languages",
-        {
-            "asm",
-            "awa",
-            "ben",
-            "bho",
-            "gom",
-            "guj",
-            "hif_Latn",
-            "hin",
-            "mai",
-            "mar",
-            "npi",
-            "ori",
-            "pan_Guru",
-            "pnb",
-            "rom",
-            "san_Deva",
-            "sin",
-            "snd_Arab",
-            "urd",
-        },
-    ),
-    "ine": (
-        "Indo-European languages",
-        {
-            "afr",
-            "afr_Arab",
-            "aln",
-            "ang_Latn",
-            "arg",
-            "asm",
-            "ast",
-            "awa",
-            "bel",
-            "bel_Latn",
-            "ben",
-            "bho",
-            "bjn",
-            "bos_Latn",
-            "bre",
-            "bul",
-            "bul_Latn",
-            "cat",
-            "ces",
-            "cor",
-            "cos",
-            "csb_Latn",
-            "cym",
-            "dan",
-            "deu",
-            "dsb",
-            "egl",
-            "ell",
-            "eng",
-            "enm_Latn",
-            "ext",
-            "fao",
-            "fra",
-            "frm_Latn",
-            "frr",
-            "fry",
-            "gcf_Latn",
-            "gla",
-            "gle",
-            "glg",
-            "glv",
-            "gom",
-            "gos",
-            "got_Goth",
-            "grc_Grek",
-            "gsw",
-            "guj",
-            "hat",
-            "hif_Latn",
-            "hin",
-            "hrv",
-            "hsb",
-            "hye",
-            "hye_Latn",
-            "ind",
-            "isl",
-            "ita",
-            "jdt_Cyrl",
-            "ksh",
-            "kur_Arab",
-            "kur_Latn",
-            "lad",
-            "lad_Latn",
-            "lat_Grek",
-            "lat_Latn",
-            "lav",
-            "lij",
-            "lit",
-            "lld_Latn",
-            "lmo",
-            "ltg",
-            "ltz",
-            "mai",
-            "mar",
-            "max_Latn",
-            "mfe",
-            "min",
-            "mkd",
-            "mwl",
-            "nds",
-            "nld",
-            "nno",
-            "nob",
-            "nob_Hebr",
-            "non_Latn",
-            "npi",
-            "oci",
-            "ori",
-            "orv_Cyrl",
-            "oss",
-            "pan_Guru",
-            "pap",
-            "pcd",
-            "pdc",
-            "pes",
-            "pes_Latn",
-            "pes_Thaa",
-            "pms",
-            "pnb",
-            "pol",
-            "por",
-            "prg_Latn",
-            "pus",
-            "roh",
-            "rom",
-            "ron",
-            "rue",
-            "rus",
-            "rus_Latn",
-            "san_Deva",
-            "scn",
-            "sco",
-            "sgs",
-            "sin",
-            "slv",
-            "snd_Arab",
-            "spa",
-            "sqi",
-            "srd",
-            "srp_Cyrl",
-            "srp_Latn",
-            "stq",
-            "swe",
-            "swg",
-            "tgk_Cyrl",
-            "tly_Latn",
-            "tmw_Latn",
-            "ukr",
-            "urd",
-            "vec",
-            "wln",
-            "yid",
-            "zlm_Latn",
-            "zsm_Latn",
-            "zza",
-        },
-    ),
-    "isl": ("Icelandic", {"isl"}),
-    "ita": ("Italian", {"ita"}),
-    "itc": (
-        "Italic languages",
-        {
-            "arg",
-            "ast",
-            "bjn",
-            "cat",
-            "cos",
-            "egl",
-            "ext",
-            "fra",
-            "frm_Latn",
-            "gcf_Latn",
-            "glg",
-            "hat",
-            "ind",
-            "ita",
-            "lad",
-            "lad_Latn",
-            "lat_Grek",
-            "lat_Latn",
-            "lij",
-            "lld_Latn",
-            "lmo",
-            "max_Latn",
-            "mfe",
-            "min",
-            "mwl",
-            "oci",
-            "pap",
-            "pcd",
-            "pms",
-            "por",
-            "roh",
-            "ron",
-            "scn",
-            "spa",
-            "srd",
-            "tmw_Latn",
-            "vec",
-            "wln",
-            "zlm_Latn",
-            "zsm_Latn",
-        },
-    ),
-    "jpn": ("Japanese", {"jpn", "jpn_Bopo", "jpn_Hang", "jpn_Hani", "jpn_Hira", "jpn_Kana", "jpn_Latn", "jpn_Yiii"}),
-    "jpx": ("Japanese (family)", {"jpn"}),
-    "kat": ("Georgian", {"kat"}),
-    "kor": ("Korean", {"kor_Hani", "kor_Hang", "kor_Latn", "kor"}),
-    "lav": ("Latvian", {"lav"}),
-    "lit": ("Lithuanian", {"lit"}),
-    "mkd": ("Macedonian", {"mkd"}),
-    "mkh": ("Mon-Khmer languages", {"vie_Hani", "mnw", "vie", "kha", "khm_Latn", "khm"}),
-    "msa": ("Malay (macrolanguage)", {"zsm_Latn", "ind", "max_Latn", "zlm_Latn", "min"}),
-    "mul": (
-        "Multiple languages",
-        {
-            "abk",
-            "acm",
-            "ady",
-            "afb",
-            "afh_Latn",
-            "afr",
-            "akl_Latn",
-            "aln",
-            "amh",
-            "ang_Latn",
-            "apc",
-            "ara",
-            "arg",
-            "arq",
-            "ary",
-            "arz",
-            "asm",
-            "ast",
-            "avk_Latn",
-            "awa",
-            "aze_Latn",
-            "bak",
-            "bam_Latn",
-            "bel",
-            "bel_Latn",
-            "ben",
-            "bho",
-            "bod",
-            "bos_Latn",
-            "bre",
-            "brx",
-            "brx_Latn",
-            "bul",
-            "bul_Latn",
-            "cat",
-            "ceb",
-            "ces",
-            "cha",
-            "che",
-            "chr",
-            "chv",
-            "cjy_Hans",
-            "cjy_Hant",
-            "cmn",
-            "cmn_Hans",
-            "cmn_Hant",
-            "cor",
-            "cos",
-            "crh",
-            "crh_Latn",
-            "csb_Latn",
-            "cym",
-            "dan",
-            "deu",
-            "dsb",
-            "dtp",
-            "dws_Latn",
-            "egl",
-            "ell",
-            "enm_Latn",
-            "epo",
-            "est",
-            "eus",
-            "ewe",
-            "ext",
-            "fao",
-            "fij",
-            "fin",
-            "fkv_Latn",
-            "fra",
-            "frm_Latn",
-            "frr",
-            "fry",
-            "fuc",
-            "fuv",
-            "gan",
-            "gcf_Latn",
-            "gil",
-            "gla",
-            "gle",
-            "glg",
-            "glv",
-            "gom",
-            "gos",
-            "got_Goth",
-            "grc_Grek",
-            "grn",
-            "gsw",
-            "guj",
-            "hat",
-            "hau_Latn",
-            "haw",
-            "heb",
-            "hif_Latn",
-            "hil",
-            "hin",
-            "hnj_Latn",
-            "hoc",
-            "hoc_Latn",
-            "hrv",
-            "hsb",
-            "hun",
-            "hye",
-            "iba",
-            "ibo",
-            "ido",
-            "ido_Latn",
-            "ike_Latn",
-            "ile_Latn",
-            "ilo",
-            "ina_Latn",
-            "ind",
-            "isl",
-            "ita",
-            "izh",
-            "jav",
-            "jav_Java",
-            "jbo",
-            "jbo_Cyrl",
-            "jbo_Latn",
-            "jdt_Cyrl",
-            "jpn",
-            "kab",
-            "kal",
-            "kan",
-            "kat",
-            "kaz_Cyrl",
-            "kaz_Latn",
-            "kek_Latn",
-            "kha",
-            "khm",
-            "khm_Latn",
-            "kin",
-            "kir_Cyrl",
-            "kjh",
-            "kpv",
-            "krl",
-            "ksh",
-            "kum",
-            "kur_Arab",
-            "kur_Latn",
-            "lad",
-            "lad_Latn",
-            "lao",
-            "lat_Latn",
-            "lav",
-            "ldn_Latn",
-            "lfn_Cyrl",
-            "lfn_Latn",
-            "lij",
-            "lin",
-            "lit",
-            "liv_Latn",
-            "lkt",
-            "lld_Latn",
-            "lmo",
-            "ltg",
-            "ltz",
-            "lug",
-            "lzh",
-            "lzh_Hans",
-            "mad",
-            "mah",
-            "mai",
-            "mal",
-            "mar",
-            "max_Latn",
-            "mdf",
-            "mfe",
-            "mhr",
-            "mic",
-            "min",
-            "mkd",
-            "mlg",
-            "mlt",
-            "mnw",
-            "moh",
-            "mon",
-            "mri",
-            "mwl",
-            "mww",
-            "mya",
-            "myv",
-            "nan",
-            "nau",
-            "nav",
-            "nds",
-            "niu",
-            "nld",
-            "nno",
-            "nob",
-            "nob_Hebr",
-            "nog",
-            "non_Latn",
-            "nov_Latn",
-            "npi",
-            "nya",
-            "oci",
-            "ori",
-            "orv_Cyrl",
-            "oss",
-            "ota_Arab",
-            "ota_Latn",
-            "pag",
-            "pan_Guru",
-            "pap",
-            "pau",
-            "pdc",
-            "pes",
-            "pes_Latn",
-            "pes_Thaa",
-            "pms",
-            "pnb",
-            "pol",
-            "por",
-            "ppl_Latn",
-            "prg_Latn",
-            "pus",
-            "quc",
-            "qya",
-            "qya_Latn",
-            "rap",
-            "rif_Latn",
-            "roh",
-            "rom",
-            "ron",
-            "rue",
-            "run",
-            "rus",
-            "sag",
-            "sah",
-            "san_Deva",
-            "scn",
-            "sco",
-            "sgs",
-            "shs_Latn",
-            "shy_Latn",
-            "sin",
-            "sjn_Latn",
-            "slv",
-            "sma",
-            "sme",
-            "smo",
-            "sna",
-            "snd_Arab",
-            "som",
-            "spa",
-            "sqi",
-            "srp_Cyrl",
-            "srp_Latn",
-            "stq",
-            "sun",
-            "swe",
-            "swg",
-            "swh",
-            "tah",
-            "tam",
-            "tat",
-            "tat_Arab",
-            "tat_Latn",
-            "tel",
-            "tet",
-            "tgk_Cyrl",
-            "tha",
-            "tir",
-            "tlh_Latn",
-            "tly_Latn",
-            "tmw_Latn",
-            "toi_Latn",
-            "ton",
-            "tpw_Latn",
-            "tso",
-            "tuk",
-            "tuk_Latn",
-            "tur",
-            "tvl",
-            "tyv",
-            "tzl",
-            "tzl_Latn",
-            "udm",
-            "uig_Arab",
-            "uig_Cyrl",
-            "ukr",
-            "umb",
-            "urd",
-            "uzb_Cyrl",
-            "uzb_Latn",
-            "vec",
-            "vie",
-            "vie_Hani",
-            "vol_Latn",
-            "vro",
-            "war",
-            "wln",
-            "wol",
-            "wuu",
-            "xal",
-            "xho",
-            "yid",
-            "yor",
-            "yue",
-            "yue_Hans",
-            "yue_Hant",
-            "zho",
-            "zho_Hans",
-            "zho_Hant",
-            "zlm_Latn",
-            "zsm_Latn",
-            "zul",
-            "zza",
-        },
-    ),
-    "nic": (
-        "Niger-Kordofanian languages",
-        {
-            "bam_Latn",
-            "ewe",
-            "fuc",
-            "fuv",
-            "ibo",
-            "kin",
-            "lin",
-            "lug",
-            "nya",
-            "run",
-            "sag",
-            "sna",
-            "swh",
-            "toi_Latn",
-            "tso",
-            "umb",
-            "wol",
-            "xho",
-            "yor",
-            "zul",
-        },
-    ),
-    "nld": ("Dutch", {"nld"}),
-    "nor": ("Norwegian", {"nob", "nno"}),
-    "phi": ("Philippine languages", {"ilo", "akl_Latn", "war", "hil", "pag", "ceb"}),
-    "pol": ("Polish", {"pol"}),
-    "por": ("Portuguese", {"por"}),
-    "pqe": (
-        "Eastern Malayo-Polynesian languages",
-        {"fij", "gil", "haw", "mah", "mri", "nau", "niu", "rap", "smo", "tah", "ton", "tvl"},
-    ),
-    "roa": (
-        "Romance languages",
-        {
-            "arg",
-            "ast",
-            "cat",
-            "cos",
-            "egl",
-            "ext",
-            "fra",
-            "frm_Latn",
-            "gcf_Latn",
-            "glg",
-            "hat",
-            "ind",
-            "ita",
-            "lad",
-            "lad_Latn",
-            "lij",
-            "lld_Latn",
-            "lmo",
-            "max_Latn",
-            "mfe",
-            "min",
-            "mwl",
-            "oci",
-            "pap",
-            "pms",
-            "por",
-            "roh",
-            "ron",
-            "scn",
-            "spa",
-            "tmw_Latn",
-            "vec",
-            "wln",
-            "zlm_Latn",
-            "zsm_Latn",
-        },
-    ),
-    "ron": ("Romanian", {"ron"}),
-    "run": ("Rundi", {"run"}),
-    "rus": ("Russian", {"rus"}),
-    "sal": ("Salishan languages", {"shs_Latn"}),
-    "sem": ("Semitic languages", {"acm", "afb", "amh", "apc", "ara", "arq", "ary", "arz", "heb", "mlt", "tir"}),
-    "sla": (
-        "Slavic languages",
-        {
-            "bel",
-            "bel_Latn",
-            "bos_Latn",
-            "bul",
-            "bul_Latn",
-            "ces",
-            "csb_Latn",
-            "dsb",
-            "hrv",
-            "hsb",
-            "mkd",
-            "orv_Cyrl",
-            "pol",
-            "rue",
-            "rus",
-            "slv",
-            "srp_Cyrl",
-            "srp_Latn",
-            "ukr",
-        },
-    ),
-    "slv": ("Slovenian", {"slv"}),
-    "spa": ("Spanish", {"spa"}),
-    "swe": ("Swedish", {"swe"}),
-    "taw": ("Tai", {"lao", "tha"}),
-    "tgl": ("Tagalog", {"tgl_Latn"}),
-    "tha": ("Thai", {"tha"}),
-    "trk": (
-        "Turkic languages",
-        {
-            "aze_Latn",
-            "bak",
-            "chv",
-            "crh",
-            "crh_Latn",
-            "kaz_Cyrl",
-            "kaz_Latn",
-            "kir_Cyrl",
-            "kjh",
-            "kum",
-            "ota_Arab",
-            "ota_Latn",
-            "sah",
-            "tat",
-            "tat_Arab",
-            "tat_Latn",
-            "tuk",
-            "tuk_Latn",
-            "tur",
-            "tyv",
-            "uig_Arab",
-            "uig_Cyrl",
-            "uzb_Cyrl",
-            "uzb_Latn",
-        },
-    ),
-    "tur": ("Turkish", {"tur"}),
-    "ukr": ("Ukrainian", {"ukr"}),
-    "urd": ("Urdu", {"urd"}),
-    "urj": (
-        "Uralic languages",
-        {
-            "est",
-            "fin",
-            "fkv_Latn",
-            "hun",
-            "izh",
-            "kpv",
-            "krl",
-            "liv_Latn",
-            "mdf",
-            "mhr",
-            "myv",
-            "sma",
-            "sme",
-            "udm",
-            "vep",
-            "vro",
-        },
-    ),
-    "vie": ("Vietnamese", {"vie", "vie_Hani"}),
-    "war": ("Waray (Philippines)", {"war"}),
-    "zho": (
-        "Chinese",
-        {
-            "cjy_Hans",
-            "cjy_Hant",
-            "cmn",
-            "cmn_Bopo",
-            "cmn_Hang",
-            "cmn_Hani",
-            "cmn_Hans",
-            "cmn_Hant",
-            "cmn_Hira",
-            "cmn_Kana",
-            "cmn_Latn",
-            "cmn_Yiii",
-            "gan",
-            "hak_Hani",
-            "lzh",
-            "lzh_Bopo",
-            "lzh_Hang",
-            "lzh_Hani",
-            "lzh_Hans",
-            "lzh_Hira",
-            "lzh_Kana",
-            "lzh_Yiii",
-            "nan",
-            "nan_Hani",
-            "wuu",
-            "wuu_Bopo",
-            "wuu_Hani",
-            "wuu_Latn",
-            "yue",
-            "yue_Bopo",
-            "yue_Hang",
-            "yue_Hani",
-            "yue_Hans",
-            "yue_Hant",
-            "yue_Hira",
-            "yue_Kana",
-            "zho",
-            "zho_Hans",
-            "zho_Hant",
-        },
-    ),
-    "zle": ("East Slavic languages", {"bel", "orv_Cyrl", "bel_Latn", "rus", "ukr", "rue"}),
-    "zls": ("South Slavic languages", {"bos_Latn", "bul", "bul_Latn", "hrv", "mkd", "slv", "srp_Cyrl", "srp_Latn"}),
-    "zlw": ("West Slavic languages", {"csb_Latn", "dsb", "hsb", "pol", "ces"}),
-}
-
-
-def l2front_matter(langs):
-    return "".join(f"- {l}\n" for l in langs)
-
-
-def dedup(lst):
-    """Preservers order"""
-    new_lst = []
-    for item in lst:
-        if not item or item in new_lst:
-            continue
-        else:
-            new_lst.append(item)
-    return new_lst
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-m", "--models", action="append", help="<Required> Set flag", required=True, nargs="+", dest="models"
-    )
-    parser.add_argument("-save_dir", "--save_dir", default="marian_converted", help="where to save converted models")
-    args = parser.parse_args()
-    resolver = TatoebaConverter(save_dir=args.save_dir)
-    resolver.convert_models(args.models[0])
diff --git a/src/transformers/models/marian/convert_marian_to_pytorch.py b/src/transformers/models/marian/convert_marian_to_pytorch.py
deleted file mode 100644
index 4cc9b15ce4d5..000000000000
--- a/src/transformers/models/marian/convert_marian_to_pytorch.py
+++ /dev/null
@@ -1,717 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import json
-import os
-import socket
-import time
-import warnings
-from pathlib import Path
-from typing import Dict, List, Union
-from zipfile import ZipFile
-
-import numpy as np
-import torch
-from huggingface_hub.hf_api import list_models
-from torch import nn
-from tqdm import tqdm
-
-from transformers import MarianConfig, MarianMTModel, MarianTokenizer
-
-
-def remove_suffix(text: str, suffix: str):
-    if text.endswith(suffix):
-        return text[: -len(suffix)]
-    return text  # or whatever
-
-
-def remove_prefix(text: str, prefix: str):
-    if text.startswith(prefix):
-        return text[len(prefix) :]
-    return text  # or whatever
-
-
-def convert_encoder_layer(opus_dict, layer_prefix: str, converter: dict):
-    sd = {}
-    for k in opus_dict:
-        if not k.startswith(layer_prefix):
-            continue
-        stripped = remove_prefix(k, layer_prefix)
-        v = opus_dict[k].T  # besides embeddings, everything must be transposed.
-        sd[converter[stripped]] = torch.tensor(v).squeeze()
-    return sd
-
-
-def load_layers_(layer_lst: nn.ModuleList, opus_state: dict, converter, is_decoder=False):
-    for i, layer in enumerate(layer_lst):
-        layer_tag = f"decoder_l{i + 1}_" if is_decoder else f"encoder_l{i + 1}_"
-        sd = convert_encoder_layer(opus_state, layer_tag, converter)
-        layer.load_state_dict(sd, strict=False)
-
-
-def find_pretrained_model(src_lang: str, tgt_lang: str) -> List[str]:
-    """Find models that can accept src_lang as input and return tgt_lang as output."""
-    prefix = "Helsinki-NLP/opus-mt-"
-    model_list = list_models()
-    model_ids = [x.id for x in model_list if x.id.startswith("Helsinki-NLP")]
-    src_and_targ = [
-        remove_prefix(m, prefix).lower().split("-") for m in model_ids if "+" not in m
-    ]  # + cant be loaded.
-    matching = [f"{prefix}{a}-{b}" for (a, b) in src_and_targ if src_lang in a and tgt_lang in b]
-    return matching
-
-
-def add_emb_entries(wemb, final_bias, n_special_tokens=1):
-    vsize, d_model = wemb.shape
-    embs_to_add = np.zeros((n_special_tokens, d_model))
-    new_embs = np.concatenate([wemb, embs_to_add])
-    bias_to_add = np.zeros((n_special_tokens, 1))
-    new_bias = np.concatenate((final_bias, bias_to_add), axis=1)
-    return new_embs, new_bias
-
-
-def _cast_yaml_str(v):
-    bool_dct = {"true": True, "false": False}
-    if not isinstance(v, str):
-        return v
-    elif v in bool_dct:
-        return bool_dct[v]
-    try:
-        return int(v)
-    except (TypeError, ValueError):
-        return v
-
-
-def cast_marian_config(raw_cfg: Dict[str, str]) -> Dict:
-    return {k: _cast_yaml_str(v) for k, v in raw_cfg.items()}
-
-
-CONFIG_KEY = "special:model.yml"
-
-
-def load_config_from_state_dict(opus_dict):
-    import yaml
-
-    cfg_str = "".join([chr(x) for x in opus_dict[CONFIG_KEY]])
-    yaml_cfg = yaml.load(cfg_str[:-1], Loader=yaml.BaseLoader)
-    return cast_marian_config(yaml_cfg)
-
-
-def find_model_file(dest_dir):  # this one better
-    model_files = list(Path(dest_dir).glob("*.npz"))
-    if len(model_files) != 1:
-        raise ValueError(f"Found more than one model file: {model_files}")
-    model_file = model_files[0]
-    return model_file
-
-
-# Group Names Logic: change long opus model names to something shorter, like opus-mt-en-ROMANCE
-ROM_GROUP = (
-    "fr+fr_BE+fr_CA+fr_FR+wa+frp+oc+ca+rm+lld+fur+lij+lmo+es+es_AR+es_CL+es_CO+es_CR+es_DO+es_EC+es_ES+es_GT"
-    "+es_HN+es_MX+es_NI+es_PA+es_PE+es_PR+es_SV+es_UY+es_VE+pt+pt_br+pt_BR+pt_PT+gl+lad+an+mwl+it+it_IT+co"
-    "+nap+scn+vec+sc+ro+la"
-)
-GROUPS = [
-    ("cmn+cn+yue+ze_zh+zh_cn+zh_CN+zh_HK+zh_tw+zh_TW+zh_yue+zhs+zht+zh", "ZH"),
-    (ROM_GROUP, "ROMANCE"),
-    ("de+nl+fy+af+da+fo+is+no+nb+nn+sv", "NORTH_EU"),
-    ("da+fo+is+no+nb+nn+sv", "SCANDINAVIA"),
-    ("se+sma+smj+smn+sms", "SAMI"),
-    ("nb_NO+nb+nn_NO+nn+nog+no_nb+no", "NORWAY"),
-    ("ga+cy+br+gd+kw+gv", "CELTIC"),  # https://en.wikipedia.org/wiki/Insular_Celtic_languages
-]
-GROUP_TO_OPUS_NAME = {
-    "opus-mt-ZH-de": "cmn+cn+yue+ze_zh+zh_cn+zh_CN+zh_HK+zh_tw+zh_TW+zh_yue+zhs+zht+zh-de",
-    "opus-mt-ZH-fi": "cmn+cn+yue+ze_zh+zh_cn+zh_CN+zh_HK+zh_tw+zh_TW+zh_yue+zhs+zht+zh-fi",
-    "opus-mt-ZH-sv": "cmn+cn+yue+ze_zh+zh_cn+zh_CN+zh_HK+zh_tw+zh_TW+zh_yue+zhs+zht+zh-sv",
-    "opus-mt-SCANDINAVIA-SCANDINAVIA": "da+fo+is+no+nb+nn+sv-da+fo+is+no+nb+nn+sv",
-    "opus-mt-NORTH_EU-NORTH_EU": "de+nl+fy+af+da+fo+is+no+nb+nn+sv-de+nl+fy+af+da+fo+is+no+nb+nn+sv",
-    "opus-mt-de-ZH": "de-cmn+cn+yue+ze_zh+zh_cn+zh_CN+zh_HK+zh_tw+zh_TW+zh_yue+zhs+zht+zh",
-    "opus-mt-en_el_es_fi-en_el_es_fi": "en+el+es+fi-en+el+es+fi",
-    "opus-mt-en-ROMANCE": (
-        "en-fr+fr_BE+fr_CA+fr_FR+wa+frp+oc+ca+rm+lld+fur+lij+lmo+es+es_AR+es_CL+es_CO+es_CR+es_DO"
-        "+es_EC+es_ES+es_GT+es_HN+es_MX+es_NI+es_PA+es_PE+es_PR+es_SV+es_UY+es_VE+pt+pt_br+pt_BR"
-        "+pt_PT+gl+lad+an+mwl+it+it_IT+co+nap+scn+vec+sc+ro+la"
-    ),
-    "opus-mt-en-CELTIC": "en-ga+cy+br+gd+kw+gv",
-    "opus-mt-es-NORWAY": "es-nb_NO+nb+nn_NO+nn+nog+no_nb+no",
-    "opus-mt-fi_nb_no_nn_ru_sv_en-SAMI": "fi+nb+no+nn+ru+sv+en-se+sma+smj+smn+sms",
-    "opus-mt-fi-ZH": "fi-cmn+cn+yue+ze_zh+zh_cn+zh_CN+zh_HK+zh_tw+zh_TW+zh_yue+zhs+zht+zh",
-    "opus-mt-fi-NORWAY": "fi-nb_NO+nb+nn_NO+nn+nog+no_nb+no",
-    "opus-mt-ROMANCE-en": (
-        "fr+fr_BE+fr_CA+fr_FR+wa+frp+oc+ca+rm+lld+fur+lij+lmo+es+es_AR+es_CL+es_CO+es_CR+es_DO"
-        "+es_EC+es_ES+es_GT+es_HN+es_MX+es_NI+es_PA+es_PE+es_PR+es_SV+es_UY+es_VE+pt+pt_br+pt_BR"
-        "+pt_PT+gl+lad+an+mwl+it+it_IT+co+nap+scn+vec+sc+ro+la-en"
-    ),
-    "opus-mt-CELTIC-en": "ga+cy+br+gd+kw+gv-en",
-    "opus-mt-sv-ZH": "sv-cmn+cn+yue+ze_zh+zh_cn+zh_CN+zh_HK+zh_tw+zh_TW+zh_yue+zhs+zht+zh",
-    "opus-mt-sv-NORWAY": "sv-nb_NO+nb+nn_NO+nn+nog+no_nb+no",
-}
-OPUS_GITHUB_URL = "https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/"
-ORG_NAME = "Helsinki-NLP/"
-
-
-def convert_opus_name_to_hf_name(x):
-    """For OPUS-MT-Train/ DEPRECATED"""
-    for substr, grp_name in GROUPS:
-        x = x.replace(substr, grp_name)
-    return x.replace("+", "_")
-
-
-def convert_hf_name_to_opus_name(hf_model_name):
-    """
-    Relies on the assumption that there are no language codes like pt_br in models that are not in GROUP_TO_OPUS_NAME.
-    """
-    hf_model_name = remove_prefix(hf_model_name, ORG_NAME)
-    if hf_model_name in GROUP_TO_OPUS_NAME:
-        opus_w_prefix = GROUP_TO_OPUS_NAME[hf_model_name]
-    else:
-        opus_w_prefix = hf_model_name.replace("_", "+")
-    return remove_prefix(opus_w_prefix, "opus-mt-")
-
-
-def get_system_metadata(repo_root):
-    import git
-
-    return {
-        "helsinki_git_sha": git.Repo(path=repo_root, search_parent_directories=True).head.object.hexsha,
-        "transformers_git_sha": git.Repo(path=".", search_parent_directories=True).head.object.hexsha,
-        "port_machine": socket.gethostname(),
-        "port_time": time.strftime("%Y-%m-%d-%H:%M"),
-    }
-
-
-# docstyle-ignore
-FRONT_MATTER_TEMPLATE = """---
-language:
-{}
-tags:
-- translation
-
-license: apache-2.0
----
-"""
-DEFAULT_REPO = "Tatoeba-Challenge"
-DEFAULT_MODEL_DIR = os.path.join(DEFAULT_REPO, "models")
-
-
-def write_model_card(
-    hf_model_name: str,
-    repo_root=DEFAULT_REPO,
-    save_dir=Path("marian_converted"),
-    dry_run=False,
-    extra_metadata={},
-) -> str:
-    """
-    Copy the most recent model's readme section from opus, and add metadata. upload command: aws s3 sync model_card_dir
-    s3://models.huggingface.co/bert/Helsinki-NLP/ --dryrun
-    """
-    import pandas as pd
-
-    hf_model_name = remove_prefix(hf_model_name, ORG_NAME)
-    opus_name: str = convert_hf_name_to_opus_name(hf_model_name)
-    if repo_root not in ("OPUS-MT-train", "Tatoeba-Challenge"):
-        raise ValueError(f"Repos root is {repo_root}. Expected either OPUS-MT-train or Tatoeba-Challenge")
-    opus_readme_path = Path(repo_root).joinpath("models", opus_name, "README.md")
-    if not (opus_readme_path.exists()):
-        raise ValueError(f"Readme file {opus_readme_path} not found")
-
-    opus_src, opus_tgt = [x.split("+") for x in opus_name.split("-")]
-
-    readme_url = f"https://github.com/Helsinki-NLP/{repo_root}/tree/master/models/{opus_name}/README.md"
-
-    s, t = ",".join(opus_src), ",".join(opus_tgt)
-    metadata = {
-        "hf_name": hf_model_name,
-        "source_languages": s,
-        "target_languages": t,
-        "opus_readme_url": readme_url,
-        "original_repo": repo_root,
-        "tags": ["translation"],
-    }
-    metadata.update(extra_metadata)
-    metadata.update(get_system_metadata(repo_root))
-
-    # combine with opus markdown
-
-    extra_markdown = (
-        f"### {hf_model_name}\n\n* source group: {metadata['src_name']} \n* target group: "
-        f"{metadata['tgt_name']} \n*  OPUS readme: [{opus_name}]({readme_url})\n"
-    )
-
-    content = opus_readme_path.open().read()
-    content = content.split("\n# ")[-1]  # Get the lowest level 1 header in the README -- the most recent model.
-    splat = content.split("*")[2:]
-    print(splat[3])
-    content = "*".join(splat)
-    content = (
-        FRONT_MATTER_TEMPLATE.format(metadata["src_alpha2"])
-        + extra_markdown
-        + "\n* "
-        + content.replace("download", "download original weights")
-    )
-
-    items = "\n\n".join([f"- {k}: {v}" for k, v in metadata.items()])
-    sec3 = "\n### System Info: \n" + items
-    content += sec3
-    if dry_run:
-        return content, metadata
-    sub_dir = save_dir / f"opus-mt-{hf_model_name}"
-    sub_dir.mkdir(exist_ok=True)
-    dest = sub_dir / "README.md"
-    dest.open("w").write(content)
-    pd.Series(metadata).to_json(sub_dir / "metadata.json")
-
-    # if dry_run:
-    return content, metadata
-
-
-def make_registry(repo_path="Opus-MT-train/models"):
-    if not (Path(repo_path) / "fr-en" / "README.md").exists():
-        raise ValueError(
-            f"repo_path:{repo_path} does not exist: "
-            "You must run: git clone git@github.com:Helsinki-NLP/Opus-MT-train.git before calling."
-        )
-    results = {}
-    for p in Path(repo_path).iterdir():
-        n_dash = p.name.count("-")
-        if n_dash == 0:
-            continue
-        else:
-            lns = list(open(p / "README.md").readlines())
-            results[p.name] = _parse_readme(lns)
-    return [(k, v["pre-processing"], v["download"], v["download"][:-4] + ".test.txt") for k, v in results.items()]
-
-
-def convert_all_sentencepiece_models(model_list=None, repo_path=None, dest_dir=Path("marian_converted")):
-    """Requires 300GB"""
-    save_dir = Path("marian_ckpt")
-    dest_dir = Path(dest_dir)
-    dest_dir.mkdir(exist_ok=True)
-    save_paths = []
-    if model_list is None:
-        model_list: list = make_registry(repo_path=repo_path)
-    for k, prepro, download, test_set_url in tqdm(model_list):
-        if "SentencePiece" not in prepro:  # dont convert BPE models.
-            continue
-        if not os.path.exists(save_dir / k):
-            download_and_unzip(download, save_dir / k)
-        pair_name = convert_opus_name_to_hf_name(k)
-        convert(save_dir / k, dest_dir / f"opus-mt-{pair_name}")
-
-        save_paths.append(dest_dir / f"opus-mt-{pair_name}")
-    return save_paths
-
-
-def lmap(f, x) -> List:
-    return list(map(f, x))
-
-
-def fetch_test_set(test_set_url):
-    import wget
-
-    fname = wget.download(test_set_url, "opus_test.txt")
-    lns = Path(fname).open().readlines()
-    src = lmap(str.strip, lns[::4])
-    gold = lmap(str.strip, lns[1::4])
-    mar_model = lmap(str.strip, lns[2::4])
-    if not (len(gold) == len(mar_model) == len(src)):
-        raise ValueError(f"Gold, marian and source lengths {len(gold)}, {len(mar_model)}, {len(src)} mismatched")
-    os.remove(fname)
-    return src, mar_model, gold
-
-
-def convert_whole_dir(path=Path("marian_ckpt/")):
-    for subdir in tqdm(list(path.ls())):
-        dest_dir = f"marian_converted/{subdir.name}"
-        if (dest_dir / "pytorch_model.bin").exists():
-            continue
-        convert(source_dir, dest_dir)
-
-
-def _parse_readme(lns):
-    """Get link and metadata from opus model card equivalent."""
-    subres = {}
-    for ln in [x.strip() for x in lns]:
-        if not ln.startswith("*"):
-            continue
-        ln = ln[1:].strip()
-
-        for k in ["download", "dataset", "models", "model", "pre-processing"]:
-            if ln.startswith(k):
-                break
-        else:
-            continue
-        if k in ["dataset", "model", "pre-processing"]:
-            splat = ln.split(":")
-            _, v = splat
-            subres[k] = v
-        elif k == "download":
-            v = ln.split("(")[-1][:-1]
-            subres[k] = v
-    return subres
-
-
-def save_tokenizer_config(dest_dir: Path, separate_vocabs=False):
-    dname = dest_dir.name.split("-")
-    dct = {"target_lang": dname[-1], "source_lang": "-".join(dname[:-1]), "separate_vocabs": separate_vocabs}
-    save_json(dct, dest_dir / "tokenizer_config.json")
-
-
-def add_to_vocab_(vocab: Dict[str, int], special_tokens: List[str]):
-    start = max(vocab.values()) + 1
-    added = 0
-    for tok in special_tokens:
-        if tok in vocab:
-            continue
-        vocab[tok] = start + added
-        added += 1
-    return added
-
-
-def find_vocab_file(model_dir):
-    return list(model_dir.glob("*vocab.yml"))[0]
-
-
-def find_src_vocab_file(model_dir):
-    return list(model_dir.glob("*src.vocab.yml"))[0]
-
-
-def find_tgt_vocab_file(model_dir):
-    return list(model_dir.glob("*trg.vocab.yml"))[0]
-
-
-def add_special_tokens_to_vocab(model_dir: Path, separate_vocab=False) -> None:
-    if separate_vocab:
-        vocab = load_yaml(find_src_vocab_file(model_dir))
-        vocab = {k: int(v) for k, v in vocab.items()}
-        num_added = add_to_vocab_(vocab, ["<pad>"])
-        save_json(vocab, model_dir / "vocab.json")
-
-        vocab = load_yaml(find_tgt_vocab_file(model_dir))
-        vocab = {k: int(v) for k, v in vocab.items()}
-        num_added = add_to_vocab_(vocab, ["<pad>"])
-        save_json(vocab, model_dir / "target_vocab.json")
-        save_tokenizer_config(model_dir, separate_vocabs=separate_vocab)
-    else:
-        vocab = load_yaml(find_vocab_file(model_dir))
-        vocab = {k: int(v) for k, v in vocab.items()}
-        num_added = add_to_vocab_(vocab, ["<pad>"])
-        print(f"added {num_added} tokens to vocab")
-        save_json(vocab, model_dir / "vocab.json")
-        save_tokenizer_config(model_dir)
-
-
-def check_equal(marian_cfg, k1, k2):
-    v1, v2 = marian_cfg[k1], marian_cfg[k2]
-    if v1 != v2:
-        raise ValueError(f"hparams {k1},{k2} differ: {v1} != {v2}")
-
-
-def check_marian_cfg_assumptions(marian_cfg):
-    assumed_settings = {
-        "layer-normalization": False,
-        "right-left": False,
-        "transformer-ffn-depth": 2,
-        "transformer-aan-depth": 2,
-        "transformer-no-projection": False,
-        "transformer-postprocess-emb": "d",
-        "transformer-postprocess": "dan",  # Dropout, add, normalize
-        "transformer-preprocess": "",
-        "type": "transformer",
-        "ulr-dim-emb": 0,
-        "dec-cell-base-depth": 2,
-        "dec-cell-high-depth": 1,
-        "transformer-aan-nogate": False,
-    }
-    for k, v in assumed_settings.items():
-        actual = marian_cfg[k]
-        if actual != v:
-            raise ValueError(f"Unexpected config value for {k} expected {v} got {actual}")
-
-
-BIAS_KEY = "decoder_ff_logit_out_b"
-BART_CONVERTER = {  # for each encoder and decoder layer
-    "self_Wq": "self_attn.q_proj.weight",
-    "self_Wk": "self_attn.k_proj.weight",
-    "self_Wv": "self_attn.v_proj.weight",
-    "self_Wo": "self_attn.out_proj.weight",
-    "self_bq": "self_attn.q_proj.bias",
-    "self_bk": "self_attn.k_proj.bias",
-    "self_bv": "self_attn.v_proj.bias",
-    "self_bo": "self_attn.out_proj.bias",
-    "self_Wo_ln_scale": "self_attn_layer_norm.weight",
-    "self_Wo_ln_bias": "self_attn_layer_norm.bias",
-    "ffn_W1": "fc1.weight",
-    "ffn_b1": "fc1.bias",
-    "ffn_W2": "fc2.weight",
-    "ffn_b2": "fc2.bias",
-    "ffn_ffn_ln_scale": "final_layer_norm.weight",
-    "ffn_ffn_ln_bias": "final_layer_norm.bias",
-    # Decoder Cross Attention
-    "context_Wk": "encoder_attn.k_proj.weight",
-    "context_Wo": "encoder_attn.out_proj.weight",
-    "context_Wq": "encoder_attn.q_proj.weight",
-    "context_Wv": "encoder_attn.v_proj.weight",
-    "context_bk": "encoder_attn.k_proj.bias",
-    "context_bo": "encoder_attn.out_proj.bias",
-    "context_bq": "encoder_attn.q_proj.bias",
-    "context_bv": "encoder_attn.v_proj.bias",
-    "context_Wo_ln_scale": "encoder_attn_layer_norm.weight",
-    "context_Wo_ln_bias": "encoder_attn_layer_norm.bias",
-}
-
-
-class OpusState:
-    def __init__(self, source_dir, eos_token_id=0):
-        npz_path = find_model_file(source_dir)
-        self.state_dict = np.load(npz_path)
-        cfg = load_config_from_state_dict(self.state_dict)
-        if cfg["dim-vocabs"][0] != cfg["dim-vocabs"][1]:
-            raise ValueError
-        if "Wpos" in self.state_dict:
-            raise ValueError("Wpos key in state dictionary")
-        self.state_dict = dict(self.state_dict)
-        if cfg["tied-embeddings-all"]:
-            cfg["tied-embeddings-src"] = True
-            cfg["tied-embeddings"] = True
-        self.share_encoder_decoder_embeddings = cfg["tied-embeddings-src"]
-
-        # create the tokenizer here because we need to know the eos_token_id
-        self.source_dir = source_dir
-        self.tokenizer = self.load_tokenizer()
-        # retrieve EOS token and set correctly
-        tokenizer_has_eos_token_id = (
-            hasattr(self.tokenizer, "eos_token_id") and self.tokenizer.eos_token_id is not None
-        )
-        eos_token_id = self.tokenizer.eos_token_id if tokenizer_has_eos_token_id else 0
-
-        if cfg["tied-embeddings-src"]:
-            self.wemb, self.final_bias = add_emb_entries(self.state_dict["Wemb"], self.state_dict[BIAS_KEY], 1)
-            self.pad_token_id = self.wemb.shape[0] - 1
-            cfg["vocab_size"] = self.pad_token_id + 1
-        else:
-            self.wemb, _ = add_emb_entries(self.state_dict["encoder_Wemb"], self.state_dict[BIAS_KEY], 1)
-            self.dec_wemb, self.final_bias = add_emb_entries(
-                self.state_dict["decoder_Wemb"], self.state_dict[BIAS_KEY], 1
-            )
-            # still assuming that vocab size is same for encoder and decoder
-            self.pad_token_id = self.wemb.shape[0] - 1
-            cfg["vocab_size"] = self.pad_token_id + 1
-            cfg["decoder_vocab_size"] = self.pad_token_id + 1
-
-        if cfg["vocab_size"] != self.tokenizer.vocab_size:
-            raise ValueError(
-                f"Original vocab size {cfg['vocab_size']} and new vocab size {len(self.tokenizer.encoder)} mismatched."
-            )
-
-        # self.state_dict['Wemb'].sha
-        self.state_keys = list(self.state_dict.keys())
-        if "Wtype" in self.state_dict:
-            raise ValueError("Wtype key in state dictionary")
-        self._check_layer_entries()
-        self.cfg = cfg
-        hidden_size, intermediate_shape = self.state_dict["encoder_l1_ffn_W1"].shape
-        if hidden_size != cfg["dim-emb"]:
-            raise ValueError(f"Hidden size {hidden_size} and configured size {cfg['dim_emb']} mismatched")
-
-        # Process decoder.yml
-        decoder_yml = cast_marian_config(load_yaml(source_dir / "decoder.yml"))
-        check_marian_cfg_assumptions(cfg)
-        self.hf_config = MarianConfig(
-            vocab_size=cfg["vocab_size"],
-            decoder_vocab_size=cfg.get("decoder_vocab_size", cfg["vocab_size"]),
-            share_encoder_decoder_embeddings=cfg["tied-embeddings-src"],
-            decoder_layers=cfg["dec-depth"],
-            encoder_layers=cfg["enc-depth"],
-            decoder_attention_heads=cfg["transformer-heads"],
-            encoder_attention_heads=cfg["transformer-heads"],
-            decoder_ffn_dim=cfg["transformer-dim-ffn"],
-            encoder_ffn_dim=cfg["transformer-dim-ffn"],
-            d_model=cfg["dim-emb"],
-            activation_function=cfg["transformer-ffn-activation"],
-            pad_token_id=self.pad_token_id,
-            eos_token_id=eos_token_id,
-            forced_eos_token_id=eos_token_id,
-            bos_token_id=0,
-            max_position_embeddings=cfg["dim-emb"],
-            scale_embedding=True,
-            normalize_embedding="n" in cfg["transformer-preprocess"],
-            static_position_embeddings=not cfg["transformer-train-position-embeddings"],
-            tie_word_embeddings=cfg["tied-embeddings"],
-            dropout=0.1,  # see opus-mt-train repo/transformer-dropout param.
-            # default: add_final_layer_norm=False,
-            num_beams=decoder_yml["beam-size"],
-            decoder_start_token_id=self.pad_token_id,
-            bad_words_ids=[[self.pad_token_id]],
-            max_length=512,
-        )
-
-    def _check_layer_entries(self):
-        self.encoder_l1 = self.sub_keys("encoder_l1")
-        self.decoder_l1 = self.sub_keys("decoder_l1")
-        self.decoder_l2 = self.sub_keys("decoder_l2")
-        if len(self.encoder_l1) != 16:
-            warnings.warn(f"Expected 16 keys for each encoder layer, got {len(self.encoder_l1)}")
-        if len(self.decoder_l1) != 26:
-            warnings.warn(f"Expected 26 keys for each decoder layer, got {len(self.decoder_l1)}")
-        if len(self.decoder_l2) != 26:
-            warnings.warn(f"Expected 26 keys for each decoder layer, got {len(self.decoder_l1)}")
-
-    @property
-    def extra_keys(self):
-        extra = []
-        for k in self.state_keys:
-            if (
-                k.startswith("encoder_l")
-                or k.startswith("decoder_l")
-                or k in [CONFIG_KEY, "Wemb", "encoder_Wemb", "decoder_Wemb", "Wpos", "decoder_ff_logit_out_b"]
-            ):
-                continue
-            else:
-                extra.append(k)
-        return extra
-
-    def sub_keys(self, layer_prefix):
-        return [remove_prefix(k, layer_prefix) for k in self.state_dict if k.startswith(layer_prefix)]
-
-    def load_tokenizer(self):
-        # save tokenizer
-        add_special_tokens_to_vocab(self.source_dir, not self.share_encoder_decoder_embeddings)
-        return MarianTokenizer.from_pretrained(str(self.source_dir))
-
-    def load_marian_model(self) -> MarianMTModel:
-        state_dict, cfg = self.state_dict, self.hf_config
-
-        if not cfg.static_position_embeddings:
-            raise ValueError("config.static_position_embeddings should be True")
-        model = MarianMTModel(cfg)
-
-        if "hidden_size" in cfg.to_dict():
-            raise ValueError("hidden_size is in config")
-        load_layers_(
-            model.model.encoder.layers,
-            state_dict,
-            BART_CONVERTER,
-        )
-        load_layers_(model.model.decoder.layers, state_dict, BART_CONVERTER, is_decoder=True)
-
-        # handle tensors not associated with layers
-        if self.cfg["tied-embeddings-src"]:
-            wemb_tensor = nn.Parameter(torch.FloatTensor(self.wemb))
-            bias_tensor = nn.Parameter(torch.FloatTensor(self.final_bias))
-            model.model.shared.weight = wemb_tensor
-            model.model.encoder.embed_tokens = model.model.decoder.embed_tokens = model.model.shared
-        else:
-            wemb_tensor = nn.Parameter(torch.FloatTensor(self.wemb))
-            model.model.encoder.embed_tokens.weight = wemb_tensor
-
-            decoder_wemb_tensor = nn.Parameter(torch.FloatTensor(self.dec_wemb))
-            bias_tensor = nn.Parameter(torch.FloatTensor(self.final_bias))
-            model.model.decoder.embed_tokens.weight = decoder_wemb_tensor
-
-        # handle tied embeddings, otherwise "from_pretrained" loads them incorrectly
-        if self.cfg["tied-embeddings"]:
-            model.lm_head.weight.data = model.model.decoder.embed_tokens.weight.data.clone()
-
-        model.final_logits_bias = bias_tensor
-
-        if "Wpos" in state_dict:
-            print("Unexpected: got Wpos")
-            wpos_tensor = torch.tensor(state_dict["Wpos"])
-            model.model.encoder.embed_positions.weight = wpos_tensor
-            model.model.decoder.embed_positions.weight = wpos_tensor
-
-        if cfg.normalize_embedding:
-            if "encoder_emb_ln_scale_pre" not in state_dict:
-                raise ValueError("encoder_emb_ln_scale_pre is not in state dictionary")
-            raise NotImplementedError("Need to convert layernorm_embedding")
-
-        if self.extra_keys:
-            raise ValueError(f"Failed to convert {self.extra_keys}")
-
-        if model.get_input_embeddings().padding_idx != self.pad_token_id:
-            raise ValueError(
-                f"Padding tokens {model.get_input_embeddings().padding_idx} and {self.pad_token_id} mismatched"
-            )
-        return model
-
-
-def download_and_unzip(url, dest_dir):
-    try:
-        import wget
-    except ImportError:
-        raise ImportError("you must pip install wget")
-
-    filename = wget.download(url)
-    unzip(filename, dest_dir)
-    os.remove(filename)
-
-
-def convert(source_dir: Path, dest_dir):
-    dest_dir = Path(dest_dir)
-    dest_dir.mkdir(exist_ok=True)
-
-    opus_state = OpusState(source_dir)
-
-    # save tokenizer
-    opus_state.tokenizer.save_pretrained(dest_dir)
-
-    # save_json(opus_state.cfg, dest_dir / "marian_original_config.json")
-    # ^^ Uncomment to save human readable marian config for debugging
-
-    model = opus_state.load_marian_model()
-    model = model.half()
-    model.save_pretrained(dest_dir)
-    model.from_pretrained(dest_dir)  # sanity check
-
-
-def load_yaml(path):
-    import yaml
-
-    with open(path, encoding="utf-8") as f:
-        return yaml.load(f, Loader=yaml.BaseLoader)
-
-
-def save_json(content: Union[Dict, List], path: str) -> None:
-    with open(path, "w") as f:
-        json.dump(content, f)
-
-
-def unzip(zip_path: str, dest_dir: str) -> None:
-    with ZipFile(zip_path, "r") as zipObj:
-        zipObj.extractall(dest_dir)
-
-
-if __name__ == "__main__":
-    """
-    Tatoeba conversion instructions in scripts/tatoeba/README.md
-    """
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--src",
-        type=str,
-        help="path to marian model sub dir. yaml.load will be used to load the configuration file, please be wary of which file you're loading.",
-        default="en-de",
-    )
-    parser.add_argument("--dest", type=str, default=None, help="Path to the output PyTorch model.")
-    args = parser.parse_args()
-
-    source_dir = Path(args.src)
-    if not source_dir.exists():
-        raise ValueError(f"Source directory {source_dir} not found")
-    dest_dir = f"converted-{source_dir.name}" if args.dest is None else args.dest
-    convert(source_dir, dest_dir)
diff --git a/src/transformers/models/mask2former/convert_mask2former_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/mask2former/convert_mask2former_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 3fd28acad392..000000000000
--- a/src/transformers/models/mask2former/convert_mask2former_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,1019 +0,0 @@
-# coding=utf-8
-# Copyright 2022 Meta Platforms, Inc. and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import json
-import sys
-from argparse import ArgumentParser
-from dataclasses import dataclass
-from pathlib import Path
-from pprint import pformat
-from typing import Any, Dict, Iterator, List, Set, Tuple
-
-import requests
-import torch
-import torchvision.transforms as T
-from detectron2.checkpoint import DetectionCheckpointer
-from detectron2.config import get_cfg
-from detectron2.projects.deeplab import add_deeplab_config
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torch import Tensor, nn
-
-from transformers import (
-    Mask2FormerConfig,
-    Mask2FormerForUniversalSegmentation,
-    Mask2FormerImageProcessor,
-    Mask2FormerModel,
-    SwinConfig,
-)
-from transformers.models.mask2former.modeling_mask2former import (
-    Mask2FormerForUniversalSegmentationOutput,
-    Mask2FormerModelOutput,
-)
-from transformers.utils import logging
-
-
-StateDict = Dict[str, Tensor]
-
-logging.set_verbosity_info()
-logger = logging.get_logger()
-
-torch.manual_seed(0)
-
-
-class TrackedStateDict:
-    def __init__(self, to_track: Dict):
-        """This class "tracks" a python dictionary by keeping track of which item is accessed.
-
-        Args:
-            to_track (Dict): The dictionary we wish to track
-        """
-        self.to_track = to_track
-        self._seen: Set[str] = set()
-
-    def __getitem__(self, key: str) -> Any:
-        return self.to_track[key]
-
-    def __setitem__(self, key: str, item: Any):
-        self._seen.add(key)
-        self.to_track[key] = item
-
-    def diff(self) -> List[str]:
-        """This method returns a set difference between the keys in the tracked state dict and the one we have access so far.
-        This is an effective method to check if we have update all the keys
-
-        Returns:
-            List[str]: List of keys not yet updated
-        """
-        return set(self.to_track.keys()) - self._seen
-
-    def copy(self) -> Dict:
-        # proxy the call to the internal dictionary
-        return self.to_track.copy()
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    img_data = requests.get(url, stream=True).raw
-    im = Image.open(img_data)
-    return im
-
-
-@dataclass
-class Args:
-    """Fake command line arguments needed by mask2former/detectron implementation"""
-
-    config_file: str
-
-
-def setup_cfg(args: Args):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    add_deeplab_config(cfg)
-    add_maskformer2_config(cfg)
-    cfg.merge_from_file(args.config_file)
-    cfg.freeze()
-    return cfg
-
-
-class OriginalMask2FormerConfigToOursConverter:
-    def __call__(self, original_config: object) -> Mask2FormerConfig:
-        model = original_config.MODEL
-
-        repo_id = "huggingface/label-files"
-        if model.SEM_SEG_HEAD.NUM_CLASSES == 847:
-            filename = "mask2former-ade20k-full-id2label.json"
-        elif model.SEM_SEG_HEAD.NUM_CLASSES == 150:
-            filename = "ade20k-id2label.json"
-        elif model.SEM_SEG_HEAD.NUM_CLASSES == 80:
-            filename = "coco-detection-mmdet-id2label.json"
-        elif model.SEM_SEG_HEAD.NUM_CLASSES == 171:
-            filename = "mask2former-coco-stuff-id2label.json"
-        elif model.SEM_SEG_HEAD.NUM_CLASSES == 133:
-            filename = "coco-panoptic-id2label.json"
-        elif model.SEM_SEG_HEAD.NUM_CLASSES == 19:
-            filename = "cityscapes-id2label.json"
-        elif model.SEM_SEG_HEAD.NUM_CLASSES == 8:
-            filename = "cityscapes-instance-id2label.json"
-        elif model.SEM_SEG_HEAD.NUM_CLASSES == 65:
-            filename = "mapillary-vistas-id2label.json"
-
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        label2id = {label: idx for idx, label in id2label.items()}
-
-        if model.SWIN.EMBED_DIM == 96:
-            backbone_config = SwinConfig.from_pretrained(
-                "microsoft/swin-tiny-patch4-window7-224", out_features=["stage1", "stage2", "stage3", "stage4"]
-            )
-        elif model.SWIN.EMBED_DIM == 128:
-            backbone_config = SwinConfig(
-                embed_dim=128,
-                window_size=12,
-                depths=(2, 2, 18, 2),
-                num_heads=(4, 8, 16, 32),
-                out_features=["stage1", "stage2", "stage3", "stage4"],
-            )
-
-        elif model.SWIN.EMBED_DIM == 192:
-            backbone_config = SwinConfig.from_pretrained(
-                "microsoft/swin-large-patch4-window12-384", out_features=["stage1", "stage2", "stage3", "stage4"]
-            )
-        else:
-            raise ValueError(f"embed dim {model.SWIN.EMBED_DIM} not supported for Swin!")
-
-        backbone_config.drop_path_rate = model.SWIN.DROP_PATH_RATE
-        backbone_config.attention_probs_dropout_prob = model.SWIN.ATTN_DROP_RATE
-        backbone_config.depths = model.SWIN.DEPTHS
-
-        config: Mask2FormerConfig = Mask2FormerConfig(
-            ignore_value=model.SEM_SEG_HEAD.IGNORE_VALUE,
-            num_labels=model.SEM_SEG_HEAD.NUM_CLASSES,
-            num_queries=model.MASK_FORMER.NUM_OBJECT_QUERIES,
-            no_object_weight=model.MASK_FORMER.NO_OBJECT_WEIGHT,
-            class_weight=model.MASK_FORMER.CLASS_WEIGHT,
-            mask_weight=model.MASK_FORMER.MASK_WEIGHT,
-            dice_weight=model.MASK_FORMER.DICE_WEIGHT,
-            train_num_points=model.MASK_FORMER.TRAIN_NUM_POINTS,
-            oversample_ratio=model.MASK_FORMER.OVERSAMPLE_RATIO,
-            importance_sample_ratio=model.MASK_FORMER.IMPORTANCE_SAMPLE_RATIO,
-            init_std=0.02,
-            init_xavier_std=1.0,
-            use_auxiliary_loss=model.MASK_FORMER.DEEP_SUPERVISION,
-            feature_strides=[4, 8, 16, 32],
-            backbone_config=backbone_config,
-            id2label=id2label,
-            label2id=label2id,
-            feature_size=model.SEM_SEG_HEAD.CONVS_DIM,
-            mask_feature_size=model.SEM_SEG_HEAD.MASK_DIM,
-            hidden_dim=model.MASK_FORMER.HIDDEN_DIM,
-            encoder_layers=model.SEM_SEG_HEAD.TRANSFORMER_ENC_LAYERS,
-            encoder_feedforward_dim=1024,
-            decoder_layers=model.MASK_FORMER.DEC_LAYERS,
-            num_attention_heads=model.MASK_FORMER.NHEADS,
-            dropout=model.MASK_FORMER.DROPOUT,
-            dim_feedforward=model.MASK_FORMER.DIM_FEEDFORWARD,
-            pre_norm=model.MASK_FORMER.PRE_NORM,
-            enforce_input_proj=model.MASK_FORMER.ENFORCE_INPUT_PROJ,
-            common_stride=model.SEM_SEG_HEAD.COMMON_STRIDE,
-        )
-        return config
-
-
-class OriginalMask2FormerConfigToImageProcessorConverter:
-    def __call__(self, original_config: object) -> Mask2FormerImageProcessor:
-        model = original_config.MODEL
-        model_input = original_config.INPUT
-
-        return Mask2FormerImageProcessor(
-            image_mean=(torch.tensor(model.PIXEL_MEAN) / 255).tolist(),
-            image_std=(torch.tensor(model.PIXEL_STD) / 255).tolist(),
-            size=model_input.MIN_SIZE_TEST,
-            max_size=model_input.MAX_SIZE_TEST,
-            num_labels=model.SEM_SEG_HEAD.NUM_CLASSES,
-            ignore_index=model.SEM_SEG_HEAD.IGNORE_VALUE,
-            size_divisibility=32,
-        )
-
-
-class OriginalMask2FormerCheckpointToOursConverter:
-    def __init__(self, original_model: nn.Module, config: Mask2FormerConfig):
-        self.original_model = original_model
-        self.config = config
-
-    def pop_all(self, renamed_keys: List[Tuple[str, str]], dst_state_dict: StateDict, src_state_dict: StateDict):
-        for src_key, dst_key in renamed_keys:
-            dst_state_dict[dst_key] = src_state_dict.pop(src_key)
-
-    def replace_maskformer_swin_backbone(
-        self, dst_state_dict: StateDict, src_state_dict: StateDict, config: Mask2FormerConfig
-    ):
-        dst_prefix: str = "pixel_level_module.encoder"
-        src_prefix: str = "backbone"
-
-        renamed_keys = [
-            (
-                f"{src_prefix}.patch_embed.proj.weight",
-                f"{dst_prefix}.model.embeddings.patch_embeddings.projection.weight",
-            ),
-            (f"{src_prefix}.patch_embed.proj.bias", f"{dst_prefix}.model.embeddings.patch_embeddings.projection.bias"),
-            (f"{src_prefix}.patch_embed.norm.weight", f"{dst_prefix}.model.embeddings.norm.weight"),
-            (f"{src_prefix}.patch_embed.norm.bias", f"{dst_prefix}.model.embeddings.norm.bias"),
-        ]
-        num_layers = len(config.backbone_config.depths)
-        for layer_idx in range(num_layers):
-            for block_idx in range(config.backbone_config.depths[layer_idx]):
-                renamed_keys.extend(
-                    [  # src, dst
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm1.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_before.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm1.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_before.bias",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.relative_position_bias_table",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.relative_position_bias_table",
-                        ),
-                    ]
-                )
-                # now we need to handle the attentions
-                # read in weights + bias of input projection layer of cross-attention
-
-                src_att_weight = src_state_dict[f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.weight"]
-                src_att_bias = src_state_dict[f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.bias"]
-
-                size = src_att_weight.shape[0]
-                offset = size // 3
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.query.weight"
-                ] = src_att_weight[:offset, :]
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.query.bias"
-                ] = src_att_bias[:offset]
-
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.key.weight"
-                ] = src_att_weight[offset : offset * 2, :]
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.key.bias"
-                ] = src_att_bias[offset : offset * 2]
-
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.value.weight"
-                ] = src_att_weight[-offset:, :]
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.value.bias"
-                ] = src_att_bias[-offset:]
-
-                # let's pop them
-                src_state_dict.pop(f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.weight")
-                src_state_dict.pop(f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.bias")
-                # proj
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.proj.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.output.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.proj.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.output.dense.bias",
-                        ),
-                    ]
-                )
-
-                # second norm
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm2.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_after.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm2.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_after.bias",
-                        ),
-                    ]
-                )
-
-                # mlp
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc1.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.intermediate.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc1.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.intermediate.dense.bias",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc2.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.output.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc2.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.output.dense.bias",
-                        ),
-                    ]
-                )
-
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.relative_position_index",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.relative_position_index",
-                        )
-                    ]
-                )
-
-            if layer_idx < num_layers - 1:
-                # patch merging
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.reduction.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.downsample.reduction.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.norm.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.downsample.norm.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.norm.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.downsample.norm.bias",
-                        ),
-                    ]
-                )
-
-            # hidden states norms
-            renamed_keys.extend(
-                [
-                    (
-                        f"{src_prefix}.norm{layer_idx}.weight",
-                        f"{dst_prefix}.hidden_states_norms.{layer_idx}.weight",
-                    ),
-                    (
-                        f"{src_prefix}.norm{layer_idx}.bias",
-                        f"{dst_prefix}.hidden_states_norms.{layer_idx}.bias",
-                    ),
-                ]
-            )
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def replace_swin_backbone(self, dst_state_dict: StateDict, src_state_dict: StateDict, config: Mask2FormerConfig):
-        dst_prefix: str = "pixel_level_module.encoder"
-        src_prefix: str = "backbone"
-
-        renamed_keys = [
-            (
-                f"{src_prefix}.patch_embed.proj.weight",
-                f"{dst_prefix}.embeddings.patch_embeddings.projection.weight",
-            ),
-            (f"{src_prefix}.patch_embed.proj.bias", f"{dst_prefix}.embeddings.patch_embeddings.projection.bias"),
-            (f"{src_prefix}.patch_embed.norm.weight", f"{dst_prefix}.embeddings.norm.weight"),
-            (f"{src_prefix}.patch_embed.norm.bias", f"{dst_prefix}.embeddings.norm.bias"),
-        ]
-
-        for layer_idx in range(len(config.backbone_config.depths)):
-            for block_idx in range(config.backbone_config.depths[layer_idx]):
-                renamed_keys.extend(
-                    [  # src, dst
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm1.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_before.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm1.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_before.bias",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.relative_position_bias_table",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.relative_position_bias_table",
-                        ),
-                    ]
-                )
-                # now we need to handle the attentions
-                # read in weights + bias of input projection layer of cross-attention
-
-                src_att_weight = src_state_dict[f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.weight"]
-                src_att_bias = src_state_dict[f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.bias"]
-
-                size = src_att_weight.shape[0]
-                offset = size // 3
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.query.weight"
-                ] = src_att_weight[:offset, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.query.bias"
-                ] = src_att_bias[:offset]
-
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.key.weight"
-                ] = src_att_weight[offset : offset * 2, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.key.bias"
-                ] = src_att_bias[offset : offset * 2]
-
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.value.weight"
-                ] = src_att_weight[-offset:, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.value.bias"
-                ] = src_att_bias[-offset:]
-
-                # let's pop them
-                src_state_dict.pop(f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.weight")
-                src_state_dict.pop(f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.bias")
-                # proj
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.proj.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.output.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.proj.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.output.dense.bias",
-                        ),
-                    ]
-                )
-
-                # second norm
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm2.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_after.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm2.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_after.bias",
-                        ),
-                    ]
-                )
-
-                # mlp
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc1.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.intermediate.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc1.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.intermediate.dense.bias",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc2.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.output.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc2.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.output.dense.bias",
-                        ),
-                    ]
-                )
-
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.relative_position_index",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.relative_position_index",
-                        )
-                    ]
-                )
-
-            if layer_idx < 3:
-                # patch merging
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.reduction.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.downsample.reduction.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.norm.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.downsample.norm.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.norm.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.downsample.norm.bias",
-                        ),
-                    ]
-                )
-
-            # hidden states norms
-            renamed_keys.extend(
-                [
-                    (
-                        f"{src_prefix}.norm{layer_idx}.weight",
-                        f"{dst_prefix}.hidden_states_norms.stage{layer_idx + 1}.weight",
-                    ),
-                    (
-                        f"{src_prefix}.norm{layer_idx}.bias",
-                        f"{dst_prefix}.hidden_states_norms.stage{layer_idx + 1}.bias",
-                    ),
-                ]
-            )
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    # Backbone + Pixel Decoder
-    def replace_pixel_module(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "pixel_level_module.decoder"
-        src_prefix: str = "sem_seg_head.pixel_decoder"
-
-        self.replace_swin_backbone(dst_state_dict, src_state_dict, self.config)
-
-        def rename_keys_for_weight_bias(src_prefix: str, dst_prefix: str):
-            return [
-                (f"{src_prefix}.weight", f"{dst_prefix}.weight"),
-                (f"{src_prefix}.bias", f"{dst_prefix}.bias"),
-            ]
-
-        def rename_keys_for_self_attn(src_prefix: str, dst_prefix: str):
-            self_attn_keys = []
-            self_attn_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.attention_weights", f"{dst_prefix}.attention_weights")
-            )
-            self_attn_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.output_proj", f"{dst_prefix}.output_proj")
-            )
-            self_attn_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.sampling_offsets", f"{dst_prefix}.sampling_offsets")
-            )
-            self_attn_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.value_proj", f"{dst_prefix}.value_proj"))
-
-            return self_attn_keys
-
-        def rename_keys_for_encoder_layer(src_prefix: str, dst_prefix: str):
-            encoder_keys = []
-            encoder_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.linear1", f"{dst_prefix}.fc1"))
-            encoder_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.linear2", f"{dst_prefix}.fc2"))
-            encoder_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.norm1", f"{dst_prefix}.self_attn_layer_norm")
-            )
-            encoder_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.norm2", f"{dst_prefix}.final_layer_norm"))
-            encoder_keys.extend(rename_keys_for_self_attn(f"{src_prefix}.self_attn", f"{dst_prefix}.self_attn"))
-
-            return encoder_keys
-
-        # convolution layer for final features
-        renamed_keys = [
-            (f"{src_prefix}.adapter_1.weight", f"{dst_prefix}.adapter_1.0.weight"),
-            (f"{src_prefix}.adapter_1.norm.weight", f"{dst_prefix}.adapter_1.1.weight"),
-            (f"{src_prefix}.adapter_1.norm.bias", f"{dst_prefix}.adapter_1.1.bias"),
-        ]
-
-        renamed_keys.extend(
-            [
-                (f"{src_prefix}.layer_1.weight", f"{dst_prefix}.layer_1.0.weight"),
-                (f"{src_prefix}.layer_1.norm.weight", f"{dst_prefix}.layer_1.1.weight"),
-                (f"{src_prefix}.layer_1.norm.bias", f"{dst_prefix}.layer_1.1.bias"),
-            ]
-        )
-
-        # proj layers
-        for i in range(3):
-            for j in range(2):
-                renamed_keys.extend(
-                    [
-                        (f"{src_prefix}.input_proj.{i}.{j}.weight", f"{dst_prefix}.input_projections.{i}.{j}.weight"),
-                        (f"{src_prefix}.input_proj.{i}.{j}.bias", f"{dst_prefix}.input_projections.{i}.{j}.bias"),
-                    ]
-                )
-
-        renamed_keys.extend([(f"{src_prefix}.transformer.level_embed", f"{dst_prefix}.level_embed")])
-
-        # layers
-        for layer_idx in range(self.config.encoder_layers):
-            renamed_keys.extend(
-                rename_keys_for_encoder_layer(
-                    f"{src_prefix}.transformer.encoder.layers.{layer_idx}", f"{dst_prefix}.encoder.layers.{layer_idx}"
-                )
-            )
-
-        # proj
-        renamed_keys.extend(
-            [
-                (f"{src_prefix}.mask_features.weight", f"{dst_prefix}.mask_projection.weight"),
-                (f"{src_prefix}.mask_features.bias", f"{dst_prefix}.mask_projection.bias"),
-            ]
-        )
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    # Transformer Decoder
-    def rename_keys_in_masked_attention_decoder(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module.decoder"
-        src_prefix: str = "sem_seg_head.predictor"
-
-        rename_keys = []
-        for i in range(self.config.decoder_layers - 1):
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_self_attention_layers.{i}.self_attn.out_proj.weight",
-                    f"{dst_prefix}.layers.{i}.self_attn.out_proj.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_self_attention_layers.{i}.self_attn.out_proj.bias",
-                    f"{dst_prefix}.layers.{i}.self_attn.out_proj.bias",
-                )
-            )
-
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_self_attention_layers.{i}.norm.weight",
-                    f"{dst_prefix}.layers.{i}.self_attn_layer_norm.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_self_attention_layers.{i}.norm.bias",
-                    f"{dst_prefix}.layers.{i}.self_attn_layer_norm.bias",
-                )
-            )
-
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_cross_attention_layers.{i}.multihead_attn.in_proj_weight",
-                    f"{dst_prefix}.layers.{i}.cross_attn.in_proj_weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_cross_attention_layers.{i}.multihead_attn.in_proj_bias",
-                    f"{dst_prefix}.layers.{i}.cross_attn.in_proj_bias",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_cross_attention_layers.{i}.multihead_attn.out_proj.weight",
-                    f"{dst_prefix}.layers.{i}.cross_attn.out_proj.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_cross_attention_layers.{i}.multihead_attn.out_proj.bias",
-                    f"{dst_prefix}.layers.{i}.cross_attn.out_proj.bias",
-                )
-            )
-
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_cross_attention_layers.{i}.norm.weight",
-                    f"{dst_prefix}.layers.{i}.cross_attn_layer_norm.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_cross_attention_layers.{i}.norm.bias",
-                    f"{dst_prefix}.layers.{i}.cross_attn_layer_norm.bias",
-                )
-            )
-
-            rename_keys.append(
-                (f"{src_prefix}.transformer_ffn_layers.{i}.linear1.weight", f"{dst_prefix}.layers.{i}.fc1.weight")
-            )
-            rename_keys.append(
-                (f"{src_prefix}.transformer_ffn_layers.{i}.linear1.bias", f"{dst_prefix}.layers.{i}.fc1.bias")
-            )
-            rename_keys.append(
-                (f"{src_prefix}.transformer_ffn_layers.{i}.linear2.weight", f"{dst_prefix}.layers.{i}.fc2.weight")
-            )
-            rename_keys.append(
-                (f"{src_prefix}.transformer_ffn_layers.{i}.linear2.bias", f"{dst_prefix}.layers.{i}.fc2.bias")
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_ffn_layers.{i}.norm.weight",
-                    f"{dst_prefix}.layers.{i}.final_layer_norm.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.transformer_ffn_layers.{i}.norm.bias",
-                    f"{dst_prefix}.layers.{i}.final_layer_norm.bias",
-                )
-            )
-
-        return rename_keys
-
-    def replace_masked_attention_decoder(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module.decoder"
-        src_prefix: str = "sem_seg_head.predictor"
-
-        renamed_keys = self.rename_keys_in_masked_attention_decoder(dst_state_dict, src_state_dict)
-
-        # add more
-        renamed_keys.extend(
-            [
-                (f"{src_prefix}.decoder_norm.weight", f"{dst_prefix}.layernorm.weight"),
-                (f"{src_prefix}.decoder_norm.bias", f"{dst_prefix}.layernorm.bias"),
-            ]
-        )
-
-        mlp_len = 3
-        for i in range(mlp_len):
-            renamed_keys.extend(
-                [
-                    (
-                        f"{src_prefix}.mask_embed.layers.{i}.weight",
-                        f"{dst_prefix}.mask_predictor.mask_embedder.{i}.0.weight",
-                    ),
-                    (
-                        f"{src_prefix}.mask_embed.layers.{i}.bias",
-                        f"{dst_prefix}.mask_predictor.mask_embedder.{i}.0.bias",
-                    ),
-                ]
-            )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def replace_keys_qkv_transformer_decoder(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module.decoder.layers"
-        src_prefix: str = "sem_seg_head.predictor"
-        for i in range(self.config.decoder_layers - 1):
-            # read in weights + bias of input projection layer of self-attention
-            in_proj_weight = src_state_dict.pop(
-                f"{src_prefix}.transformer_self_attention_layers.{i}.self_attn.in_proj_weight"
-            )
-            in_proj_bias = src_state_dict.pop(
-                f"{src_prefix}.transformer_self_attention_layers.{i}.self_attn.in_proj_bias"
-            )
-            # next, add query, keys and values (in that order) to the state dict
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-
-    def replace_transformer_module(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module"
-        src_prefix: str = "sem_seg_head.predictor"
-
-        self.replace_masked_attention_decoder(dst_state_dict, src_state_dict)
-
-        renamed_keys = [
-            (f"{src_prefix}.query_embed.weight", f"{dst_prefix}.queries_embedder.weight"),
-            (f"{src_prefix}.query_feat.weight", f"{dst_prefix}.queries_features.weight"),
-            (f"{src_prefix}.level_embed.weight", f"{dst_prefix}.level_embed.weight"),
-        ]
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-        self.replace_keys_qkv_transformer_decoder(dst_state_dict, src_state_dict)
-
-    def replace_universal_segmentation_module(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = ""
-        src_prefix: str = "sem_seg_head.predictor"
-
-        renamed_keys = [
-            (f"{src_prefix}.class_embed.weight", f"{dst_prefix}class_predictor.weight"),
-            (f"{src_prefix}.class_embed.bias", f"{dst_prefix}class_predictor.bias"),
-        ]
-
-        logger.info(f"Replacing keys {pformat(renamed_keys)}")
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def convert(self, mask2former: Mask2FormerModel) -> Mask2FormerModel:
-        dst_state_dict = TrackedStateDict(mask2former.state_dict())
-        src_state_dict = self.original_model.state_dict()
-
-        self.replace_pixel_module(dst_state_dict, src_state_dict)
-        self.replace_transformer_module(dst_state_dict, src_state_dict)
-
-        logger.info(f"Missed keys are {pformat(dst_state_dict.diff())}")
-        logger.info(f"Not copied keys are {pformat(src_state_dict.keys())}")
-        logger.info("🙌 Done")
-
-        state_dict = {key: dst_state_dict[key] for key in dst_state_dict.to_track.keys()}
-        mask2former.load_state_dict(state_dict)
-        return mask2former
-
-    def convert_universal_segmentation(
-        self, mask2former: Mask2FormerForUniversalSegmentation
-    ) -> Mask2FormerForUniversalSegmentation:
-        dst_state_dict = TrackedStateDict(mask2former.state_dict())
-        src_state_dict = self.original_model.state_dict()
-
-        self.replace_universal_segmentation_module(dst_state_dict, src_state_dict)
-
-        state_dict = {key: dst_state_dict[key] for key in dst_state_dict.to_track.keys()}
-        mask2former.load_state_dict(state_dict)
-
-        return mask2former
-
-    @staticmethod
-    def using_dirs(checkpoints_dir: Path, config_dir: Path) -> Iterator[Tuple[object, Path, Path]]:
-        checkpoints: List[Path] = checkpoints_dir.glob("**/*.pkl")
-
-        for checkpoint in checkpoints:
-            logger.info(f"💪 Converting {checkpoint.stem}")
-            # find associated config file
-
-            # dataset_name e.g 'coco'
-            dataset_name = checkpoint.parents[2].stem
-            if dataset_name == "ade":
-                dataset_name = dataset_name.replace("ade", "ade20k")
-
-            # task type e.g 'instance-segmentation'
-            segmentation_task = checkpoint.parents[1].stem
-
-            # config file corresponding to checkpoint
-            config_file_name = f"{checkpoint.parents[0].stem}.yaml"
-
-            config: Path = config_dir / dataset_name / segmentation_task / "swin" / config_file_name
-            yield config, checkpoint
-
-
-def test(
-    original_model,
-    our_model: Mask2FormerForUniversalSegmentation,
-    image_processor: Mask2FormerImageProcessor,
-    tolerance: float,
-):
-    with torch.no_grad():
-        original_model = original_model.eval()
-        our_model = our_model.eval()
-
-        im = prepare_img()
-        x = image_processor(images=im, return_tensors="pt")["pixel_values"]
-
-        original_model_backbone_features = original_model.backbone(x.clone())
-        our_model_output: Mask2FormerModelOutput = our_model.model(x.clone(), output_hidden_states=True)
-
-        # Test backbone
-        for original_model_feature, our_model_feature in zip(
-            original_model_backbone_features.values(), our_model_output.encoder_hidden_states
-        ):
-            assert torch.allclose(original_model_feature, our_model_feature, atol=tolerance), (
-                "The backbone features are not the same."
-            )
-
-        # Test pixel decoder
-        mask_features, _, multi_scale_features = original_model.sem_seg_head.pixel_decoder.forward_features(
-            original_model_backbone_features
-        )
-
-        for original_model_feature, our_model_feature in zip(
-            multi_scale_features, our_model_output.pixel_decoder_hidden_states
-        ):
-            assert torch.allclose(original_model_feature, our_model_feature, atol=tolerance), (
-                "The pixel decoder feature are not the same"
-            )
-
-        # Let's test the full model
-        tr_complete = T.Compose(
-            [T.Resize((384, 384)), T.ToTensor()],
-        )
-        y = (tr_complete(im) * 255.0).to(torch.int).float()
-
-        # modify original Mask2Former code to return mask and class logits
-        original_class_logits, original_mask_logits = original_model([{"image": y.clone().squeeze(0)}])
-
-        our_model_out: Mask2FormerForUniversalSegmentationOutput = our_model(x.clone())
-        our_mask_logits = our_model_out.masks_queries_logits
-        our_class_logits = our_model_out.class_queries_logits
-
-        assert original_mask_logits.shape == our_mask_logits.shape, "Output masks shapes are not matching."
-        assert original_class_logits.shape == our_class_logits.shape, "Output class logits shapes are not matching."
-        assert torch.allclose(original_class_logits, our_class_logits, atol=tolerance), (
-            "The class logits are not the same."
-        )
-        assert torch.allclose(original_mask_logits, our_mask_logits, atol=tolerance), (
-            "The predicted masks are not the same."
-        )
-
-        logger.info("✅ Test passed!")
-
-
-def get_model_name(checkpoint_file: Path):
-    # model_name_raw is something like maskformer2_swin_small_bs16_50ep
-    model_name_raw: str = checkpoint_file.parents[0].stem
-
-    # `segmentation_task_type` must be one of the following: `instance-segmentation`, `panoptic-segmentation`, `semantic-segmentation`
-    segmentation_task_name: str = checkpoint_file.parents[1].stem
-    if segmentation_task_name not in ["instance-segmentation", "panoptic-segmentation", "semantic-segmentation"]:
-        raise ValueError(
-            f"{segmentation_task_name} must be wrong since acceptable values are: instance-segmentation,"
-            " panoptic-segmentation, semantic-segmentation."
-        )
-
-    # dataset name must be one of the following: `coco`, `ade`, `cityscapes`, `mapillary-vistas`
-    dataset_name: str = checkpoint_file.parents[2].stem
-    if dataset_name not in ["coco", "ade", "cityscapes", "mapillary-vistas"]:
-        raise ValueError(
-            f"{dataset_name} must be wrong since we didn't find 'coco' or 'ade' or 'cityscapes' or 'mapillary-vistas'"
-            " in it "
-        )
-
-    backbone = "swin"
-    backbone_types = ["tiny", "small", "base_IN21k", "base", "large"]
-    backbone_type = list(filter(lambda x: x in model_name_raw, backbone_types))[0].replace("_", "-")
-
-    model_name = f"mask2former-{backbone}-{backbone_type}-{dataset_name}-{segmentation_task_name.split('-')[0]}"
-
-    return model_name
-
-
-if __name__ == "__main__":
-    parser = ArgumentParser(
-        description="Command line to convert the original mask2formers (with swin backbone) to our implementations."
-    )
-
-    parser.add_argument(
-        "--checkpoints_dir",
-        type=Path,
-        help=(
-            "A directory containing the model's checkpoints. The directory has to have the following structure:"
-            " <DIR_NAME>/<DATASET_NAME>/<SEGMENTATION_TASK_NAME>/<CONFIG_NAME>.pkl"
-        ),
-    )
-    parser.add_argument(
-        "--configs_dir",
-        type=Path,
-        help=(
-            "A directory containing the model's configs, see detectron2 doc. The directory has to have the following"
-            " structure: <DIR_NAME>/<DATASET_NAME>/<SEGMENTATION_TASK_NAME>/<CONFIG_NAME>.yaml"
-        ),
-    )
-    parser.add_argument(
-        "--mask2former_dir",
-        required=True,
-        type=Path,
-        help=(
-            "A path to Mask2Former's original implementation directory. You can download from here:"
-            " https://github.com/facebookresearch/Mask2Former"
-        ),
-    )
-
-    args = parser.parse_args()
-
-    checkpoints_dir: Path = args.checkpoints_dir
-    config_dir: Path = args.configs_dir
-    mask2former_dir: Path = args.mask2former_dir
-    # append the path to the parents to mask2former dir
-    sys.path.append(str(mask2former_dir.parent))
-    # import original Mask2Former config and model from original source code repo
-    from Mask2Former.mask2former.config import add_maskformer2_config
-    from Mask2Former.mask2former.maskformer_model import MaskFormer as OriginalMask2Former
-
-    for config_file, checkpoint_file in OriginalMask2FormerCheckpointToOursConverter.using_dirs(
-        checkpoints_dir, config_dir
-    ):
-        model_name = get_model_name(checkpoint_file)
-        image_processor = OriginalMask2FormerConfigToImageProcessorConverter()(
-            setup_cfg(Args(config_file=config_file))
-        )
-        image_processor.size = {"height": 384, "width": 384}
-
-        original_config = setup_cfg(Args(config_file=config_file))
-        mask2former_kwargs = OriginalMask2Former.from_config(original_config)
-        original_model = OriginalMask2Former(**mask2former_kwargs).eval()
-
-        DetectionCheckpointer(original_model).load(str(checkpoint_file))
-
-        config: Mask2FormerConfig = OriginalMask2FormerConfigToOursConverter()(original_config)
-        mask2former = Mask2FormerModel(config=config).eval()
-
-        converter = OriginalMask2FormerCheckpointToOursConverter(original_model, config)
-        mask2former = converter.convert(mask2former)
-
-        mask2former_for_segmentation = Mask2FormerForUniversalSegmentation(config=config).eval()
-        mask2former_for_segmentation.model = mask2former
-
-        mask2former_for_segmentation = converter.convert_universal_segmentation(mask2former_for_segmentation)
-
-        tolerance = 3e-1
-        high_tolerance_models = [
-            "mask2former-swin-base-IN21k-coco-instance",
-            "mask2former-swin-base-coco-instance",
-            "mask2former-swin-small-cityscapes-semantic",
-        ]
-
-        if model_name in high_tolerance_models:
-            tolerance = 3e-1
-
-        logger.info(f"🪄 Testing {model_name}...")
-        test(original_model, mask2former_for_segmentation, image_processor, tolerance)
-        logger.info(f"🪄 Pushing {model_name} to hub...")
-
-        image_processor.push_to_hub(model_name)
-        mask2former_for_segmentation.push_to_hub(model_name)
diff --git a/src/transformers/models/maskformer/convert_maskformer_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/maskformer/convert_maskformer_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index b55b0e871480..000000000000
--- a/src/transformers/models/maskformer/convert_maskformer_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,731 +0,0 @@
-# coding=utf-8
-# Copyright 2022 Meta Platforms, Inc. and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import sys
-from argparse import ArgumentParser
-from dataclasses import dataclass
-from pathlib import Path
-from pprint import pformat
-from typing import Any, Dict, Iterator, List, Set, Tuple
-
-import requests
-import torch
-import torchvision.transforms as T
-from detectron2.checkpoint import DetectionCheckpointer
-from detectron2.config import get_cfg
-from detectron2.data import MetadataCatalog
-from detectron2.projects.deeplab import add_deeplab_config
-from PIL import Image
-from torch import Tensor, nn
-
-from transformers.models.maskformer.feature_extraction_maskformer import MaskFormerImageProcessor
-from transformers.models.maskformer.modeling_maskformer import (
-    MaskFormerConfig,
-    MaskFormerForInstanceSegmentation,
-    MaskFormerForInstanceSegmentationOutput,
-    MaskFormerModel,
-    MaskFormerModelOutput,
-)
-from transformers.utils import logging
-
-
-StateDict = Dict[str, Tensor]
-
-logging.set_verbosity_info()
-logger = logging.get_logger()
-
-torch.manual_seed(0)
-
-
-class TrackedStateDict:
-    def __init__(self, to_track: Dict):
-        """This class "tracks" a python dictionary by keeping track of which item is accessed.
-
-        Args:
-            to_track (Dict): The dictionary we wish to track
-        """
-        self.to_track = to_track
-        self._seen: Set[str] = set()
-
-    def __getitem__(self, key: str) -> Any:
-        return self.to_track[key]
-
-    def __setitem__(self, key: str, item: Any):
-        self._seen.add(key)
-        self.to_track[key] = item
-
-    def diff(self) -> List[str]:
-        """This method returns a set difference between the keys in the tracked state dict and the one we have access so far.
-        This is an effective method to check if we have update all the keys
-
-        Returns:
-            List[str]: List of keys not yet updated
-        """
-        return set(self.to_track.keys()) - self._seen
-
-    def copy(self) -> Dict:
-        # proxy the call to the internal dictionary
-        return self.to_track.copy()
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    img_data = requests.get(url, stream=True).raw
-    im = Image.open(img_data)
-    return im
-
-
-@dataclass
-class Args:
-    """Fake command line arguments needed by maskformer/detectron implementation"""
-
-    config_file: str
-
-
-def setup_cfg(args: Args):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    add_deeplab_config(cfg)
-    add_mask_former_config(cfg)
-    cfg.merge_from_file(args.config_file)
-    cfg.freeze()
-    return cfg
-
-
-class OriginalMaskFormerConfigToOursConverter:
-    def __call__(self, original_config: object) -> MaskFormerConfig:
-        model = original_config.MODEL
-        mask_former = model.MASK_FORMER
-        swin = model.SWIN
-
-        dataset_catalog = MetadataCatalog.get(original_config.DATASETS.TEST[0])
-        id2label = dict(enumerate(dataset_catalog.stuff_classes))
-        label2id = {label: idx for idx, label in id2label.items()}
-
-        config: MaskFormerConfig = MaskFormerConfig(
-            fpn_feature_size=model.SEM_SEG_HEAD.CONVS_DIM,
-            mask_feature_size=model.SEM_SEG_HEAD.MASK_DIM,
-            num_labels=model.SEM_SEG_HEAD.NUM_CLASSES,
-            no_object_weight=mask_former.NO_OBJECT_WEIGHT,
-            num_queries=mask_former.NUM_OBJECT_QUERIES,
-            backbone_config={
-                "pretrain_img_size": swin.PRETRAIN_IMG_SIZE,
-                "image_size": swin.PRETRAIN_IMG_SIZE,
-                "in_channels": 3,
-                "patch_size": swin.PATCH_SIZE,
-                "embed_dim": swin.EMBED_DIM,
-                "depths": swin.DEPTHS,
-                "num_heads": swin.NUM_HEADS,
-                "window_size": swin.WINDOW_SIZE,
-                "drop_path_rate": swin.DROP_PATH_RATE,
-                "model_type": "swin",
-            },
-            dice_weight=mask_former.DICE_WEIGHT,
-            ce_weight=1.0,
-            mask_weight=mask_former.MASK_WEIGHT,
-            decoder_config={
-                "model_type": "detr",
-                "max_position_embeddings": 1024,
-                "encoder_layers": 6,
-                "encoder_ffn_dim": 2048,
-                "encoder_attention_heads": 8,
-                "decoder_layers": mask_former.DEC_LAYERS,
-                "decoder_ffn_dim": mask_former.DIM_FEEDFORWARD,
-                "decoder_attention_heads": mask_former.NHEADS,
-                "encoder_layerdrop": 0.0,
-                "decoder_layerdrop": 0.0,
-                "d_model": mask_former.HIDDEN_DIM,
-                "dropout": mask_former.DROPOUT,
-                "attention_dropout": 0.0,
-                "activation_dropout": 0.0,
-                "init_std": 0.02,
-                "init_xavier_std": 1.0,
-                "scale_embedding": False,
-                "auxiliary_loss": False,
-                "dilation": False,
-                # default pretrained config values
-            },
-            id2label=id2label,
-            label2id=label2id,
-        )
-
-        return config
-
-
-class OriginalMaskFormerConfigToImageProcessorConverter:
-    def __call__(self, original_config: object) -> MaskFormerImageProcessor:
-        model = original_config.MODEL
-        model_input = original_config.INPUT
-        dataset_catalog = MetadataCatalog.get(original_config.DATASETS.TEST[0])
-
-        return MaskFormerImageProcessor(
-            image_mean=(torch.tensor(model.PIXEL_MEAN) / 255).tolist(),
-            image_std=(torch.tensor(model.PIXEL_STD) / 255).tolist(),
-            size=model_input.MIN_SIZE_TEST,
-            max_size=model_input.MAX_SIZE_TEST,
-            num_labels=model.SEM_SEG_HEAD.NUM_CLASSES,
-            ignore_index=dataset_catalog.ignore_label,
-            size_divisibility=32,  # 32 is required by swin
-        )
-
-
-class OriginalMaskFormerCheckpointToOursConverter:
-    def __init__(self, original_model: nn.Module, config: MaskFormerConfig):
-        self.original_model = original_model
-        self.config = config
-
-    def pop_all(self, renamed_keys: List[Tuple[str, str]], dst_state_dict: StateDict, src_state_dict: StateDict):
-        for src_key, dst_key in renamed_keys:
-            dst_state_dict[dst_key] = src_state_dict.pop(src_key)
-
-    def replace_backbone(self, dst_state_dict: StateDict, src_state_dict: StateDict, config: MaskFormerConfig):
-        dst_prefix: str = "pixel_level_module.encoder"
-        src_prefix: str = "backbone"
-
-        renamed_keys = [
-            (
-                f"{src_prefix}.patch_embed.proj.weight",
-                f"{dst_prefix}.model.embeddings.patch_embeddings.projection.weight",
-            ),
-            (f"{src_prefix}.patch_embed.proj.bias", f"{dst_prefix}.model.embeddings.patch_embeddings.projection.bias"),
-            (f"{src_prefix}.patch_embed.norm.weight", f"{dst_prefix}.model.embeddings.norm.weight"),
-            (f"{src_prefix}.patch_embed.norm.bias", f"{dst_prefix}.model.embeddings.norm.bias"),
-        ]
-        num_layers = len(config.backbone_config.depths)
-        for layer_idx in range(num_layers):
-            for block_idx in range(config.backbone_config.depths[layer_idx]):
-                renamed_keys.extend(
-                    [  # src, dst
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm1.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_before.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm1.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_before.bias",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.relative_position_bias_table",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.relative_position_bias_table",
-                        ),
-                    ]
-                )
-                # now we need to handle the attentions
-                # read in weights + bias of input projection layer of cross-attention
-
-                src_att_weight = src_state_dict[f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.weight"]
-                src_att_bias = src_state_dict[f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.bias"]
-
-                size = src_att_weight.shape[0]
-                offset = size // 3
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.query.weight"
-                ] = src_att_weight[:offset, :]
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.query.bias"
-                ] = src_att_bias[:offset]
-
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.key.weight"
-                ] = src_att_weight[offset : offset * 2, :]
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.key.bias"
-                ] = src_att_bias[offset : offset * 2]
-
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.value.weight"
-                ] = src_att_weight[-offset:, :]
-                dst_state_dict[
-                    f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.value.bias"
-                ] = src_att_bias[-offset:]
-
-                # let's pop them
-                src_state_dict.pop(f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.weight")
-                src_state_dict.pop(f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.bias")
-                # proj
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.proj.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.output.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.proj.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.output.dense.bias",
-                        ),
-                    ]
-                )
-
-                # second norm
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm2.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_after.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm2.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_after.bias",
-                        ),
-                    ]
-                )
-
-                # mlp
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc1.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.intermediate.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc1.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.intermediate.dense.bias",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc2.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.output.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc2.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.output.dense.bias",
-                        ),
-                    ]
-                )
-
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.relative_position_index",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.relative_position_index",
-                        )
-                    ]
-                )
-
-            if layer_idx < num_layers - 1:
-                # patch merging
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.reduction.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.downsample.reduction.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.norm.weight",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.downsample.norm.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.norm.bias",
-                            f"{dst_prefix}.model.encoder.layers.{layer_idx}.downsample.norm.bias",
-                        ),
-                    ]
-                )
-
-            # hidden states norms
-            renamed_keys.extend(
-                [
-                    (
-                        f"{src_prefix}.norm{layer_idx}.weight",
-                        f"{dst_prefix}.hidden_states_norms.{layer_idx}.weight",
-                    ),
-                    (
-                        f"{src_prefix}.norm{layer_idx}.bias",
-                        f"{dst_prefix}.hidden_states_norms.{layer_idx}.bias",
-                    ),
-                ]
-            )
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def replace_pixel_module(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "pixel_level_module.decoder"
-        src_prefix: str = "sem_seg_head.pixel_decoder"
-
-        self.replace_backbone(dst_state_dict, src_state_dict, self.config)
-
-        def rename_keys_for_conv(detectron_conv: str, mine_conv: str):
-            return [
-                (f"{detectron_conv}.weight", f"{mine_conv}.0.weight"),
-                # 2 cuz the have act in the middle -> rename it
-                (f"{detectron_conv}.norm.weight", f"{mine_conv}.1.weight"),
-                (f"{detectron_conv}.norm.bias", f"{mine_conv}.1.bias"),
-            ]
-
-        renamed_keys = [
-            (f"{src_prefix}.mask_features.weight", f"{dst_prefix}.mask_projection.weight"),
-            (f"{src_prefix}.mask_features.bias", f"{dst_prefix}.mask_projection.bias"),
-            # the layers in the original one are in reverse order, stem is the last one!
-        ]
-
-        renamed_keys.extend(rename_keys_for_conv(f"{src_prefix}.layer_4", f"{dst_prefix}.fpn.stem"))
-
-        # add all the fpn layers (here we need some config parameters to know the size in advance)
-        for src_i, dst_i in zip(range(3, 0, -1), range(0, 3)):
-            renamed_keys.extend(
-                rename_keys_for_conv(f"{src_prefix}.adapter_{src_i}", f"{dst_prefix}.fpn.layers.{dst_i}.proj")
-            )
-            renamed_keys.extend(
-                rename_keys_for_conv(f"{src_prefix}.layer_{src_i}", f"{dst_prefix}.fpn.layers.{dst_i}.block")
-            )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def rename_keys_in_detr_decoder(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module.decoder"
-        src_prefix: str = "sem_seg_head.predictor.transformer.decoder"
-        # not sure why we are not popping direcetly here!
-        # here we list all keys to be renamed (original name on the left, our name on the right)
-        rename_keys = []
-        for i in range(self.config.decoder_config.decoder_layers):
-            # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
-            rename_keys.append(
-                (
-                    f"{src_prefix}.layers.{i}.self_attn.out_proj.weight",
-                    f"{dst_prefix}.layers.{i}.self_attn.out_proj.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.layers.{i}.self_attn.out_proj.bias",
-                    f"{dst_prefix}.layers.{i}.self_attn.out_proj.bias",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.layers.{i}.multihead_attn.out_proj.weight",
-                    f"{dst_prefix}.layers.{i}.encoder_attn.out_proj.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"{src_prefix}.layers.{i}.multihead_attn.out_proj.bias",
-                    f"{dst_prefix}.layers.{i}.encoder_attn.out_proj.bias",
-                )
-            )
-            rename_keys.append((f"{src_prefix}.layers.{i}.linear1.weight", f"{dst_prefix}.layers.{i}.fc1.weight"))
-            rename_keys.append((f"{src_prefix}.layers.{i}.linear1.bias", f"{dst_prefix}.layers.{i}.fc1.bias"))
-            rename_keys.append((f"{src_prefix}.layers.{i}.linear2.weight", f"{dst_prefix}.layers.{i}.fc2.weight"))
-            rename_keys.append((f"{src_prefix}.layers.{i}.linear2.bias", f"{dst_prefix}.layers.{i}.fc2.bias"))
-            rename_keys.append(
-                (f"{src_prefix}.layers.{i}.norm1.weight", f"{dst_prefix}.layers.{i}.self_attn_layer_norm.weight")
-            )
-            rename_keys.append(
-                (f"{src_prefix}.layers.{i}.norm1.bias", f"{dst_prefix}.layers.{i}.self_attn_layer_norm.bias")
-            )
-            rename_keys.append(
-                (f"{src_prefix}.layers.{i}.norm2.weight", f"{dst_prefix}.layers.{i}.encoder_attn_layer_norm.weight")
-            )
-            rename_keys.append(
-                (f"{src_prefix}.layers.{i}.norm2.bias", f"{dst_prefix}.layers.{i}.encoder_attn_layer_norm.bias")
-            )
-            rename_keys.append(
-                (f"{src_prefix}.layers.{i}.norm3.weight", f"{dst_prefix}.layers.{i}.final_layer_norm.weight")
-            )
-            rename_keys.append(
-                (f"{src_prefix}.layers.{i}.norm3.bias", f"{dst_prefix}.layers.{i}.final_layer_norm.bias")
-            )
-
-        return rename_keys
-
-    def replace_q_k_v_in_detr_decoder(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module.decoder"
-        src_prefix: str = "sem_seg_head.predictor.transformer.decoder"
-        for i in range(self.config.decoder_config.decoder_layers):
-            # read in weights + bias of input projection layer of self-attention
-            in_proj_weight = src_state_dict.pop(f"{src_prefix}.layers.{i}.self_attn.in_proj_weight")
-            in_proj_bias = src_state_dict.pop(f"{src_prefix}.layers.{i}.self_attn.in_proj_bias")
-            # next, add query, keys and values (in that order) to the state dict
-            dst_state_dict[f"{dst_prefix}.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-            # read in weights + bias of input projection layer of cross-attention
-            in_proj_weight_cross_attn = src_state_dict.pop(f"{src_prefix}.layers.{i}.multihead_attn.in_proj_weight")
-            in_proj_bias_cross_attn = src_state_dict.pop(f"{src_prefix}.layers.{i}.multihead_attn.in_proj_bias")
-            # next, add query, keys and values (in that order) of cross-attention to the state dict
-            dst_state_dict[f"{dst_prefix}.layers.{i}.encoder_attn.q_proj.weight"] = in_proj_weight_cross_attn[:256, :]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.encoder_attn.q_proj.bias"] = in_proj_bias_cross_attn[:256]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.encoder_attn.k_proj.weight"] = in_proj_weight_cross_attn[
-                256:512, :
-            ]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.encoder_attn.k_proj.bias"] = in_proj_bias_cross_attn[256:512]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.encoder_attn.v_proj.weight"] = in_proj_weight_cross_attn[-256:, :]
-            dst_state_dict[f"{dst_prefix}.layers.{i}.encoder_attn.v_proj.bias"] = in_proj_bias_cross_attn[-256:]
-
-    def replace_detr_decoder(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module.decoder"
-        src_prefix: str = "sem_seg_head.predictor.transformer.decoder"
-        renamed_keys = self.rename_keys_in_detr_decoder(dst_state_dict, src_state_dict)
-        # add more
-        renamed_keys.extend(
-            [
-                (f"{src_prefix}.norm.weight", f"{dst_prefix}.layernorm.weight"),
-                (f"{src_prefix}.norm.bias", f"{dst_prefix}.layernorm.bias"),
-            ]
-        )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-        self.replace_q_k_v_in_detr_decoder(dst_state_dict, src_state_dict)
-
-    def replace_transformer_module(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module"
-        src_prefix: str = "sem_seg_head.predictor"
-
-        self.replace_detr_decoder(dst_state_dict, src_state_dict)
-
-        renamed_keys = [
-            (f"{src_prefix}.query_embed.weight", f"{dst_prefix}.queries_embedder.weight"),
-            (f"{src_prefix}.input_proj.weight", f"{dst_prefix}.input_projection.weight"),
-            (f"{src_prefix}.input_proj.bias", f"{dst_prefix}.input_projection.bias"),
-        ]
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def replace_instance_segmentation_module(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        # NOTE in our case we don't have a prefix, thus we removed the "." from the keys later on!
-        dst_prefix: str = ""
-        src_prefix: str = "sem_seg_head.predictor"
-
-        renamed_keys = [
-            (f"{src_prefix}.class_embed.weight", f"{dst_prefix}class_predictor.weight"),
-            (f"{src_prefix}.class_embed.bias", f"{dst_prefix}class_predictor.bias"),
-        ]
-
-        mlp_len = 3
-        for i in range(mlp_len):
-            renamed_keys.extend(
-                [
-                    (f"{src_prefix}.mask_embed.layers.{i}.weight", f"{dst_prefix}mask_embedder.{i}.0.weight"),
-                    (f"{src_prefix}.mask_embed.layers.{i}.bias", f"{dst_prefix}mask_embedder.{i}.0.bias"),
-                ]
-            )
-        logger.info(f"Replacing keys {pformat(renamed_keys)}")
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def convert(self, mask_former: MaskFormerModel) -> MaskFormerModel:
-        dst_state_dict = TrackedStateDict(mask_former.state_dict())
-        src_state_dict = self.original_model.state_dict()
-
-        self.replace_pixel_module(dst_state_dict, src_state_dict)
-        self.replace_transformer_module(dst_state_dict, src_state_dict)
-
-        logger.info(f"Missed keys are {pformat(dst_state_dict.diff())}")
-        logger.info(f"Not copied keys are {pformat(src_state_dict.keys())}")
-        logger.info("🙌 Done")
-
-        mask_former.load_state_dict(dst_state_dict)
-
-        return mask_former
-
-    def convert_instance_segmentation(
-        self, mask_former: MaskFormerForInstanceSegmentation
-    ) -> MaskFormerForInstanceSegmentation:
-        dst_state_dict = TrackedStateDict(mask_former.state_dict())
-        src_state_dict = self.original_model.state_dict()
-
-        self.replace_instance_segmentation_module(dst_state_dict, src_state_dict)
-
-        mask_former.load_state_dict(dst_state_dict)
-
-        return mask_former
-
-    @staticmethod
-    def using_dirs(checkpoints_dir: Path, config_dir: Path) -> Iterator[Tuple[object, Path, Path]]:
-        checkpoints: List[Path] = checkpoints_dir.glob("**/*.pkl")
-
-        for checkpoint in checkpoints:
-            logger.info(f"💪 Converting {checkpoint.stem}")
-            # find associated config file
-            config: Path = config_dir / checkpoint.parents[0].stem / "swin" / f"{checkpoint.stem}.yaml"
-
-            yield config, checkpoint
-
-
-def test(original_model, our_model: MaskFormerForInstanceSegmentation, image_processor: MaskFormerImageProcessor):
-    with torch.no_grad():
-        original_model = original_model.eval()
-        our_model = our_model.eval()
-
-        im = prepare_img()
-
-        tr = T.Compose(
-            [
-                T.Resize((384, 384)),
-                T.ToTensor(),
-                T.Normalize(
-                    mean=torch.tensor([123.675, 116.280, 103.530]) / 255.0,
-                    std=torch.tensor([58.395, 57.120, 57.375]) / 255.0,
-                ),
-            ],
-        )
-
-        x = tr(im).unsqueeze(0)
-
-        original_model_backbone_features = original_model.backbone(x.clone())
-
-        our_model_output: MaskFormerModelOutput = our_model.model(x.clone(), output_hidden_states=True)
-
-        for original_model_feature, our_model_feature in zip(
-            original_model_backbone_features.values(), our_model_output.encoder_hidden_states
-        ):
-            assert torch.allclose(original_model_feature, our_model_feature, atol=1e-3), (
-                "The backbone features are not the same."
-            )
-
-        original_model_pixel_out = original_model.sem_seg_head.pixel_decoder.forward_features(
-            original_model_backbone_features
-        )
-
-        assert torch.allclose(
-            original_model_pixel_out[0], our_model_output.pixel_decoder_last_hidden_state, atol=1e-4
-        ), "The pixel decoder feature are not the same"
-
-        # let's test the full model
-        original_model_out = original_model([{"image": x.squeeze(0)}])
-
-        original_segmentation = original_model_out[0]["sem_seg"]
-
-        our_model_out: MaskFormerForInstanceSegmentationOutput = our_model(x)
-
-        our_segmentation = image_processor.post_process_segmentation(our_model_out, target_size=(384, 384))
-
-        assert torch.allclose(original_segmentation, our_segmentation, atol=1e-3), (
-            "The segmentation image is not the same."
-        )
-
-        logger.info("✅ Test passed!")
-
-
-def get_name(checkpoint_file: Path):
-    model_name_raw: str = checkpoint_file.stem
-    # model_name_raw is something like maskformer_panoptic_swin_base_IN21k_384_bs64_554k
-    parent_name: str = checkpoint_file.parents[0].stem
-    backbone = "swin"
-    dataset = ""
-    if "coco" in parent_name:
-        dataset = "coco"
-    elif "ade" in parent_name:
-        dataset = "ade"
-    else:
-        raise ValueError(f"{parent_name} must be wrong since we didn't find 'coco' or 'ade' in it ")
-
-    backbone_types = ["tiny", "small", "base", "large"]
-
-    backbone_type = list(filter(lambda x: x in model_name_raw, backbone_types))[0]
-
-    model_name = f"maskformer-{backbone}-{backbone_type}-{dataset}"
-
-    return model_name
-
-
-if __name__ == "__main__":
-    parser = ArgumentParser(
-        description="Command line to convert the original maskformers (with swin backbone) to our implementations."
-    )
-
-    parser.add_argument(
-        "--checkpoints_dir",
-        type=Path,
-        help=(
-            "A directory containing the model's checkpoints. The directory has to have the following structure:"
-            " <DIR_NAME>/<DATASET_NAME>/<CONFIG_NAME>.pkl\n"
-            "Given the files are in the pickle format, please be wary of passing it files you trust."
-        ),
-    )
-    parser.add_argument(
-        "--configs_dir",
-        type=Path,
-        help=(
-            "A directory containing the model's configs, see detectron2 doc. The directory has to have the following"
-            " structure: <DIR_NAME>/<DATASET_NAME>/<CONFIG_NAME>.yaml"
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        required=True,
-        type=Path,
-        help="Path to the folder to output PyTorch models.",
-    )
-    parser.add_argument(
-        "--maskformer_dir",
-        required=True,
-        type=Path,
-        help=(
-            "A path to MaskFormer's original implementation directory. You can download from here:"
-            " https://github.com/facebookresearch/MaskFormer"
-        ),
-    )
-
-    args = parser.parse_args()
-
-    checkpoints_dir: Path = args.checkpoints_dir
-    config_dir: Path = args.configs_dir
-    save_directory: Path = args.pytorch_dump_folder_path
-    maskformer_dir: Path = args.maskformer_dir
-    # append the path to the parents to maskformer dir
-    sys.path.append(str(maskformer_dir.parent))
-    # and import what's needed
-    from MaskFormer.mask_former import add_mask_former_config
-    from MaskFormer.mask_former.mask_former_model import MaskFormer as OriginalMaskFormer
-
-    if not save_directory.exists():
-        save_directory.mkdir(parents=True)
-
-    for config_file, checkpoint_file in OriginalMaskFormerCheckpointToOursConverter.using_dirs(
-        checkpoints_dir, config_dir
-    ):
-        image_processor = OriginalMaskFormerConfigToImageProcessorConverter()(setup_cfg(Args(config_file=config_file)))
-
-        original_config = setup_cfg(Args(config_file=config_file))
-        mask_former_kwargs = OriginalMaskFormer.from_config(original_config)
-
-        original_model = OriginalMaskFormer(**mask_former_kwargs).eval()
-
-        DetectionCheckpointer(original_model).load(str(checkpoint_file))
-
-        config: MaskFormerConfig = OriginalMaskFormerConfigToOursConverter()(original_config)
-
-        mask_former = MaskFormerModel(config=config).eval()
-
-        converter = OriginalMaskFormerCheckpointToOursConverter(original_model, config)
-
-        maskformer = converter.convert(mask_former)
-
-        mask_former_for_instance_segmentation = MaskFormerForInstanceSegmentation(config=config).eval()
-
-        mask_former_for_instance_segmentation.model = mask_former
-        mask_former_for_instance_segmentation = converter.convert_instance_segmentation(
-            mask_former_for_instance_segmentation
-        )
-
-        test(original_model, mask_former_for_instance_segmentation, image_processor)
-
-        model_name = get_name(checkpoint_file)
-        logger.info(f"🪄 Saving {model_name}")
-
-        image_processor.save_pretrained(save_directory / model_name)
-        mask_former_for_instance_segmentation.save_pretrained(save_directory / model_name)
-
-        image_processor.push_to_hub(
-            repo_path_or_name=save_directory / model_name,
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
-        mask_former_for_instance_segmentation.push_to_hub(
-            repo_path_or_name=save_directory / model_name,
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
diff --git a/src/transformers/models/maskformer/convert_maskformer_resnet_to_pytorch.py b/src/transformers/models/maskformer/convert_maskformer_resnet_to_pytorch.py
deleted file mode 100644
index 79ef4917e9d3..000000000000
--- a/src/transformers/models/maskformer/convert_maskformer_resnet_to_pytorch.py
+++ /dev/null
@@ -1,390 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MaskFormer checkpoints with ResNet backbone from the original repository. URL:
-https://github.com/facebookresearch/MaskFormer"""
-
-import argparse
-import json
-import pickle
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, ResNetConfig
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_maskformer_config(model_name: str):
-    if "resnet101c" in model_name:
-        # TODO add support for ResNet-C backbone, which uses a "deeplab" stem
-        raise NotImplementedError("To do")
-    elif "resnet101" in model_name:
-        backbone_config = ResNetConfig.from_pretrained(
-            "microsoft/resnet-101", out_features=["stage1", "stage2", "stage3", "stage4"]
-        )
-    else:
-        backbone_config = ResNetConfig.from_pretrained(
-            "microsoft/resnet-50", out_features=["stage1", "stage2", "stage3", "stage4"]
-        )
-    config = MaskFormerConfig(backbone_config=backbone_config)
-
-    repo_id = "huggingface/label-files"
-    if "ade20k-full" in model_name:
-        config.num_labels = 847
-        filename = "maskformer-ade20k-full-id2label.json"
-    elif "ade" in model_name:
-        config.num_labels = 150
-        filename = "ade20k-id2label.json"
-    elif "coco-stuff" in model_name:
-        config.num_labels = 171
-        filename = "maskformer-coco-stuff-id2label.json"
-    elif "coco" in model_name:
-        # TODO
-        config.num_labels = 133
-        filename = "coco-panoptic-id2label.json"
-    elif "cityscapes" in model_name:
-        config.num_labels = 19
-        filename = "cityscapes-id2label.json"
-    elif "vistas" in model_name:
-        config.num_labels = 65
-        filename = "mapillary-vistas-id2label.json"
-
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-def create_rename_keys(config):
-    rename_keys = []
-    # stem
-    # fmt: off
-    rename_keys.append(("backbone.stem.conv1.weight", "model.pixel_level_module.encoder.embedder.embedder.convolution.weight"))
-    rename_keys.append(("backbone.stem.conv1.norm.weight", "model.pixel_level_module.encoder.embedder.embedder.normalization.weight"))
-    rename_keys.append(("backbone.stem.conv1.norm.bias", "model.pixel_level_module.encoder.embedder.embedder.normalization.bias"))
-    rename_keys.append(("backbone.stem.conv1.norm.running_mean", "model.pixel_level_module.encoder.embedder.embedder.normalization.running_mean"))
-    rename_keys.append(("backbone.stem.conv1.norm.running_var", "model.pixel_level_module.encoder.embedder.embedder.normalization.running_var"))
-    # fmt: on
-    # stages
-    for stage_idx in range(len(config.backbone_config.depths)):
-        for layer_idx in range(config.backbone_config.depths[stage_idx]):
-            # shortcut
-            if layer_idx == 0:
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.shortcut.weight",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.shortcut.norm.weight",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.shortcut.norm.bias",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.shortcut.norm.running_mean",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.shortcut.norm.running_var",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var",
-                    )
-                )
-            # 3 convs
-            for i in range(3):
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.conv{i + 1}.weight",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.conv{i + 1}.norm.weight",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.conv{i + 1}.norm.bias",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.conv{i + 1}.norm.running_mean",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.res{stage_idx + 2}.{layer_idx}.conv{i + 1}.norm.running_var",
-                        f"model.pixel_level_module.encoder.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var",
-                    )
-                )
-
-    # FPN
-    # fmt: off
-    rename_keys.append(("sem_seg_head.layer_4.weight", "model.pixel_level_module.decoder.fpn.stem.0.weight"))
-    rename_keys.append(("sem_seg_head.layer_4.norm.weight", "model.pixel_level_module.decoder.fpn.stem.1.weight"))
-    rename_keys.append(("sem_seg_head.layer_4.norm.bias", "model.pixel_level_module.decoder.fpn.stem.1.bias"))
-    for source_index, target_index in zip(range(3, 0, -1), range(0, 3)):
-        rename_keys.append((f"sem_seg_head.adapter_{source_index}.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight"))
-        rename_keys.append((f"sem_seg_head.adapter_{source_index}.norm.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight"))
-        rename_keys.append((f"sem_seg_head.adapter_{source_index}.norm.bias", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias"))
-        rename_keys.append((f"sem_seg_head.layer_{source_index}.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight"))
-        rename_keys.append((f"sem_seg_head.layer_{source_index}.norm.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight"))
-        rename_keys.append((f"sem_seg_head.layer_{source_index}.norm.bias", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias"))
-    rename_keys.append(("sem_seg_head.mask_features.weight", "model.pixel_level_module.decoder.mask_projection.weight"))
-    rename_keys.append(("sem_seg_head.mask_features.bias", "model.pixel_level_module.decoder.mask_projection.bias"))
-    # fmt: on
-
-    # Transformer decoder
-    # fmt: off
-    for idx in range(config.decoder_config.decoder_layers):
-        # self-attention out projection
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight", f"model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias", f"model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias"))
-        # cross-attention out projection
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight", f"model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias", f"model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias"))
-        # MLP 1
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight", f"model.transformer_module.decoder.layers.{idx}.fc1.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias", f"model.transformer_module.decoder.layers.{idx}.fc1.bias"))
-        # MLP 2
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight", f"model.transformer_module.decoder.layers.{idx}.fc2.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias", f"model.transformer_module.decoder.layers.{idx}.fc2.bias"))
-        # layernorm 1 (self-attention layernorm)
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight", f"model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias", f"model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias"))
-        # layernorm 2 (cross-attention layernorm)
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight", f"model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias", f"model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias"))
-        # layernorm 3 (final layernorm)
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight", f"model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias", f"model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias"))
-
-    rename_keys.append(("sem_seg_head.predictor.transformer.decoder.norm.weight", "model.transformer_module.decoder.layernorm.weight"))
-    rename_keys.append(("sem_seg_head.predictor.transformer.decoder.norm.bias", "model.transformer_module.decoder.layernorm.bias"))
-    # fmt: on
-
-    # heads on top
-    # fmt: off
-    rename_keys.append(("sem_seg_head.predictor.query_embed.weight", "model.transformer_module.queries_embedder.weight"))
-
-    rename_keys.append(("sem_seg_head.predictor.input_proj.weight", "model.transformer_module.input_projection.weight"))
-    rename_keys.append(("sem_seg_head.predictor.input_proj.bias", "model.transformer_module.input_projection.bias"))
-
-    rename_keys.append(("sem_seg_head.predictor.class_embed.weight", "class_predictor.weight"))
-    rename_keys.append(("sem_seg_head.predictor.class_embed.bias", "class_predictor.bias"))
-
-    for i in range(3):
-        rename_keys.append((f"sem_seg_head.predictor.mask_embed.layers.{i}.weight", f"mask_embedder.{i}.0.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.mask_embed.layers.{i}.bias", f"mask_embedder.{i}.0.bias"))
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_decoder_q_k_v(state_dict, config):
-    # fmt: off
-    hidden_size = config.decoder_config.hidden_size
-    for idx in range(config.decoder_config.decoder_layers):
-        # read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.q_proj.weight"] = in_proj_weight[: hidden_size, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.q_proj.bias"] = in_proj_bias[:config.hidden_size]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.k_proj.weight"] = in_proj_weight[hidden_size : hidden_size * 2, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.k_proj.bias"] = in_proj_bias[hidden_size : hidden_size * 2]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.v_proj.weight"] = in_proj_weight[-hidden_size :, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.v_proj.bias"] = in_proj_bias[-hidden_size :]
-        # read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.q_proj.weight"] = in_proj_weight[: hidden_size, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.q_proj.bias"] = in_proj_bias[:config.hidden_size]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.k_proj.weight"] = in_proj_weight[hidden_size : hidden_size * 2, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.k_proj.bias"] = in_proj_bias[hidden_size : hidden_size * 2]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.v_proj.weight"] = in_proj_weight[-hidden_size :, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.v_proj.bias"] = in_proj_bias[-hidden_size :]
-    # fmt: on
-
-
-# We will verify our results on an image of cute cats
-def prepare_img() -> torch.Tensor:
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_maskformer_checkpoint(
-    model_name: str, checkpoint_path: str, pytorch_dump_folder_path: str, push_to_hub: bool = False
-):
-    """
-    Copy/paste/tweak model's weights to our MaskFormer structure.
-    """
-    config = get_maskformer_config(model_name)
-
-    # load original state_dict
-    with open(checkpoint_path, "rb") as f:
-        data = pickle.load(f)
-    state_dict = data["model"]
-
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_decoder_q_k_v(state_dict, config)
-
-    # update to torch tensors
-    for key, value in state_dict.items():
-        state_dict[key] = torch.from_numpy(value)
-
-    # load 🤗 model
-    model = MaskFormerForInstanceSegmentation(config)
-    model.eval()
-
-    model.load_state_dict(state_dict)
-
-    # verify results
-    image = prepare_img()
-    if "vistas" in model_name:
-        ignore_index = 65
-    elif "cityscapes" in model_name:
-        ignore_index = 65535
-    else:
-        ignore_index = 255
-    do_reduce_labels = True if "ade" in model_name else False
-    image_processor = MaskFormerImageProcessor(ignore_index=ignore_index, do_reduce_labels=do_reduce_labels)
-
-    inputs = image_processor(image, return_tensors="pt")
-
-    outputs = model(**inputs)
-
-    if model_name == "maskformer-resnet50-ade":
-        expected_logits = torch.tensor(
-            [[6.7710, -0.1452, -3.5687], [1.9165, -1.0010, -1.8614], [3.6209, -0.2950, -1.3813]]
-        )
-    elif model_name == "maskformer-resnet101-ade":
-        expected_logits = torch.tensor(
-            [[4.0381, -1.1483, -1.9688], [2.7083, -1.9147, -2.2555], [3.4367, -1.3711, -2.1609]]
-        )
-    elif model_name == "maskformer-resnet50-coco-stuff":
-        expected_logits = torch.tensor(
-            [[3.2309, -3.0481, -2.8695], [5.4986, -5.4242, -2.4211], [6.2100, -5.2279, -2.7786]]
-        )
-    elif model_name == "maskformer-resnet101-coco-stuff":
-        expected_logits = torch.tensor(
-            [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]]
-        )
-    elif model_name == "maskformer-resnet101-cityscapes":
-        expected_logits = torch.tensor(
-            [[-1.8861, -1.5465, 0.6749], [-2.3677, -1.6707, -0.0867], [-2.2314, -1.9530, -0.9132]]
-        )
-    elif model_name == "maskformer-resnet50-vistas":
-        expected_logits = torch.tensor(
-            [[-6.3917, -1.5216, -1.1392], [-5.5335, -4.5318, -1.8339], [-4.3576, -4.0301, 0.2162]]
-        )
-    elif model_name == "maskformer-resnet50-ade20k-full":
-        expected_logits = torch.tensor(
-            [[3.6146, -1.9367, -3.2534], [4.0099, 0.2027, -2.7576], [3.3913, -2.3644, -3.9519]]
-        )
-    elif model_name == "maskformer-resnet101-ade20k-full":
-        expected_logits = torch.tensor(
-            [[3.2211, -1.6550, -2.7605], [2.8559, -2.4512, -2.9574], [2.6331, -2.6775, -2.1844]]
-        )
-
-    assert torch.allclose(outputs.class_queries_logits[0, :3, :3], expected_logits, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and image processor of {model_name} to {pytorch_dump_folder_path}")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and image processor of {model_name} to the hub...")
-        model.push_to_hub(f"facebook/{model_name}")
-        image_processor.push_to_hub(f"facebook/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="maskformer-resnet50-ade",
-        type=str,
-        required=True,
-        choices=[
-            "maskformer-resnet50-ade",
-            "maskformer-resnet101-ade",
-            "maskformer-resnet50-coco-stuff",
-            "maskformer-resnet101-coco-stuff",
-            "maskformer-resnet101-cityscapes",
-            "maskformer-resnet50-vistas",
-            "maskformer-resnet50-ade20k-full",
-            "maskformer-resnet101-ade20k-full",
-        ],
-        help=("Name of the MaskFormer model you'd like to convert",),
-    )
-    parser.add_argument(
-        "--checkpoint_path",
-        type=str,
-        required=True,
-        help="Path to the original pickle file (.pkl) of the original checkpoint.\n"
-        "Given the files are in the pickle format, please be wary of passing it files you trust.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_maskformer_checkpoint(
-        args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
-    )
diff --git a/src/transformers/models/maskformer/convert_maskformer_swin_to_pytorch.py b/src/transformers/models/maskformer/convert_maskformer_swin_to_pytorch.py
deleted file mode 100644
index 41e8b4888810..000000000000
--- a/src/transformers/models/maskformer/convert_maskformer_swin_to_pytorch.py
+++ /dev/null
@@ -1,333 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MaskFormer checkpoints with Swin backbone from the original repository. URL:
-https://github.com/facebookresearch/MaskFormer"""
-
-import argparse
-import json
-import pickle
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_maskformer_config(model_name: str):
-    backbone_config = SwinConfig.from_pretrained(
-        "microsoft/swin-tiny-patch4-window7-224", out_features=["stage1", "stage2", "stage3", "stage4"]
-    )
-    config = MaskFormerConfig(backbone_config=backbone_config)
-
-    repo_id = "huggingface/label-files"
-    if "ade20k-full" in model_name:
-        # this should be ok
-        config.num_labels = 847
-        filename = "maskformer-ade20k-full-id2label.json"
-    elif "ade" in model_name:
-        # this should be ok
-        config.num_labels = 150
-        filename = "ade20k-id2label.json"
-    elif "coco-stuff" in model_name:
-        # this should be ok
-        config.num_labels = 171
-        filename = "maskformer-coco-stuff-id2label.json"
-    elif "coco" in model_name:
-        # TODO
-        config.num_labels = 133
-        filename = "coco-panoptic-id2label.json"
-    elif "cityscapes" in model_name:
-        # this should be ok
-        config.num_labels = 19
-        filename = "cityscapes-id2label.json"
-    elif "vistas" in model_name:
-        # this should be ok
-        config.num_labels = 65
-        filename = "mapillary-vistas-id2label.json"
-
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    return config
-
-
-def create_rename_keys(config):
-    rename_keys = []
-    # stem
-    # fmt: off
-    rename_keys.append(("backbone.patch_embed.proj.weight", "model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("backbone.patch_embed.proj.bias", "model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias"))
-    rename_keys.append(("backbone.patch_embed.norm.weight", "model.pixel_level_module.encoder.model.embeddings.norm.weight"))
-    rename_keys.append(("backbone.patch_embed.norm.bias", "model.pixel_level_module.encoder.model.embeddings.norm.bias"))
-    # stages
-    for i in range(len(config.backbone_config.depths)):
-        for j in range(config.backbone_config.depths[i]):
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm1.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm1.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.relative_position_index", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.proj.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.proj.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm2.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm2.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc1.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc1.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc2.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight"))
-            rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc2.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias"))
-
-        if i < 3:
-            rename_keys.append((f"backbone.layers.{i}.downsample.reduction.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight"))
-            rename_keys.append((f"backbone.layers.{i}.downsample.norm.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight"))
-            rename_keys.append((f"backbone.layers.{i}.downsample.norm.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias"))
-        rename_keys.append((f"backbone.norm{i}.weight", f"model.pixel_level_module.encoder.hidden_states_norms.{i}.weight"))
-        rename_keys.append((f"backbone.norm{i}.bias", f"model.pixel_level_module.encoder.hidden_states_norms.{i}.bias"))
-
-    # FPN
-    rename_keys.append(("sem_seg_head.layer_4.weight", "model.pixel_level_module.decoder.fpn.stem.0.weight"))
-    rename_keys.append(("sem_seg_head.layer_4.norm.weight", "model.pixel_level_module.decoder.fpn.stem.1.weight"))
-    rename_keys.append(("sem_seg_head.layer_4.norm.bias", "model.pixel_level_module.decoder.fpn.stem.1.bias"))
-    for source_index, target_index in zip(range(3, 0, -1), range(0, 3)):
-        rename_keys.append((f"sem_seg_head.adapter_{source_index}.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight"))
-        rename_keys.append((f"sem_seg_head.adapter_{source_index}.norm.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight"))
-        rename_keys.append((f"sem_seg_head.adapter_{source_index}.norm.bias", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias"))
-        rename_keys.append((f"sem_seg_head.layer_{source_index}.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight"))
-        rename_keys.append((f"sem_seg_head.layer_{source_index}.norm.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight"))
-        rename_keys.append((f"sem_seg_head.layer_{source_index}.norm.bias", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias"))
-    rename_keys.append(("sem_seg_head.mask_features.weight", "model.pixel_level_module.decoder.mask_projection.weight"))
-    rename_keys.append(("sem_seg_head.mask_features.bias", "model.pixel_level_module.decoder.mask_projection.bias"))
-
-    # Transformer decoder
-    for idx in range(config.decoder_config.decoder_layers):
-        # self-attention out projection
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight", f"model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias", f"model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias"))
-        # cross-attention out projection
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight", f"model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias", f"model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias"))
-        # MLP 1
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight", f"model.transformer_module.decoder.layers.{idx}.fc1.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias", f"model.transformer_module.decoder.layers.{idx}.fc1.bias"))
-        # MLP 2
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight", f"model.transformer_module.decoder.layers.{idx}.fc2.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias", f"model.transformer_module.decoder.layers.{idx}.fc2.bias"))
-        # layernorm 1 (self-attention layernorm)
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight", f"model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias", f"model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias"))
-        # layernorm 2 (cross-attention layernorm)
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight", f"model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias", f"model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias"))
-        # layernorm 3 (final layernorm)
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight", f"model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias", f"model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias"))
-
-    rename_keys.append(("sem_seg_head.predictor.transformer.decoder.norm.weight", "model.transformer_module.decoder.layernorm.weight"))
-    rename_keys.append(("sem_seg_head.predictor.transformer.decoder.norm.bias", "model.transformer_module.decoder.layernorm.bias"))
-
-    # heads on top
-    rename_keys.append(("sem_seg_head.predictor.query_embed.weight", "model.transformer_module.queries_embedder.weight"))
-
-    rename_keys.append(("sem_seg_head.predictor.input_proj.weight", "model.transformer_module.input_projection.weight"))
-    rename_keys.append(("sem_seg_head.predictor.input_proj.bias", "model.transformer_module.input_projection.bias"))
-
-    rename_keys.append(("sem_seg_head.predictor.class_embed.weight", "class_predictor.weight"))
-    rename_keys.append(("sem_seg_head.predictor.class_embed.bias", "class_predictor.bias"))
-
-    for i in range(3):
-        rename_keys.append((f"sem_seg_head.predictor.mask_embed.layers.{i}.weight", f"mask_embedder.{i}.0.weight"))
-        rename_keys.append((f"sem_seg_head.predictor.mask_embed.layers.{i}.bias", f"mask_embedder.{i}.0.bias"))
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_swin_q_k_v(state_dict, backbone_config):
-    num_features = [int(backbone_config.embed_dim * 2**i) for i in range(len(backbone_config.depths))]
-    for i in range(len(backbone_config.depths)):
-        dim = num_features[i]
-        for j in range(backbone_config.depths[i]):
-            # fmt: off
-            # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-            in_proj_weight = state_dict.pop(f"backbone.layers.{i}.blocks.{j}.attn.qkv.weight")
-            in_proj_bias = state_dict.pop(f"backbone.layers.{i}.blocks.{j}.attn.qkv.bias")
-            # next, add query, keys and values (in that order) to the state dict
-            state_dict[f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.query.weight"] = in_proj_weight[:dim, :]
-            state_dict[f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.query.bias"] = in_proj_bias[: dim]
-            state_dict[f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.key.weight"] = in_proj_weight[
-                dim : dim * 2, :
-            ]
-            state_dict[f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.key.bias"] = in_proj_bias[
-                dim : dim * 2
-            ]
-            state_dict[f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.value.weight"] = in_proj_weight[
-                -dim :, :
-            ]
-            state_dict[f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.value.bias"] = in_proj_bias[-dim :]
-            # fmt: on
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_decoder_q_k_v(state_dict, config):
-    # fmt: off
-    hidden_size = config.decoder_config.hidden_size
-    for idx in range(config.decoder_config.decoder_layers):
-        # read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.q_proj.weight"] = in_proj_weight[: hidden_size, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.q_proj.bias"] = in_proj_bias[:config.hidden_size]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.k_proj.weight"] = in_proj_weight[hidden_size : hidden_size * 2, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.k_proj.bias"] = in_proj_bias[hidden_size : hidden_size * 2]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.v_proj.weight"] = in_proj_weight[-hidden_size :, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.self_attn.v_proj.bias"] = in_proj_bias[-hidden_size :]
-        # read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.q_proj.weight"] = in_proj_weight[: hidden_size, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.q_proj.bias"] = in_proj_bias[:config.hidden_size]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.k_proj.weight"] = in_proj_weight[hidden_size : hidden_size * 2, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.k_proj.bias"] = in_proj_bias[hidden_size : hidden_size * 2]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.v_proj.weight"] = in_proj_weight[-hidden_size :, :]
-        state_dict[f"model.transformer_module.decoder.layers.{idx}.encoder_attn.v_proj.bias"] = in_proj_bias[-hidden_size :]
-    # fmt: on
-
-
-# We will verify our results on an image of cute cats
-def prepare_img() -> torch.Tensor:
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_maskformer_checkpoint(
-    model_name: str, checkpoint_path: str, pytorch_dump_folder_path: str, push_to_hub: bool = False
-):
-    """
-    Copy/paste/tweak model's weights to our MaskFormer structure.
-    """
-    config = get_maskformer_config(model_name)
-
-    # load original state_dict
-    with open(checkpoint_path, "rb") as f:
-        data = pickle.load(f)
-    state_dict = data["model"]
-
-    # for name, param in state_dict.items():
-    #     print(name, param.shape)
-
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_swin_q_k_v(state_dict, config.backbone_config)
-    read_in_decoder_q_k_v(state_dict, config)
-
-    # update to torch tensors
-    for key, value in state_dict.items():
-        state_dict[key] = torch.from_numpy(value)
-
-    # load 🤗 model
-    model = MaskFormerForInstanceSegmentation(config)
-    model.eval()
-
-    for name, param in model.named_parameters():
-        print(name, param.shape)
-
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    assert missing_keys == [
-        "model.pixel_level_module.encoder.model.layernorm.weight",
-        "model.pixel_level_module.encoder.model.layernorm.bias",
-    ]
-    assert len(unexpected_keys) == 0, f"Unexpected keys: {unexpected_keys}"
-
-    # verify results
-    image = prepare_img()
-    if "vistas" in model_name:
-        ignore_index = 65
-    elif "cityscapes" in model_name:
-        ignore_index = 65535
-    else:
-        ignore_index = 255
-    do_reduce_labels = True if "ade" in model_name else False
-    image_processor = MaskFormerImageProcessor(ignore_index=ignore_index, do_reduce_labels=do_reduce_labels)
-
-    inputs = image_processor(image, return_tensors="pt")
-
-    outputs = model(**inputs)
-
-    print("Logits:", outputs.class_queries_logits[0, :3, :3])
-
-    if model_name == "maskformer-swin-tiny-ade":
-        expected_logits = torch.tensor(
-            [[3.6353, -4.4770, -2.6065], [0.5081, -4.2394, -3.5343], [2.1909, -5.0353, -1.9323]]
-        )
-    assert torch.allclose(outputs.class_queries_logits[0, :3, :3], expected_logits, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and image processor to {pytorch_dump_folder_path}")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model and image processor to the hub...")
-        model.push_to_hub(f"nielsr/{model_name}")
-        image_processor.push_to_hub(f"nielsr/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="maskformer-swin-tiny-ade",
-        type=str,
-        help=("Name of the MaskFormer model you'd like to convert",),
-    )
-    parser.add_argument(
-        "--checkpoint_path",
-        default="/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl",
-        type=str,
-        help="Path to the original state dict (.pth file).\n"
-        "Given the files are in the pickle format, please be wary of passing it files you trust.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_maskformer_checkpoint(
-        args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
-    )
diff --git a/src/transformers/models/mbart/convert_mbart_original_checkpoint_to_pytorch.py b/src/transformers/models/mbart/convert_mbart_original_checkpoint_to_pytorch.py
deleted file mode 100644
index eb7f00bf7710..000000000000
--- a/src/transformers/models/mbart/convert_mbart_original_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import torch
-from torch import nn
-
-from transformers import MBartConfig, MBartForConditionalGeneration
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = [
-        "encoder.version",
-        "decoder.version",
-        "model.encoder.version",
-        "model.decoder.version",
-        "_float_tensor",
-        "decoder.output_projection.weight",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-def convert_fairseq_mbart_checkpoint_from_disk(
-    checkpoint_path, hf_config_path="facebook/mbart-large-en-ro", finetuned=False, mbart_50=False
-):
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-    remove_ignore_keys_(state_dict)
-    vocab_size = state_dict["encoder.embed_tokens.weight"].shape[0]
-
-    mbart_config = MBartConfig.from_pretrained(hf_config_path, vocab_size=vocab_size)
-    if mbart_50 and finetuned:
-        mbart_config.activation_function = "relu"
-
-    state_dict["shared.weight"] = state_dict["decoder.embed_tokens.weight"]
-    model = MBartForConditionalGeneration(mbart_config)
-    model.model.load_state_dict(state_dict)
-
-    if finetuned:
-        model.lm_head = make_linear_from_emb(model.model.shared)
-
-    return model
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "fairseq_path", type=str, help="bart.large, bart.large.cnn or a path to a model.pt on local filesystem."
-    )
-    parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument(
-        "--hf_config",
-        default="facebook/mbart-large-cc25",
-        type=str,
-        help="Which huggingface architecture to use: mbart-large",
-    )
-    parser.add_argument("--mbart_50", action="store_true", help="whether the model is mMART-50 checkpoint")
-    parser.add_argument("--finetuned", action="store_true", help="whether the model is a fine-tuned checkpoint")
-    args = parser.parse_args()
-    model = convert_fairseq_mbart_checkpoint_from_disk(
-        args.fairseq_path, hf_config_path=args.hf_config, finetuned=args.finetuned, mbart_50=args.mbart_50
-    )
-    model.save_pretrained(args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py b/src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py
deleted file mode 100644
index 0fc67866301f..000000000000
--- a/src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py
+++ /dev/null
@@ -1,334 +0,0 @@
-####################################################################################################
-
-# Copyright (c) 2021-, NVIDIA CORPORATION.  All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-####################################################################################################
-
-#
-# Note: If when running this conversion script you're getting an exception:
-#     ModuleNotFoundError: No module named 'megatron.model.enums'
-# you need to tell python where to find the clone of Megatron-LM, e.g.:
-#
-# cd /tmp
-# git clone https://github.com/NVIDIA/Megatron-LM
-# PYTHONPATH=/tmp/Megatron-LM python src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py ...
-#
-# if you already have it cloned elsewhere, simply adjust the path to the existing path
-#
-# If the training was done using a Megatron-LM fork, e.g.,
-# https://github.com/microsoft/Megatron-DeepSpeed/ then chances are that you need to have that one
-# in your path, i.e., /path/to/Megatron-DeepSpeed/
-#
-
-import argparse
-import os
-import re
-import zipfile
-
-import torch
-
-from transformers import MegatronBertConfig
-
-
-####################################################################################################
-
-
-def recursive_print(name, val, spaces=0):
-    # Format the message.
-    if name is None:
-        msg = None
-    else:
-        fmt = "." * max(0, spaces - 2) + "# {:" + str(50 - spaces) + "s}"
-        msg = fmt.format(name)
-
-    # Print and recurse (if needed).
-    if isinstance(val, dict):
-        if msg is not None:
-            print(msg)
-        for k in val.keys():
-            recursive_print(k, val[k], spaces + 2)
-    elif isinstance(val, torch.Tensor):
-        print(msg, ":", val.size())
-    else:
-        print(msg, ":", val)
-
-
-def fix_query_key_value_ordering(param, checkpoint_version, num_splits, num_heads, hidden_size):
-    # Permutes layout of param tensor to [num_splits * num_heads * hidden_size, :]
-    # for compatibility with later versions of NVIDIA Megatron-LM.
-    # The inverse operation is performed inside Megatron-LM to read checkpoints:
-    # https://github.com/NVIDIA/Megatron-LM/blob/v2.4/megatron/checkpointing.py#L209
-    # If param is the weight tensor of the self-attention block, the returned tensor
-    # will have to be transposed one more time to be read by HuggingFace BERT.
-    input_shape = param.size()
-    if checkpoint_version == 1.0:
-        # version 1.0 stores [num_heads * hidden_size * num_splits, :]
-        saved_shape = (num_heads, hidden_size, num_splits) + input_shape[1:]
-        param = param.view(*saved_shape)
-        param = param.transpose(0, 2)
-        param = param.transpose(1, 2).contiguous()
-    elif checkpoint_version >= 2.0:
-        # other versions store [num_heads * num_splits * hidden_size, :]
-        saved_shape = (num_heads, num_splits, hidden_size) + input_shape[1:]
-        param = param.view(*saved_shape)
-        param = param.transpose(0, 1).contiguous()
-    param = param.view(*input_shape)
-    return param
-
-
-####################################################################################################
-
-
-def convert_megatron_checkpoint(args, input_state_dict, config):
-    # The converted output model.
-    output_state_dict = {}
-
-    # old versions did not store training args
-    ds_args = input_state_dict.get("args", None)
-    if ds_args is not None:
-        # do not make the user write a config file when the exact dimensions/sizes are already in the checkpoint
-        # from pprint import pprint
-        # pprint(vars(ds_args))
-
-        config.tokenizer_type = ds_args.tokenizer_type
-        config.vocab_size = ds_args.padded_vocab_size
-        config.max_position_embeddings = ds_args.max_position_embeddings
-        config.hidden_size = ds_args.hidden_size
-        config.num_hidden_layers = ds_args.num_layers
-        config.num_attention_heads = ds_args.num_attention_heads
-        config.intermediate_size = ds_args.ffn_hidden_size if "ffn_hidden_size" in ds_args else 4 * ds_args.hidden_size
-        # pprint(config)
-
-    # The number of heads.
-    heads = config.num_attention_heads
-    # The hidden_size per head.
-    hidden_size_per_head = config.hidden_size // heads
-    # Megatron-LM checkpoint version
-    if "checkpoint_version" in input_state_dict.keys():
-        checkpoint_version = input_state_dict["checkpoint_version"]
-    else:
-        checkpoint_version = 0.0
-
-    # The model.
-    model = input_state_dict["model"]
-    # The language model.
-    lm = model["language_model"]
-    # The embeddings.
-    embeddings = lm["embedding"]
-
-    # The word embeddings.
-    word_embeddings = embeddings["word_embeddings"]["weight"]
-    # Truncate the embedding table to vocab_size rows.
-    word_embeddings = word_embeddings[: config.vocab_size, :]
-    # Store the word embeddings.
-    output_state_dict["bert.embeddings.word_embeddings.weight"] = word_embeddings
-
-    # The position embeddings.
-    pos_embeddings = embeddings["position_embeddings"]["weight"]
-    assert pos_embeddings.size(0) == config.max_position_embeddings and pos_embeddings.size(1) == config.hidden_size
-    # Store the position embeddings.
-    output_state_dict["bert.embeddings.position_embeddings.weight"] = pos_embeddings
-
-    # The token-type embeddings.
-    tokentype_embeddings = embeddings["tokentype_embeddings"]["weight"]
-    # Store the position embeddings.
-    output_state_dict["bert.embeddings.token_type_embeddings.weight"] = tokentype_embeddings
-
-    # The transformer.
-    transformer = lm["transformer"] if "transformer" in lm.keys() else lm["encoder"]
-
-    # The regex to extract layer names.
-    layer_re = re.compile(r"layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)")
-
-    # The simple map of names for "automated" rules.
-    megatron_to_transformers = {
-        "attention.dense": ".attention.output.dense.",
-        "self_attention.dense": ".attention.output.dense.",
-        "mlp.dense_h_to_4h": ".intermediate.dense.",
-        "mlp.dense_4h_to_h": ".output.dense.",
-    }
-
-    # Keep track of the attention/query/value tensor.
-    attention_qkv_weight = None
-
-    # Extract the layers.
-    for key, val in transformer.items():
-        # Match the name.
-        m = layer_re.match(key)
-
-        # Stop if that's not a layer
-        if m is None:
-            break
-
-        # The index of the layer.
-        layer_idx = int(m.group(1))
-        # The name of the operation.
-        op_name = m.group(2)
-        # Is it a weight or a bias?
-        weight_or_bias = m.group(3)
-
-        # The name of the layer.
-        layer_name = f"bert.encoder.layer.{layer_idx}"
-
-        # For layernorm(s), simply store the layer norm.
-        if op_name.endswith("layernorm"):
-            ln_name = "attention.ln" if op_name.startswith("input") else "ln"
-            output_state_dict[layer_name + "." + ln_name + "." + weight_or_bias] = val
-
-        # Transpose the QKV matrix.
-        elif (
-            op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
-        ) and weight_or_bias == "weight":
-            # Make sure the QKV pointer is nil.
-            assert attention_qkv_weight is None, ""
-
-            out_val = fix_query_key_value_ordering(val, checkpoint_version, 3, heads, hidden_size_per_head)
-            # Store the tensor as we need the bias as well to interleave QKV and biases.
-            attention_qkv_weight = out_val
-
-        # Transpose the bias.
-        elif (
-            op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
-        ) and weight_or_bias == "bias":
-            # Make sure we read the weight tensor.
-            assert attention_qkv_weight is not None, ""
-
-            # Split the QKV matrix into Q, K and V. Megatron stores Q,K,V interleaved.
-            q = attention_qkv_weight[0 * config.hidden_size : 1 * config.hidden_size, :]
-            k = attention_qkv_weight[1 * config.hidden_size : 2 * config.hidden_size, :]
-            v = attention_qkv_weight[2 * config.hidden_size : 3 * config.hidden_size, :]
-
-            out_val = fix_query_key_value_ordering(val, checkpoint_version, 3, heads, hidden_size_per_head)
-            # Split the bias.
-            q_bias = out_val[0 * config.hidden_size : 1 * config.hidden_size]
-            k_bias = out_val[1 * config.hidden_size : 2 * config.hidden_size]
-            v_bias = out_val[2 * config.hidden_size : 3 * config.hidden_size]
-
-            # Store.
-            output_state_dict[f"{layer_name}.attention.self.query.weight"] = q
-            output_state_dict[f"{layer_name}.attention.self.query.bias"] = q_bias
-            output_state_dict[f"{layer_name}.attention.self.key.weight"] = k
-            output_state_dict[f"{layer_name}.attention.self.key.bias"] = k_bias
-            output_state_dict[f"{layer_name}.attention.self.value.weight"] = v
-            output_state_dict[f"{layer_name}.attention.self.value.bias"] = v_bias
-
-            # Clear the stored tensor.
-            attention_qkv_weight = None
-
-        # Copy weights and biases as is.
-        elif weight_or_bias in ["weight", "bias"]:
-            out_name = megatron_to_transformers[op_name]
-            output_state_dict[layer_name + out_name + weight_or_bias] = val
-
-    # The final layernorm.
-    output_state_dict["bert.encoder.ln.weight"] = transformer["final_layernorm.weight"]
-    output_state_dict["bert.encoder.ln.bias"] = transformer["final_layernorm.bias"]
-
-    # The pooler.
-    pooler = lm["pooler"]
-
-    # Store the matrix and the bias.
-    output_state_dict["bert.pooler.dense.weight"] = pooler["dense.weight"]
-    output_state_dict["bert.pooler.dense.bias"] = pooler["dense.bias"]
-
-    # The LM head from Megatron (for RACE).
-    lm_head = model["lm_head"]
-
-    # The transform matrix.
-    output_state_dict["cls.predictions.transform.dense.weight"] = lm_head["dense.weight"]
-    output_state_dict["cls.predictions.transform.dense.bias"] = lm_head["dense.bias"]
-
-    # The transform LN.
-    output_state_dict["cls.predictions.transform.LayerNorm.weight"] = lm_head["layernorm.weight"]
-    output_state_dict["cls.predictions.transform.LayerNorm.bias"] = lm_head["layernorm.bias"]
-
-    # For the decoder, we replicate the weights.
-    output_state_dict["cls.predictions.decoder.weight"] = word_embeddings
-    output_state_dict["cls.predictions.bias"] = lm_head["bias"]
-
-    # The classifier from Megatron (for MLNI).
-    binary_head = model["binary_head"]
-
-    # Store the classifier.
-    output_state_dict["cls.seq_relationship.weight"] = binary_head["weight"]
-    output_state_dict["cls.seq_relationship.bias"] = binary_head["bias"]
-
-    # It should be done!
-    return output_state_dict
-
-
-####################################################################################################
-
-
-def main():
-    # Create the argument parser.
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--print-checkpoint-structure", action="store_true")
-    parser.add_argument("path_to_checkpoint", type=str, help="Path to the ZIP file containing the checkpoint")
-    parser.add_argument(
-        "--config_file",
-        default="",
-        type=str,
-        help="An optional config json file describing the pre-trained model.",
-    )
-    args = parser.parse_args()
-
-    # Extract the basename.
-    basename = os.path.dirname(args.path_to_checkpoint)
-
-    # Load the model.
-    # the .zip is very optional, let's keep it for backward compatibility
-    print(f'Extracting PyTorch state dictionary from "{args.path_to_checkpoint}"')
-    if args.path_to_checkpoint.endswith(".zip"):
-        with zipfile.ZipFile(args.path_to_checkpoint, "r") as checkpoint:
-            with checkpoint.open("release/mp_rank_00/model_optim_rng.pt") as pytorch_dict:
-                input_state_dict = torch.load(pytorch_dict, map_location="cpu")
-    else:
-        input_state_dict = torch.load(args.path_to_checkpoint, map_location="cpu")
-
-    if args.config_file == "":
-        # Default config of megatron-bert 345m
-        config = MegatronBertConfig()
-
-        # different megatron-bert-*-345m models have different vocab sizes, so override the default
-        # config (which is for megatron-bert-cased-345m) with the actual vocab dimension
-        config.vocab_size = input_state_dict["model"]["lm_head"]["bias"].numel()
-    else:
-        config = MegatronBertConfig.from_json_file(args.config_file)
-
-    # Convert.
-    print("Converting")
-    output_state_dict = convert_megatron_checkpoint(args, input_state_dict, config)
-
-    # Print the structure of converted state dict.
-    if args.print_checkpoint_structure:
-        recursive_print(None, output_state_dict)
-
-    # Store the config to file.
-    print("Saving config")
-    config.save_pretrained(basename)
-
-    # Store the state_dict to file.
-    output_checkpoint_file = os.path.join(basename, "pytorch_model.bin")
-    print(f'Saving checkpoint to "{output_checkpoint_file}"')
-    torch.save(output_state_dict, output_checkpoint_file)
-
-
-####################################################################################################
-
-if __name__ == "__main__":
-    main()
-
-####################################################################################################
diff --git a/src/transformers/models/megatron_gpt2/convert_megatron_gpt2_checkpoint.py b/src/transformers/models/megatron_gpt2/convert_megatron_gpt2_checkpoint.py
deleted file mode 100644
index 38060f8af5c7..000000000000
--- a/src/transformers/models/megatron_gpt2/convert_megatron_gpt2_checkpoint.py
+++ /dev/null
@@ -1,358 +0,0 @@
-####################################################################################################
-
-# Copyright (c) 2021-, NVIDIA CORPORATION.  All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-####################################################################################################
-
-#
-# Note: If when running this conversion script you're getting an exception:
-#     ModuleNotFoundError: No module named 'megatron.model.enums'
-# you need to tell python where to find the clone of Megatron-LM, e.g.:
-#
-# cd /tmp
-# git clone https://github.com/NVIDIA/Megatron-LM
-# PYTHONPATH=/tmp/Megatron-LM python src/transformers/models/megatron_gpt2/convert_megatron_gpt2_checkpoint.py ...
-#
-# if you already have it cloned elsewhere, simply adjust the path to the existing path
-#
-# If the training was done using a Megatron-LM fork, e.g.,
-# https://github.com/microsoft/Megatron-DeepSpeed/ then chances are that you need to have that one
-# in your path, i.e., /path/to/Megatron-DeepSpeed/
-#
-
-import argparse
-import os
-import re
-import zipfile
-
-import torch
-
-from transformers import AutoTokenizer, GPT2Config
-
-
-####################################################################################################
-
-
-def recursive_print(name, val, spaces=0):
-    # Format the message.
-    if name is None:
-        msg = None
-    else:
-        fmt = "." * max(0, spaces - 2) + "# {:" + str(50 - spaces) + "s}"
-        msg = fmt.format(name)
-
-    # Print and recurse (if needed).
-    if isinstance(val, dict):
-        if msg is not None:
-            print(msg)
-        for k in val.keys():
-            recursive_print(k, val[k], spaces + 2)
-    elif isinstance(val, torch.Tensor):
-        print(msg, ":", val.size())
-    else:
-        print(msg, ":", val)
-
-
-def fix_query_key_value_ordering(param, checkpoint_version, num_splits, num_heads, hidden_size):
-    # Permutes layout of param tensor to [num_splits * num_heads * hidden_size, :]
-    # for compatibility with later versions of NVIDIA Megatron-LM.
-    # The inverse operation is performed inside Megatron-LM to read checkpoints:
-    # https://github.com/NVIDIA/Megatron-LM/blob/v2.4/megatron/checkpointing.py#L209
-    # If param is the weight tensor of the self-attention block, the returned tensor
-    # will have to be transposed one more time to be read by HuggingFace GPT2.
-    input_shape = param.size()
-    if checkpoint_version == 1.0:
-        # version 1.0 stores [num_heads * hidden_size * num_splits, :]
-        saved_shape = (num_heads, hidden_size, num_splits) + input_shape[1:]
-        param = param.view(*saved_shape)
-        param = param.transpose(0, 2)
-        param = param.transpose(1, 2).contiguous()
-    elif checkpoint_version >= 2.0:
-        # other versions store [num_heads * num_splits * hidden_size, :]
-        saved_shape = (num_heads, num_splits, hidden_size) + input_shape[1:]
-        param = param.view(*saved_shape)
-        param = param.transpose(0, 1).contiguous()
-    param = param.view(*input_shape)
-    return param
-
-
-####################################################################################################
-
-
-def convert_megatron_checkpoint(args, input_state_dict, config):
-    # The converted output model.
-    output_state_dict = {}
-
-    # old versions did not store training args
-    ds_args = input_state_dict.get("args", None)
-    if ds_args is not None:
-        # do not make the user write a config file when the exact dimensions/sizes are already in the checkpoint
-        # from pprint import pprint
-        # pprint(vars(ds_args))
-
-        config.vocab_size = ds_args.padded_vocab_size
-        config.n_positions = ds_args.max_position_embeddings
-        config.n_embd = ds_args.hidden_size
-        config.n_layer = ds_args.num_layers
-        config.n_head = ds_args.num_attention_heads
-        config.n_inner = ds_args.ffn_hidden_size
-        # pprint(config)
-
-    # The number of heads.
-    heads = config.n_head
-    # The hidden_size per head.
-    hidden_size_per_head = config.n_embd // config.n_head
-    # Megatron-LM checkpoint version
-    if "checkpoint_version" in input_state_dict.keys():
-        checkpoint_version = input_state_dict["checkpoint_version"]
-    else:
-        checkpoint_version = 0.0
-
-    # The model.
-    model = input_state_dict["model"]
-    # The language model.
-    lm = model["language_model"]
-    # The embeddings.
-    embeddings = lm["embedding"]
-
-    # The word embeddings.
-    word_embeddings = embeddings["word_embeddings"]["weight"]
-    # Truncate the embedding table to vocab_size rows.
-    word_embeddings = word_embeddings[: config.vocab_size, :]
-    output_state_dict["transformer.wte.weight"] = word_embeddings
-
-    # The position embeddings.
-    pos_embeddings = embeddings["position_embeddings"]["weight"]
-    # Read the causal mask dimension (seqlen). [max_sequence_length, hidden_size]
-    n_positions = pos_embeddings.size(0)
-    if n_positions != config.n_positions:
-        raise ValueError(
-            f"pos_embeddings.max_sequence_length={n_positions} and config.n_positions={config.n_positions} don't match"
-        )
-    # Store the position embeddings.
-    output_state_dict["transformer.wpe.weight"] = pos_embeddings
-
-    # The transformer.
-    transformer = lm["transformer"] if "transformer" in lm.keys() else lm["encoder"]
-
-    # The regex to extract layer names.
-    layer_re = re.compile(r"layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)")
-
-    # The simple map of names for "automated" rules.
-    megatron_to_transformers = {
-        "attention.dense": ".attn.c_proj.",
-        "self_attention.dense": ".attn.c_proj.",
-        "mlp.dense_h_to_4h": ".mlp.c_fc.",
-        "mlp.dense_4h_to_h": ".mlp.c_proj.",
-    }
-
-    # Extract the layers.
-    for key, val in transformer.items():
-        # Match the name.
-        m = layer_re.match(key)
-
-        # Stop if that's not a layer
-        if m is None:
-            break
-
-        # The index of the layer.
-        layer_idx = int(m.group(1))
-        # The name of the operation.
-        op_name = m.group(2)
-        # Is it a weight or a bias?
-        weight_or_bias = m.group(3)
-
-        # The name of the layer.
-        layer_name = f"transformer.h.{layer_idx}"
-
-        # For layernorm(s), simply store the layer norm.
-        if op_name.endswith("layernorm"):
-            ln_name = "ln_1" if op_name.startswith("input") else "ln_2"
-            output_state_dict[layer_name + "." + ln_name + "." + weight_or_bias] = val
-
-        # Transpose the QKV matrix.
-        elif (
-            op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
-        ) and weight_or_bias == "weight":
-            # Insert a tensor of 1x1xDxD bias.
-            causal_mask = torch.tril(torch.ones((n_positions, n_positions), dtype=torch.float16)).view(
-                1, 1, n_positions, n_positions
-            )
-            output_state_dict[layer_name + ".attn.bias"] = causal_mask
-
-            # Insert a "dummy" tensor for masked_bias.
-            masked_bias = torch.tensor(-1e4, dtype=torch.float16)
-            output_state_dict[layer_name + ".attn.masked_bias"] = masked_bias
-
-            out_val = fix_query_key_value_ordering(val, checkpoint_version, 3, heads, hidden_size_per_head)
-            # Megatron stores (3*D) x D but transformers-GPT2 expects D x 3*D.
-            out_val = out_val.transpose(0, 1).contiguous()
-            # Store.
-            output_state_dict[layer_name + ".attn.c_attn.weight"] = out_val
-
-        # Transpose the bias.
-        elif (
-            op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
-        ) and weight_or_bias == "bias":
-            out_val = fix_query_key_value_ordering(val, checkpoint_version, 3, heads, hidden_size_per_head)
-            # Store. No change of shape.
-            output_state_dict[layer_name + ".attn.c_attn.bias"] = out_val
-
-        # Transpose the weights.
-        elif weight_or_bias == "weight":
-            out_name = megatron_to_transformers[op_name]
-            output_state_dict[layer_name + out_name + "weight"] = val.transpose(0, 1)
-
-        # Copy the bias.
-        elif weight_or_bias == "bias":
-            out_name = megatron_to_transformers[op_name]
-            output_state_dict[layer_name + out_name + "bias"] = val
-
-    # DEBUG.
-    assert config.n_layer == layer_idx + 1
-
-    # The final layernorm.
-    output_state_dict["transformer.ln_f.weight"] = transformer["final_layernorm.weight"]
-    output_state_dict["transformer.ln_f.bias"] = transformer["final_layernorm.bias"]
-
-    # For LM head, transformers' wants the matrix to weight embeddings.
-    output_state_dict["lm_head.weight"] = word_embeddings
-
-    # It should be done!
-    return output_state_dict
-
-
-####################################################################################################
-
-
-def main():
-    # Create the argument parser.
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--print-checkpoint-structure", action="store_true")
-    parser.add_argument(
-        "path_to_checkpoint",
-        type=str,
-        help="Path to the checkpoint file (.zip archive or direct .pt file)",
-    )
-    parser.add_argument(
-        "--config_file",
-        default="",
-        type=str,
-        help="An optional config json file describing the pre-trained model.",
-    )
-    args = parser.parse_args()
-
-    # Extract the basename.
-    basename = os.path.dirname(args.path_to_checkpoint)
-
-    # Load the model.
-    # the .zip is very optional, let's keep it for backward compatibility
-    print(f"Extracting PyTorch state dictionary from {args.path_to_checkpoint}")
-    if args.path_to_checkpoint.endswith(".zip"):
-        with zipfile.ZipFile(args.path_to_checkpoint, "r") as checkpoint:
-            with checkpoint.open("release/mp_rank_00/model_optim_rng.pt") as pytorch_dict:
-                input_state_dict = torch.load(pytorch_dict, map_location="cpu")
-    else:
-        input_state_dict = torch.load(args.path_to_checkpoint, map_location="cpu")
-
-    ds_args = input_state_dict.get("args", None)
-
-    # Read the config, or default to the model released by NVIDIA.
-    if args.config_file == "":
-        if ds_args is not None:
-            if ds_args.bias_gelu_fusion:
-                activation_function = "gelu_fast"
-            elif ds_args.openai_gelu:
-                activation_function = "gelu_new"
-            else:
-                activation_function = "gelu"
-        else:
-            # in the very early days this used to be "gelu_new"
-            activation_function = "gelu_new"
-
-        # Spell out all parameters in case the defaults change.
-        config = GPT2Config(
-            vocab_size=50257,
-            n_positions=1024,
-            n_embd=1024,
-            n_layer=24,
-            n_head=16,
-            n_inner=4096,
-            activation_function=activation_function,
-            resid_pdrop=0.1,
-            embd_pdrop=0.1,
-            attn_pdrop=0.1,
-            layer_norm_epsilon=1e-5,
-            initializer_range=0.02,
-            summary_type="cls_index",
-            summary_use_proj=True,
-            summary_activation=None,
-            summary_proj_to_labels=True,
-            summary_first_dropout=0.1,
-            scale_attn_weights=True,
-            use_cache=True,
-            bos_token_id=50256,
-            eos_token_id=50256,
-        )
-    else:
-        config = GPT2Config.from_json_file(args.config_file)
-
-    config.architectures = ["GPT2LMHeadModel"]
-
-    # Convert.
-    print("Converting")
-    output_state_dict = convert_megatron_checkpoint(args, input_state_dict, config)
-
-    # Print the structure of converted state dict.
-    if args.print_checkpoint_structure:
-        recursive_print(None, output_state_dict)
-
-    # Add tokenizer class info to config
-    # see https://github.com/huggingface/transformers/issues/13906)
-    if ds_args is not None:
-        tokenizer_type = ds_args.tokenizer_type
-        if tokenizer_type == "GPT2BPETokenizer":
-            tokenizer_model_name = "openai-community/gpt2"
-        elif tokenizer_type == "PretrainedFromHF":
-            tokenizer_model_name = ds_args.tokenizer_name_or_path
-        else:
-            raise ValueError(f"Unrecognized tokenizer_type {tokenizer_type}")
-    else:
-        tokenizer_model_name = "openai-community/gpt2"
-
-    tokenizer = AutoTokenizer.from_pretrained(tokenizer_model_name)
-    tokenizer_class = type(tokenizer).__name__
-    config.tokenizer_class = tokenizer_class
-
-    # Store the config to file.
-    print("Saving config")
-    config.save_pretrained(basename)
-
-    # Save tokenizer based on args
-    print(f"Adding {tokenizer_class} tokenizer files")
-    tokenizer.save_pretrained(basename)
-
-    # Store the state_dict to file.
-    output_checkpoint_file = os.path.join(basename, "pytorch_model.bin")
-    print(f'Saving checkpoint to "{output_checkpoint_file}"')
-    torch.save(output_state_dict, output_checkpoint_file)
-
-
-####################################################################################################
-
-if __name__ == "__main__":
-    main()
-
-####################################################################################################
diff --git a/src/transformers/models/mimi/convert_mimi_checkpoint_to_pytorch.py b/src/transformers/models/mimi/convert_mimi_checkpoint_to_pytorch.py
deleted file mode 100644
index 75702aadd314..000000000000
--- a/src/transformers/models/mimi/convert_mimi_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,198 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Mimi checkpoints."""
-
-import argparse
-
-import safetensors
-import torch
-
-from transformers import (
-    EncodecFeatureExtractor,
-    MimiConfig,
-    MimiModel,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.mimi")
-
-
-def assert_param_count(model_1, model_2):
-    count_1 = sum(p[1].numel() for p in model_1.named_parameters() if "final_proj" not in p[0])
-    count_2 = sum(p[1].numel() for p in model_2.named_parameters() if "final_proj" not in p[0])
-    assert count_1 == count_2, f"{model_1.__class__}: {count_1} != {model_2.__class__}: {count_2}"
-
-
-def param_count(model):
-    return sum(p[1].numel() for p in model.named_parameters() if "final_proj" not in p[0])
-
-
-def _grab_best_device(use_gpu=True):
-    if torch.cuda.device_count() > 0 and use_gpu:
-        device = "cuda"
-    else:
-        device = "cpu"
-    return torch.device(device)
-
-
-convert_list = [
-    # GENERAL
-    ("conv.conv.conv", "conv"),
-    ("convtr.convtr.convtr", "conv"),
-    ("conv.conv", "conv"),
-    ("convtr.convtr", "conv"),
-    # QUANTIZER
-    ("quantizer.rvq_first.vq", "quantizer.semantic_residual_vector_quantizer"),
-    ("quantizer.rvq_first", "quantizer.semantic_residual_vector_quantizer"),
-    ("quantizer.rvq_rest.vq", "quantizer.acoustic_residual_vector_quantizer"),
-    ("quantizer.rvq_rest", "quantizer.acoustic_residual_vector_quantizer"),
-    ("_codebook", "codebook"),
-    ("_initialized", "initialized"),
-    ("embedding_sum", "embed_sum"),
-    # ENCODER PART
-    ("encoder.model", "encoder.layers"),
-    ("decoder.model", "decoder.layers"),
-    # TRANSFORMERS PART
-    ("encoder_transformer.transformer", "encoder_transformer"),
-    ("decoder_transformer.transformer", "decoder_transformer"),
-    ("linear1", "mlp.fc1"),
-    ("linear2", "mlp.fc2"),
-    ("self_attn.out_proj", "self_attn.o_proj"),
-    ("norm1", "input_layernorm"),
-    ("norm2", "post_attention_layernorm"),
-    ("layer_scale_1", "self_attn_layer_scale"),
-    ("layer_scale_2", "mlp_layer_scale"),
-]
-
-
-def _convert_model(
-    state_dict,
-    hf_model,
-    convert_list,
-    device,
-    config,
-    unwanted_prefix=None,
-):
-    hidden_size = config.hidden_size
-    head_dim = config.head_dim
-    num_heads = int(config.hidden_size // config.head_dim)
-    num_key_value_heads = config.num_key_value_heads
-    key_value_head_dim = config.num_key_value_heads * head_dim
-
-    # permute for sliced rotary
-    def permute(w, n_heads, dim1=hidden_size, dim2=hidden_size):
-        return w.view(n_heads, dim1 // n_heads // 2, 2, dim2).transpose(1, 2).reshape(dim1, dim2)
-
-    for k, v in list(state_dict.items()):
-        new_k = k if unwanted_prefix is None else k[len(unwanted_prefix) :]
-        for old_layer_name, new_layer_name in convert_list:
-            if old_layer_name in new_k:
-                new_k = new_k.replace(old_layer_name, new_layer_name)
-
-        if "in_proj_weight" in new_k:
-            # split qkv into query key and value
-            mixed_qkv = state_dict.pop(k)
-            qkv_dim = mixed_qkv.size(0) // 3
-
-            query_layer = mixed_qkv[:qkv_dim]
-            key_layer = mixed_qkv[qkv_dim : qkv_dim * 2]
-            value_layer = mixed_qkv[qkv_dim * 2 :]
-
-            state_dict[new_k.replace("in_proj_weight", "q_proj.weight")] = permute(query_layer, num_heads)
-            state_dict[new_k.replace("in_proj_weight", "k_proj.weight")] = permute(
-                key_layer, num_key_value_heads, dim1=key_value_head_dim
-            )
-            state_dict[new_k.replace("in_proj_weight", "v_proj.weight")] = value_layer
-        else:
-            state_dict[new_k] = state_dict.pop(k)
-
-    extra_keys = set(state_dict.keys()) - set(hf_model.state_dict().keys())
-    missing_keys = set(hf_model.state_dict().keys()) - set(state_dict.keys())
-    if len(extra_keys) != 0:
-        raise ValueError(f"extra keys found: {extra_keys}")
-    if len(missing_keys) != 0:
-        raise ValueError(f"missing keys: {missing_keys}")
-    hf_model.load_state_dict(state_dict, strict=True)
-    n_params = param_count(hf_model)
-
-    logger.info(f"model loaded: {round(n_params / 1e6, 1)}M params")
-
-    hf_model.eval()
-    hf_model.to(device)
-    del state_dict
-
-    return hf_model
-
-
-@torch.no_grad()
-def convert_checkpoint(
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    config_path=None,
-    repo_id=None,
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    device = _grab_best_device()
-
-    if config_path is not None:
-        config = MimiConfig.from_pretrained(config_path)
-    else:
-        config = MimiConfig()
-
-    model = MimiModel(config)
-
-    feature_extractor = EncodecFeatureExtractor(
-        feature_size=config.audio_channels,
-        sampling_rate=config.sampling_rate,
-    )
-    feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-    original_checkpoint = safetensors.torch.load_file(checkpoint_path)
-    if "best_state" in original_checkpoint:
-        # we might have a training state saved, in which case discard the yaml results and just retain the weights
-        original_checkpoint = original_checkpoint["best_state"]
-
-    model = _convert_model(original_checkpoint, model, convert_list, device, config)
-
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        feature_extractor.push_to_hub(repo_id)
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_checkpoint(
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.config_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/mistral/convert_mistral_weights_to_hf.py b/src/transformers/models/mistral/convert_mistral_weights_to_hf.py
deleted file mode 100644
index e7f9da0015c5..000000000000
--- a/src/transformers/models/mistral/convert_mistral_weights_to_hf.py
+++ /dev/null
@@ -1,282 +0,0 @@
-# Copyright 2023 Mistral AI and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import json
-import os
-import re
-
-import torch
-from safetensors.torch import load_file
-
-from transformers import AutoTokenizer, LlamaTokenizerFast, MistralConfig, MistralForCausalLM
-from transformers.integrations.mistral import convert_tekken_tokenizer
-
-
-# fmt: off
-STATE_DICT_MAPPING = {
-    # CausalLM keys
-    r"^output.weight":                            r"lm_head.weight",
-
-    # Model keys
-    r"^norm.weight":                              r"model.norm.weight",
-    r"^tok_embeddings.weight":                    r"model.embed_tokens.weight",
-
-    # Layers keys
-    r"^layers.(\d+).attention_norm.weight":       r"model.layers.\1.input_layernorm.weight",
-    r"^layers.(\d+).ffn_norm.weight":             r"model.layers.\1.post_attention_layernorm.weight",
-
-    # Attention keys
-    r"^layers.(\d+).attention.w(q|k|v|o).weight": r"model.layers.\1.self_attn.\2_proj.weight",
-
-
-    # MLP keys
-    r"^layers.(\d+).feed_forward.w1.weight":      r"model.layers.\1.mlp.gate_proj.weight",
-    r"^layers.(\d+).feed_forward.w2.weight":      r"model.layers.\1.mlp.down_proj.weight",
-    r"^layers.(\d+).feed_forward.w3.weight":      r"model.layers.\1.mlp.up_proj.weight",
-}
-# fmt: on
-
-
-def map_old_key_to_new(old_key):
-    """Map of a key of the original state dict to the equivalent key in HF format"""
-    for pattern, replacement in STATE_DICT_MAPPING.items():
-        new_key, n_replace = re.subn(pattern, replacement, old_key)
-        # Early exit of the loop
-        if n_replace > 0:
-            return new_key
-
-    raise ValueError(f"Key: {old_key} could not be mapped (check the mapping).")
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def permute_for_rope(tensor, n_heads, dim1, dim2):
-    """Permute the weights for the ROPE formulation."""
-    tensor = tensor.view(n_heads, dim1 // n_heads // 2, 2, dim2)
-    tensor = tensor.transpose(1, 2)
-    tensor = tensor.reshape(dim1, dim2)
-    return tensor
-
-
-def convert_state_dict(original_state_dict: dict, config: MistralConfig):
-    """Convert a state dict file, when a single `nn.Module` is never sharded in different files (usual case)."""
-    new_dict = {}
-
-    num_attention_heads = config.num_attention_heads
-    hidden_size = config.hidden_size
-    head_dim = config.head_dim
-    num_key_value_heads = config.num_key_value_heads
-    key_value_dim = head_dim * num_key_value_heads
-    query_dim = head_dim * num_attention_heads
-
-    for old_key, tensor in original_state_dict.items():
-        new_key = map_old_key_to_new(old_key)
-
-        if "q_proj" in new_key:
-            tensor = tensor.view(num_attention_heads, head_dim, hidden_size).reshape(query_dim, hidden_size)
-            tensor = permute_for_rope(tensor, num_attention_heads, query_dim, hidden_size)
-        elif "k_proj" in new_key:
-            tensor = tensor.view(num_key_value_heads, head_dim, hidden_size).reshape(key_value_dim, hidden_size)
-            tensor = permute_for_rope(tensor, num_key_value_heads, key_value_dim, hidden_size)
-        elif "v_proj" in new_key:
-            tensor = tensor.view(num_key_value_heads, head_dim, hidden_size).reshape(key_value_dim, hidden_size)
-
-        new_dict[new_key] = tensor
-    return new_dict
-
-
-def get_concat_dim(key):
-    """Return the dimension to concatenate the weights on."""
-    concat_dim_1 = [
-        r"model.embed_tokens.weight",
-        r"model.layers.(\d+).self_attn.o_proj.weight",
-        r"model.layers.(\d+).mlp.down_proj.weight",
-    ]
-    if any(re.search(pattern, key) for pattern in concat_dim_1):
-        return 1
-    return 0
-
-
-def convert_state_dict_sharded(loaded_shards: list[dict], config: MistralConfig):
-    """Convert the state dict, when a single `nn.Module` is sharded across different files."""
-    new_dict = {}
-
-    num_shards = len(loaded_shards)
-
-    n_heads = config.num_attention_heads
-    dim = config.hidden_size
-    dims_per_head = dim // n_heads
-    num_key_value_heads = config.num_key_value_heads
-    n_heads_per_shard = n_heads // num_shards
-    num_local_key_value_heads = num_key_value_heads // num_shards
-    key_value_dim = dim if n_heads == num_key_value_heads else dims_per_head * num_local_key_value_heads
-
-    original_keys = loaded_shards[0].keys()
-    for old_key in original_keys:
-        new_key = map_old_key_to_new(old_key)
-        cat_dim = get_concat_dim(new_key)
-
-        if "q_proj" in new_key:
-            tensor = torch.cat(
-                [shard.pop(old_key).view(n_heads_per_shard, dims_per_head, dim) for shard in loaded_shards],
-                dim=cat_dim,
-            ).reshape(dim, dim)
-            tensor = permute_for_rope(tensor, n_heads, dim, dim)
-        elif "k_proj" in new_key:
-            tensor = torch.cat(
-                [shard.pop(old_key).view(num_local_key_value_heads, dims_per_head, dim) for shard in loaded_shards],
-                dim=cat_dim,
-            ).reshape(key_value_dim, dim)
-            tensor = permute_for_rope(tensor, num_key_value_heads, key_value_dim, dim)
-        elif "v_proj" in new_key:
-            tensor = torch.cat(
-                [shard.pop(old_key).view(num_local_key_value_heads, dims_per_head, dim) for shard in loaded_shards],
-                dim=cat_dim,
-            ).reshape(key_value_dim, dim)
-        elif "input_layernorm" in new_key or "post_attention_layernorm" in new_key:
-            tensor = loaded_shards[0][old_key].clone()
-        elif "model.norm.weight" in new_key:
-            tensor = loaded_shards[0][old_key]
-        else:
-            tensor = torch.cat([shard.pop(old_key) for shard in loaded_shards], dim=cat_dim)
-
-        new_dict[new_key] = tensor
-
-    return new_dict
-
-
-def convert_config(original_config: dict, max_position_embeddings: int = 32768):
-    key_mapping = {
-        "hidden_size": "dim",
-        "num_hidden_layers": "n_layers",
-        "intermediate_size": "hidden_dim",
-        "num_attention_heads": "n_heads",
-        "rms_norm_eps": "norm_eps",
-    }
-    similar_keys_to_keep = [
-        "head_dim",
-        "vocab_size",
-    ]
-
-    new_config_kwargs = {k: original_config[v] for k, v in key_mapping.items()}
-    new_config_kwargs.update({k: v for k, v in original_config.items() if k in similar_keys_to_keep})
-
-    # These are not always defined depending on `params.json`
-    new_config_kwargs["sliding_window"] = original_config.get("sliding_window", None)
-    new_config_kwargs["num_key_value_heads"] = original_config.get(
-        "n_kv_heads", new_config_kwargs["num_attention_heads"]
-    )
-    new_config_kwargs["rope_theta"] = original_config.get("rope_theta", 10000.0)
-    new_config_kwargs["max_position_embeddings"] = original_config.get("max_seq_len", max_position_embeddings)
-
-    # This may sometimes be a string in `params.json`
-    if new_config_kwargs["sliding_window"] is not None:
-        new_config_kwargs["sliding_window"] = int(new_config_kwargs["sliding_window"])
-
-    new_config = MistralConfig(**new_config_kwargs)
-    return new_config
-
-
-def convert_and_write_model(input_dir: str, output_dir: str, max_position_embeddings: int, modules_are_split: bool):
-    """Convert the model and save it (this implicitly save the config as well)."""
-    params = read_json(os.path.join(input_dir, "params.json"))
-    config = convert_config(params, max_position_embeddings)
-
-    full_state_dict = {}
-    # The model may be split between different files, but a single nn.Module is always fully present in a single file
-    if not modules_are_split:
-        shards = [file for file in os.listdir(input_dir) if file.endswith(".safetensors")]
-        for shard_file in shards:
-            original_state_dict = load_file(os.path.join(input_dir, shard_file))
-            new_dict = convert_state_dict(original_state_dict, config)
-            full_state_dict.update(new_dict)
-    # A single nn.Module is split between different checkpoint files
-    else:
-        shards = [file for file in os.listdir(input_dir) if re.match(r"consolidated.\d+.pth", file)]
-        shards = sorted(shards, key=lambda x: int(x.split(".")[1]))
-        loaded_shards = [torch.load(os.path.join(input_dir, file), map_location="cpu") for file in shards]
-        full_state_dict = convert_state_dict_sharded(loaded_shards, config)
-
-    # Load weights into model and resave them
-    with torch.device("meta"):
-        model = MistralForCausalLM(config)
-    model.load_state_dict(full_state_dict, strict=True, assign=True)
-    model.save_pretrained(output_dir)
-
-
-def convert_and_write_tokenizer(input_dir: str, output_dir: str, tokenizer_template_name: str = ""):
-    """Convert the tokenizer and save it."""
-    # Tekken format
-    if "tekken.json" in os.listdir(input_dir):
-        tokenizer_file = os.path.join(input_dir, "tekken.json")
-        tokenizer = convert_tekken_tokenizer(tokenizer_file)
-    else:
-        # May have .v3 or .v7 at the end
-        tokenizer_file = [file for file in os.listdir(input_dir) if "tokenizer.model" in file][0]
-        tokenizer = LlamaTokenizerFast(os.path.join(input_dir, tokenizer_file))
-
-    # Load a chat template from another model
-    if tokenizer_template_name != "":
-        template_tok = AutoTokenizer.from_pretrained(tokenizer_template_name)
-        tokenizer.chat_template = template_tok.chat_template
-
-    # Finally save it
-    tokenizer.save_pretrained(output_dir)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "input_dir",
-        help="Location of Mistral weights, which contains tokenizer.model and model folders",
-    )
-    parser.add_argument(
-        "output_dir",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--template_name",
-        type=str,
-        default="",
-        help="Another model name from which to copy the chat template.",
-    )
-    parser.add_argument(
-        "--max_position_embeddings",
-        type=int,
-        default=32768,
-        help="`max_position_embeddings` field in the config. This needs to be manually passed (not present anywhere otherwise).",
-    )
-    parser.add_argument(
-        "--modules_are_split",
-        action="store_true",
-        help="If passed, then the weights of a single `nn.Module` are assumed to be split between different files.",
-    )
-    parser.add_argument(
-        "--tokenizer_only",
-        action="store_true",
-        help="If passed, will only convert the tokenizer.",
-    )
-
-    args = parser.parse_args()
-
-    if not args.tokenizer_only:
-        convert_and_write_model(args.input_dir, args.output_dir, args.max_position_embeddings, args.modules_are_split)
-    convert_and_write_tokenizer(args.input_dir, args.output_dir, args.template_name)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/mistral3/convert_mistral3_weights_to_hf.py b/src/transformers/models/mistral3/convert_mistral3_weights_to_hf.py
deleted file mode 100644
index 11b2d18f04d6..000000000000
--- a/src/transformers/models/mistral3/convert_mistral3_weights_to_hf.py
+++ /dev/null
@@ -1,241 +0,0 @@
-# Copyright 2023 Mistral AI and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import json
-import os
-import re
-
-import torch
-from safetensors.torch import load_file
-
-from transformers import (
-    Mistral3Config,
-    Mistral3ForConditionalGeneration,
-    MistralConfig,
-    PixtralImageProcessorFast,
-    PixtralProcessor,
-    PixtralVisionConfig,
-)
-from transformers.integrations.mistral import convert_tekken_tokenizer
-
-
-# fmt: off
-STATE_DICT_MAPPING = {
-    # Text model keys
-    r"^output.weight":                            r"language_model.lm_head.weight",
-    r"^norm.weight":                              r"language_model.model.norm.weight",
-    r"^tok_embeddings.weight":                    r"language_model.model.embed_tokens.weight",
-    r"^layers.(\d+).attention_norm.weight":       r"language_model.model.layers.\1.input_layernorm.weight",
-    r"^layers.(\d+).ffn_norm.weight":             r"language_model.model.layers.\1.post_attention_layernorm.weight",
-    r"^layers.(\d+).attention.w(q|k|v|o).weight": r"language_model.model.layers.\1.self_attn.\2_proj.weight",
-    r"^layers.(\d+).feed_forward.w1.weight":      r"language_model.model.layers.\1.mlp.gate_proj.weight",
-    r"^layers.(\d+).feed_forward.w2.weight":      r"language_model.model.layers.\1.mlp.down_proj.weight",
-    r"^layers.(\d+).feed_forward.w3.weight":      r"language_model.model.layers.\1.mlp.up_proj.weight",
-
-    # Vision model keys
-    r"vision_encoder.transformer.layers.(\d+).attention_norm.weight": r"vision_tower.transformer.layers.\1.attention_norm.weight",
-    r"^vision_encoder.transformer.layers.(\d+).ffn_norm.weight": r"vision_tower.transformer.layers.\1.ffn_norm.weight",
-    r"^vision_encoder.transformer.layers.(\d+).attention.w(q|k|v|o).weight": r"vision_tower.transformer.layers.\1.attention.\2_proj.weight",
-    r"^vision_encoder.transformer.layers.(\d+).feed_forward.w1.weight": r"vision_tower.transformer.layers.\1.feed_forward.gate_proj.weight",
-    r"^vision_encoder.transformer.layers.(\d+).feed_forward.w2.weight": r"vision_tower.transformer.layers.\1.feed_forward.down_proj.weight",
-    r"^vision_encoder.transformer.layers.(\d+).feed_forward.w3.weight": r"vision_tower.transformer.layers.\1.feed_forward.up_proj.weight",
-    r"^vision_language_adapter.w_in": r"multi_modal_projector.linear_1",
-    r"^vision_language_adapter.w_out": r"multi_modal_projector.linear_2",
-    r"^vision_encoder.ln_pre.weight": r"vision_tower.ln_pre.weight",
-    r"^vision_encoder.patch_conv.weight": r"vision_tower.patch_conv.weight",
-    r"^patch_merger.merging_layer.weight": r"multi_modal_projector.patch_merger.merging_layer.weight",
-    r"^pre_mm_projector_norm.weight": r"multi_modal_projector.norm.weight",
-}
-# fmt: on
-
-
-def map_old_key_to_new(old_key):
-    """Map of a key of the original state dict to the equivalent key in HF format"""
-    for pattern, replacement in STATE_DICT_MAPPING.items():
-        new_key, n_replace = re.subn(pattern, replacement, old_key)
-        # Early exit of the loop
-        if n_replace > 0:
-            return new_key
-
-    raise ValueError(f"Key: {old_key} could not be mapped (check the mapping).")
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def permute_for_rope(tensor, n_heads, dim1, dim2):
-    """Permute the weights for the ROPE formulation."""
-    tensor = tensor.view(n_heads, dim1 // n_heads // 2, 2, dim2)
-    tensor = tensor.transpose(1, 2)
-    tensor = tensor.reshape(dim1, dim2)
-    return tensor
-
-
-def convert_state_dict(original_state_dict: dict, config: MistralConfig):
-    """Convert a state dict file, when a single `nn.Module` is never sharded in different files (usual case)."""
-    new_dict = {}
-
-    for old_key, tensor in original_state_dict.items():
-        new_key = map_old_key_to_new(old_key)
-
-        if "vision" in old_key:
-            num_attention_heads = config.vision_config.num_attention_heads
-            num_key_value_heads = num_attention_heads
-            hidden_size = config.vision_config.hidden_size
-            head_dim = config.vision_config.head_dim
-            key_value_dim = head_dim * num_attention_heads
-            query_dim = head_dim * num_attention_heads
-        else:
-            num_attention_heads = config.text_config.num_attention_heads
-            hidden_size = config.text_config.hidden_size
-            head_dim = config.text_config.head_dim
-            num_key_value_heads = config.text_config.num_key_value_heads
-            key_value_dim = head_dim * num_key_value_heads
-            query_dim = head_dim * num_attention_heads
-
-        if "q_proj" in new_key:
-            tensor = permute_for_rope(tensor, num_attention_heads, query_dim, hidden_size)
-        elif "k_proj" in new_key:
-            tensor = permute_for_rope(tensor, num_key_value_heads, key_value_dim, hidden_size)
-
-        new_dict[new_key] = tensor
-    return new_dict
-
-
-def convert_config(original_config: dict, max_position_embeddings: int = 131072):
-    original_vision_config = original_config.pop("vision_encoder")
-    original_text_config = original_config
-
-    # Text config
-    text_key_mapping = {
-        "hidden_size": "dim",
-        "num_hidden_layers": "n_layers",
-        "intermediate_size": "hidden_dim",
-        "num_attention_heads": "n_heads",
-        "num_key_value_heads": "n_kv_heads",
-        "rms_norm_eps": "norm_eps",
-    }
-    similar_text_keys_to_keep = [
-        "head_dim",
-        "vocab_size",
-        "rope_theta",
-    ]
-    new_text_config_kwargs = {k: original_text_config[v] for k, v in text_key_mapping.items()}
-    new_text_config_kwargs.update({k: v for k, v in original_text_config.items() if k in similar_text_keys_to_keep})
-    # These are not always defined depending on `params.json`
-    new_text_config_kwargs["sliding_window"] = original_text_config.get("sliding_window", None)
-    new_text_config_kwargs["max_position_embeddings"] = original_text_config.get(
-        "max_seq_len", max_position_embeddings
-    )
-    # This may sometimes be a string in `params.json`
-    if new_text_config_kwargs["sliding_window"] is not None:
-        new_text_config_kwargs["sliding_window"] = int(new_text_config_kwargs["sliding_window"])
-    new_text_config = MistralConfig(**new_text_config_kwargs)
-
-    # Vision config
-    new_vision_config = original_vision_config
-    adapter_bias = new_vision_config.pop("adapter_bias", False)
-    _ = new_vision_config.pop("mm_projector_id", None)
-    _ = new_vision_config.pop("add_pre_mm_projector_layer_norm", None)
-    spatial_merge_size = new_vision_config.pop("spatial_merge_size")
-    image_token_id = new_vision_config.pop("image_token_id", 10)
-    _ = new_vision_config.pop("image_break_token_id", 12)
-    _ = new_vision_config.pop("image_end_token_id", 13)
-    _ = new_vision_config.pop("max_image_size")
-    new_vision_config = PixtralVisionConfig(**new_vision_config)
-
-    new_config = Mistral3Config(
-        vision_config=new_vision_config,
-        text_config=new_text_config,
-        multimodal_projector_bias=adapter_bias,
-        image_token_index=image_token_id,
-        spatial_merge_size=spatial_merge_size,
-        vision_feature_layer=-1,
-    )
-    return new_config
-
-
-def convert_and_write_model(input_dir: str, output_dir: str, max_position_embeddings: int):
-    """Convert the model and save it (this implicitly save the config as well)."""
-    params = read_json(os.path.join(input_dir, "params.json"))
-    config = convert_config(params, max_position_embeddings)
-
-    full_state_dict = {}
-    # The model may be split between different files, but a single nn.Module is always fully present in a single file
-    shards = [file for file in os.listdir(input_dir) if file.endswith(".safetensors")]
-    for shard_file in shards:
-        original_state_dict = load_file(os.path.join(input_dir, shard_file))
-        new_dict = convert_state_dict(original_state_dict, config)
-        full_state_dict.update(new_dict)
-
-    # Load weights into model and resave them
-    with torch.device("meta"):
-        model = Mistral3ForConditionalGeneration(config)
-    model.load_state_dict(full_state_dict, strict=True, assign=True)
-    model.save_pretrained(output_dir)
-
-
-def convert_and_write_processor(input_dir: str, output_dir: str):
-    """Convert the tokenizer and save it."""
-    tokenizer_file = os.path.join(input_dir, "tekken.json")
-    tokenizer = convert_tekken_tokenizer(tokenizer_file)
-    tokenizer.add_special_tokens({"pad_token": "<pad>"})
-    chat_template = '{%- if messages[0]["role"] == "system" %}{%- set system_message = messages[0]["content"] %}{%- set loop_messages = messages[1:] %}\n{%- else %}{%- set loop_messages = messages %}{%- endif %}{{- bos_token }}{%- for message in loop_messages %}{%- if (message[\'role\'] == \'user\') != (loop.index0 % 2 == 0) %}{{- raise_exception(\'After the optional system message, conversation roles must alternate user/assistant/user/assistant/...\') }}{%- endif %}{%- if message["role"] == "user" %}{%- if loop.last and system_message is defined %}{{- "[INST]" + system_message + "\n\n" }}{%- else %}{{ "[INST]" }}{%- endif %}{%- endif %}{%- if message["content"] is not string %}{%- for chunk in message["content"] %}{%- if chunk["type"] == "text" %}{%- if "content" in chunk %}{{- chunk["content"] }}{%- elif "text" in chunk %}{{- chunk["text"] }}{%- endif %}{%- elif chunk["type"] == "image" %}{{- "[IMG]" }}{%- else %}{{- raise_exception("Unrecognized content type!") }}{%- endif %}{%- endfor %}{%- else %}{{- message["content"] }}{%- endif %}{%- if message["role"] == "user" %}{{- "[/INST]" }}{%- elif message["role"] == "assistant" %}{{- eos_token}}{%- else %}{{- raise_exception("Only user and assistant roles are supported, with the exception of an initial optional system message!") }}{%- endif %}{%- endfor %}'
-
-    config = read_json(os.path.join(input_dir, "params.json"))
-    patch_size = config["vision_encoder"]["patch_size"]
-    spatial_merge_size = config["vision_encoder"]["spatial_merge_size"]
-    max_image_size = config["vision_encoder"]["max_image_size"]
-    image_processor = PixtralImageProcessorFast(patch_size=patch_size, size={"longest_edge": max_image_size})
-
-    processor = PixtralProcessor(
-        tokenizer=tokenizer,
-        image_processor=image_processor,
-        image_token="[IMG]",
-        patch_size=patch_size,
-        chat_template=chat_template,
-        spatial_merge_size=spatial_merge_size,
-    )
-
-    # Finally save it
-    processor.save_pretrained(output_dir)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "input_dir",
-        help="Location of Mistral weights, which contains tokenizer.model and model folders",
-    )
-    parser.add_argument(
-        "output_dir",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--max_position_embeddings",
-        type=int,
-        default=131072,
-        help="`max_position_embeddings` field in the config. This needs to be manually passed (not present anywhere otherwise).",
-    )
-
-    args = parser.parse_args()
-
-    convert_and_write_model(args.input_dir, args.output_dir, args.max_position_embeddings)
-    convert_and_write_processor(args.input_dir, args.output_dir)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/mixtral/convert_mixtral_weights_to_hf.py b/src/transformers/models/mixtral/convert_mixtral_weights_to_hf.py
deleted file mode 100644
index 3309627b2786..000000000000
--- a/src/transformers/models/mixtral/convert_mixtral_weights_to_hf.py
+++ /dev/null
@@ -1,244 +0,0 @@
-# Copyright 2023 Mistral AI and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import json
-import os
-
-import torch
-
-from transformers import (
-    MixtralConfig,
-    MixtralForCausalLM,
-)
-
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/mixtral/convert_mixtral_weights_to_hf.py \
-    --input_dir /path/to/downloaded/mixtral/weights --model_size 7B --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import MixtralForCausalLM
-
-model = MixtralForCausalLM.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-
-def compute_intermediate_size(n, ffn_dim_multiplier=1, multiple_of=256):
-    return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3)) + multiple_of - 1) // multiple_of)
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def write_json(text, path):
-    with open(path, "w") as f:
-        json.dump(text, f)
-
-
-def write_model(model_path, input_base_path, model_size, safe_serialization=True):
-    os.makedirs(model_path, exist_ok=True)
-
-    params = read_json(os.path.join(input_base_path, "params.json"))
-    num_shards = 1
-
-    # For some reason this is a string in the params.json
-    sliding_window = int(params["sliding_window"]) if "sliding_window" in params else None
-    n_layers = params["num_hidden_layers"]
-    n_heads = params["num_attention_heads"]
-    n_heads_per_shard = n_heads // num_shards
-    dim = params["hidden_size"]
-    dims_per_head = dim // n_heads
-    base = params.get("rope_theta", 10000.0)
-    max_position_embeddings = 4096 * 8
-    num_local_experts = params["num_local_experts"]
-    ffn_dim = params["intermediate_size"]
-
-    vocab_size = params["vocab_size"]
-
-    if "num_key_value_heads" in params:
-        num_key_value_heads = params["num_key_value_heads"]  # for GQA / MQA
-        num_local_key_value_heads = num_key_value_heads // num_shards
-        key_value_dim = dims_per_head * num_local_key_value_heads
-    else:  # compatibility with other checkpoints
-        num_key_value_heads = n_heads
-        num_local_key_value_heads = n_heads_per_shard
-        key_value_dim = dim
-
-    # permute for sliced rotary
-    def permute(w, n_heads=n_heads, dim1=dim, dim2=dim):
-        return w.view(n_heads, dim1 // n_heads // 2, 2, dim2).transpose(1, 2).reshape(dim1, dim2)
-
-    print(f"Fetching all parameters from the checkpoint at {input_base_path}.")
-    # Load weights
-    loaded = [
-        torch.load(os.path.join(input_base_path, f"consolidated.{i:02d}.pt"), map_location="cpu") for i in range(8)
-    ]
-
-    merged_state_dict = {}
-    for state_dict in loaded:
-        merged_state_dict.update(state_dict)
-
-    state_dict = {}
-
-    for layer_i in range(n_layers):
-        # Sharded
-        # Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
-        # the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
-        # redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.
-
-        state_dict.update(
-            {
-                f"model.layers.{layer_i}.input_layernorm.weight": merged_state_dict[
-                    f"layers.{layer_i}.attention_norm.weight"
-                ].clone(),
-                f"model.layers.{layer_i}.post_attention_layernorm.weight": merged_state_dict[
-                    f"layers.{layer_i}.ffn_norm.weight"
-                ].clone(),
-            }
-        )
-
-        state_dict[f"model.layers.{layer_i}.self_attn.q_proj.weight"] = permute(
-            merged_state_dict[f"layers.{layer_i}.attention.wq.weight"]
-            .view(n_heads_per_shard, dims_per_head, dim)
-            .reshape(dim, dim)
-        )
-        state_dict[f"model.layers.{layer_i}.self_attn.k_proj.weight"] = permute(
-            merged_state_dict[f"layers.{layer_i}.attention.wk.weight"]
-            .view(num_local_key_value_heads, dims_per_head, dim)
-            .reshape(key_value_dim, dim),
-            num_key_value_heads,
-            key_value_dim,
-            dim,
-        )
-        state_dict[f"model.layers.{layer_i}.self_attn.v_proj.weight"] = (
-            merged_state_dict[f"layers.{layer_i}.attention.wv.weight"]
-            .view(num_local_key_value_heads, dims_per_head, dim)
-            .reshape(key_value_dim, dim)
-        )
-
-        state_dict[f"model.layers.{layer_i}.self_attn.o_proj.weight"] = merged_state_dict[
-            f"layers.{layer_i}.attention.wo.weight"
-        ]
-
-        w1 = merged_state_dict[f"layers.{layer_i}.block_sparse_moe.w1"]
-        w2 = merged_state_dict[f"layers.{layer_i}.block_sparse_moe.w2"]
-        w3 = merged_state_dict[f"layers.{layer_i}.block_sparse_moe.w3"]
-
-        experts_w1 = [
-            w1[ffn_dim * expert_idx : ffn_dim * (expert_idx + 1), :].clone(memory_format=torch.contiguous_format)
-            for expert_idx in range(num_local_experts)
-        ]
-
-        for idx, expert_block in enumerate(experts_w1):
-            expert_key = f"model.layers.{layer_i}.block_sparse_moe.experts.{idx}.w1"
-            state_dict[expert_key + ".weight"] = expert_block.clone()
-
-        experts_w2 = [
-            w2[ffn_dim * expert_idx : ffn_dim * (expert_idx + 1), :].clone(memory_format=torch.contiguous_format)
-            for expert_idx in range(num_local_experts)
-        ]
-
-        for idx, expert_block in enumerate(experts_w2):
-            expert_key = f"model.layers.{layer_i}.block_sparse_moe.experts.{idx}.w2"
-            state_dict[expert_key + ".weight"] = expert_block.T.clone(memory_format=torch.contiguous_format)
-
-        experts_w3 = [
-            w3[ffn_dim * expert_idx : ffn_dim * (expert_idx + 1), :].clone(memory_format=torch.contiguous_format)
-            for expert_idx in range(num_local_experts)
-        ]
-
-        for idx, expert_block in enumerate(experts_w3):
-            expert_key = f"model.layers.{layer_i}.block_sparse_moe.experts.{idx}.w3"
-            state_dict[expert_key + ".weight"] = expert_block.clone()
-
-        state_dict[f"model.layers.{layer_i}.block_sparse_moe.gate.weight"] = merged_state_dict[
-            f"layers.{layer_i}.block_sparse_moe.gate.weight"
-        ]
-
-    state_dict.update(
-        {
-            "model.norm.weight": merged_state_dict["norm.weight"],
-            "model.embed_tokens.weight": merged_state_dict["tok_embeddings.weight"],
-            "lm_head.weight": merged_state_dict["output.weight"],
-        }
-    )
-
-    config = MixtralConfig(
-        hidden_size=dim,
-        intermediate_size=ffn_dim,
-        num_attention_heads=params["num_attention_heads"],
-        num_hidden_layers=params["num_hidden_layers"],
-        rms_norm_eps=params["rms_norm_eps"],
-        num_key_value_heads=num_key_value_heads,
-        vocab_size=vocab_size,
-        rope_theta=base,
-        max_position_embeddings=max_position_embeddings,
-        sliding_window=sliding_window,
-        num_local_experts=num_local_experts,
-    )
-
-    print("Loading the checkpoint in a Mixtral model.")
-    with torch.device("meta"):
-        model = MixtralForCausalLM(config)
-    # Avoid saving this as part of the config.
-    del model.config._name_or_path
-    model.config.torch_dtype = torch.float16
-    print("Saving in the Transformers format.")
-
-    model.load_state_dict(state_dict, strict=True, assign=True)
-
-    for n, p in model.named_parameters():
-        assert p.device.type != "meta", f"{n} has not been loaded!"
-
-    model.save_pretrained(model_path, safe_serialization=safe_serialization)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        help="Location of Mixtral weights, which contains tokenizer.model and model folders",
-        required=True,
-    )
-    parser.add_argument(
-        "--model_size",
-        choices=["7B"],
-        help="'f' models correspond to the finetuned versions, and are specific to the Mixtral official release. For more details on Mixtral, checkout the original repo: https://huggingface.co/mistral-ai",
-        default="7B",
-    )
-    parser.add_argument("--output_dir", help="Location to write HF model", required=True)
-    parser.add_argument("--safe_serialization", type=bool, help="Whether or not to save using `safetensors`.")
-    args = parser.parse_args()
-    write_model(
-        model_path=args.output_dir,
-        input_base_path=args.input_dir,
-        model_size=args.model_size,
-        safe_serialization=args.safe_serialization,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/mllama/convert_mllama_weights_to_hf.py b/src/transformers/models/mllama/convert_mllama_weights_to_hf.py
deleted file mode 100644
index b2c40e27bb2b..000000000000
--- a/src/transformers/models/mllama/convert_mllama_weights_to_hf.py
+++ /dev/null
@@ -1,639 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import gc
-import json
-import math
-import os
-from typing import List, Optional
-
-import regex as re
-import torch
-import torch.nn.functional as F
-
-from transformers import (
-    GenerationConfig,
-    MllamaConfig,
-    MllamaForConditionalGeneration,
-    MllamaImageProcessor,
-    PreTrainedTokenizerFast,
-)
-from transformers.convert_slow_tokenizer import TikTokenConverter
-from transformers.models.mllama.configuration_mllama import MllamaTextConfig, MllamaVisionConfig
-from transformers.models.mllama.image_processing_mllama import get_all_supported_aspect_ratios
-
-
-# fmt: off
-# If a weight needs to be split in two or more keys, use `|` to indicate it. ex:
-# r"text_model.layers.(\d+).attention.wqkv.weight": r"language_model.model.layers.\1.self_attn.q|k|v|_proj.weight"
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    r"text_model.norm.weight":                                                                  r"language_model.model.norm.weight",
-    r"text_model.output.weight":                                                                r"language_model.lm_head.weight",
-    r"text_model.tok_embeddings":                                                               r"language_model.model.embed_tokens",
-    r"text_model.learnable_embedding":                                                          r"language_model.model.learnable_embedding",
-    r"text_model.rope.freqs":                                                                   None, # meaning we skip it and don't want it
-    # For every cross attention layer, the layer needs to be updated
-    r"text_model.cross_attention_layers.(\d+).gate_attn":                                       r"language_model.model.layers.\1.cross_attn_attn_gate",
-    r"text_model.cross_attention_layers.(\d+).gate_ffwd":                                       r"language_model.model.layers.\1.cross_attn_mlp_gate",
-    # special key, wqkv needs to be split afterwards
-    r"text_model.cross_attention_layers.(\d+).attention.w(q|k|v|o)":                            r"language_model.model.layers.\1.cross_attn.\2_proj",
-    r"text_model.cross_attention_layers.(\d+).attention.(q|k)_norm":                            r"language_model.model.layers.\1.cross_attn.\2_norm",
-    r"text_model.cross_attention_layers.(\d+).attention_norm.weight":                           r"language_model.model.layers.\1.input_layernorm.weight",
-    r"text_model.cross_attention_layers.(\d+).attention.wk.layer_norm_weight":                  r"language_model.model.layers.\1.post_attention_layernorm.weight",
-    r"text_model.cross_attention_layers.(\d+).feed_forward.w1.weight":                          r"language_model.model.layers.\1.mlp.gate_proj.weight",
-    r"text_model.cross_attention_layers.(\d+).feed_forward.w2.weight":                          r"language_model.model.layers.\1.mlp.down_proj.weight",
-    r"text_model.cross_attention_layers.(\d+).feed_forward.w3.weight":                          r"language_model.model.layers.\1.mlp.up_proj.weight",
-    r"text_model.cross_attention_layers.(\d+).ffn_norm.weight":                                 r"language_model.model.layers.\1.post_attention_layernorm.weight",
-    # self attention layers
-    r"text_model.layers.(\d+).attention.w(q|k|v|o).weight":                                     r"language_model.model.layers.\1.self_attn.\2_proj.weight",
-    r"text_model.layers.(\d+).attention_norm.weight":                                           r"language_model.model.layers.\1.input_layernorm.weight",
-    r"text_model.layers.(\d+).feed_forward.w1.":                                                r"language_model.model.layers.\1.mlp.gate_proj.",
-    r"text_model.layers.(\d+).feed_forward.w2.":                                                r"language_model.model.layers.\1.mlp.down_proj.",
-    r"text_model.layers.(\d+).feed_forward.w3.":                                                r"language_model.model.layers.\1.mlp.up_proj.",
-    r"text_model.layers.(\d+).ffn_norm.weight":                                                 r"language_model.model.layers.\1.post_attention_layernorm.weight",
-    # Vision encoder mapping
-    r"vision_model.vision_encoder.conv1._linear":                                               r"vision_model.patch_embedding",
-    r'vision_model.vision_projection.':                                                         r"multi_modal_projector.",
-    r"vision_model.vision_encoder.(global_transformer|transformer).resblocks.(\d+).attn.wq":    r"vision_model.\1.layers.\2.self_attn.q_proj",
-    r"vision_model.vision_encoder.(global_transformer|transformer).resblocks.(\d+).attn.wk":    r"vision_model.\1.layers.\2.self_attn.k_proj",
-    r"vision_model.vision_encoder.(global_transformer|transformer).resblocks.(\d+).attn.wv":    r"vision_model.\1.layers.\2.self_attn.v_proj",
-    r"vision_model.vision_encoder.(global_transformer|transformer).resblocks.(\d+).attn.wo":    r"vision_model.\1.layers.\2.self_attn.o_proj",
-    r"vision_model.vision_encoder.(global_transformer|transformer).resblocks.(\d+).mlp.c_fc":   r"vision_model.\1.layers.\2.mlp.fc1",
-    r"vision_model.vision_encoder.(global_transformer|transformer).resblocks.(\d+).mlp.c_proj": r"vision_model.\1.layers.\2.mlp.fc2",
-    r"vision_model.vision_encoder.(global_transformer|transformer).resblocks.(\d+).ln_1":       r"vision_model.\1.layers.\2.input_layernorm",
-    r"vision_model.vision_encoder.(global_transformer|transformer).resblocks.(\d+).ln_2":       r"vision_model.\1.layers.\2.post_attention_layernorm",
-    r"vision_model.vision_encoder.global_transformer.resblocks.(\d+).(gate_ffn|gate_attn)":     r"vision_model.global_transformer.layers.\1.\2",
-    r'vision_model.vision_encoder.ln_(pre|post).(weight|bias)':                                 r'vision_model.vision_encoder.layernorm_\1.\2',
-    r'vision_model.vision_encoder.positional_embedding\b':                                      r'vision_model.gated_positional_embedding.embedding',
-    r'vision_model.vision_encoder.gated_positional_embedding\b':                                r'vision_model.gated_positional_embedding.tile_embedding.weight',
-    r'vision_model.vision_encoder.gated_positional_embedding_gate':                             r'vision_model.gated_positional_embedding.gate',
-    r"vision_model.vision_encoder.pre_tile_pos_embed.embedding":                                r"vision_model.pre_tile_positional_embedding.embedding.weight",
-    r"vision_model.vision_encoder.post_tile_pos_embed.embedding":                               r"vision_model.post_tile_positional_embedding.embedding.weight",
-    r"vision_model.vision_encoder.pre_tile_pos_embed.gate":                                     r"vision_model.pre_tile_positional_embedding.gate",
-    r"vision_model.vision_encoder.post_tile_pos_embed.gate":                                    r"vision_model.post_tile_positional_embedding.gate",
-    r"vision_model.vision_encoder.(?=\w)":                                                      r"vision_model.",
-}
-# fmt: on
-
-CONTEXT_LENGTH = 131072
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    """
-    This function should be applied only once, on the concatenated keys to efficiently rename using
-    the key mappings.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-        for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-            if replacement is None:
-                new_text = re.sub(pattern, "", new_text)  # an empty line
-                continue
-            new_text = re.sub(pattern, replacement, new_text)
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-    return output_dict
-
-
-def permute_for_rope(input_tensor, n_heads, dim1, dim2):
-    """
-    When you go from the complex ROPE formulation to sin and cos one, you need
-    to permute the query and key weights (to avoid doing it on the fly)
-    """
-    input_tensor = input_tensor.reshape(dim1, dim2)
-    input_tensor = input_tensor.view(n_heads, dim1 // n_heads // 2, 2, dim2)
-    input_tensor = input_tensor.transpose(1, 2).reshape(dim1, dim2)
-    return input_tensor
-
-
-def pre_compute_positional_embedding(embedding):
-    """
-    Instead of iterating of the batch of images, and the ratios inside, we pre-compute the
-    positional embeddings depending on the aspect ratio id. This is done to support `torch.compile`
-    and efficient inference / training with different aspect ratios.
-    """
-    max_num_tiles, *shapes = embedding.shape
-    hidden_size = shapes[-1]
-    supported_aspect_ratios = get_all_supported_aspect_ratios(max_num_tiles)
-    max_aspect_ratio_id = len(supported_aspect_ratios)  # we keep 0 index for padding
-    # tile embedding does not have patches
-    num_patches = 1 if len(shapes) == 2 else shapes[1]
-    precomputed_embeddings = torch.zeros(
-        max_aspect_ratio_id + 1,
-        max_num_tiles,
-        num_patches,
-        hidden_size,
-        device=embedding.device,
-        dtype=embedding.dtype,
-    )
-
-    for i, (height, width) in enumerate(supported_aspect_ratios):
-        aspect_ratio_id = i + 1  # we keep 0 index for padding
-        current_embedding = embedding[:height, :width].reshape(height * width, num_patches, hidden_size)
-        precomputed_embeddings[aspect_ratio_id, : height * width] = current_embedding
-    precomputed_embeddings = precomputed_embeddings.flatten(1)
-    return precomputed_embeddings
-
-
-def is_param_different_across_shards(key):
-    """
-    Return `True` if the parameter is different across checkpoint shards
-    and needs to be concatenated.
-    """
-    patterns = [r"vision_model.patch_embedding.weight",r"vision_model.(transformer|global_transformer).layers.(\d+).self_attn.(q|k|v|o)_proj.weight",r"vision_model.(transformer|global_transformer).layers.(\d+).mlp.fc1.(weight|bias)",r"vision_model.(transformer|global_transformer).layers.(\d+).mlp.fc2.weight",  r"multi_modal_projector.(weight|bias)",r"language_model.model.embed_tokens.weight",r"language_model.lm_head.weight",r"language_model.model.layers.(\d+).self_attn.(q|k|v|o)_proj.weight",r"language_model.model.layers.(\d+).cross_attn.(q|k|v|o)_proj.weight",r"language_model.model.layers.(\d+).mlp.(up|down|gate)_proj.weight",r"language_model.model.learnable_embedding.weight"]  # fmt: skip
-    return any(re.search(pattern, key) for pattern in patterns)
-
-
-def get_concat_dim(key):
-    """
-    Return the dimension to concatenate the weights on.
-    """
-    concat_dim_1 = [r"vision_model.(transformer|global_transformer).layers.(\d+).mlp.fc2.weight",r"vision_model.(transformer|global_transformer).layers.(\d+).self_attn.o_proj.weight",r"language_model.model.layers.(\d+).cross_attn.o_proj.weight",r"language_model.model.layers.(\d+).self_attn.o_proj.weight",r"language_model.model.layers.(\d+).mlp.down_proj.weight"]  # fmt: off
-    if any(re.search(pattern, key) for pattern in concat_dim_1):
-        return 1
-    return 0
-
-
-def compute_intermediate_size(hidden_dim, multiple_of=1024, ffn_dim_multiplier=1.3):
-    hidden_dim = 4 * int(2 * hidden_dim / 3)
-    hidden_dim = int(ffn_dim_multiplier * hidden_dim)
-    hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of)
-    return hidden_dim
-
-
-def interpolate_positional_embedding(
-    embeddings: torch.Tensor, vision_tile_size: int, vision_patch_size: int
-) -> torch.Tensor:
-    """
-    This method allows to interpolate the pre-trained position embeddings, to be able to use the model on higher resolution
-    images.
-    """
-    cls_embedding, positional_embedding = embeddings[:1], embeddings[1:]
-    total_num_patches, dim = positional_embedding.shape
-
-    # compute current and target number of patches for height and width
-    num_patches = int(round(total_num_patches**0.5))
-    new_num_patches = vision_tile_size // vision_patch_size
-
-    # Check if the number of patches is already the desired size
-    if num_patches == new_num_patches:
-        return embeddings
-
-    positional_embedding = positional_embedding.transpose(0, 1)
-    positional_embedding = positional_embedding.reshape(1, dim, num_patches, num_patches)
-    positional_embedding = F.interpolate(
-        positional_embedding,
-        size=(new_num_patches, new_num_patches),
-        mode="bicubic",
-        align_corners=False,
-    )
-    positional_embedding = positional_embedding.reshape(dim, -1).transpose(0, 1)
-
-    embeddings = torch.cat([cls_embedding, positional_embedding], dim=0)
-    return embeddings
-
-
-def write_model(
-    model_path,
-    input_base_path,
-    num_shards,
-    safe_serialization=True,
-    instruct=False,
-):
-    os.makedirs(model_path, exist_ok=True)
-
-    with open(os.path.join(input_base_path, "params.json"), "r") as f:
-        params = json.load(f)
-
-    params = params.get("model", params)
-    torch_dtype = "bfloat16"
-
-    # ------------------------------------------------------------
-    # Text model params and config
-    # ------------------------------------------------------------
-
-    # params from config
-    text_vocab_size = params["vocab_size"]
-    text_num_layers = params["n_layers"]
-    text_dim = params["dim"]
-    text_num_heads = params["n_heads"]
-    text_rms_norm_eps = params["norm_eps"]
-    text_rope_theta = params["rope_theta"]
-    cross_attention_num_layers = params["vision_num_cross_attention_layers"]
-
-    # some constans from original code
-    rope_scaling = {
-        "rope_type": "llama3",
-        "factor": 8.0,
-        "low_freq_factor": 1.0,
-        "high_freq_factor": 4.0,
-        "original_max_position_embeddings": 8192,
-    }
-    max_position_embeddings = CONTEXT_LENGTH
-
-    # compute additional params for weight conversion
-    text_num_heads_per_shard = text_num_heads // num_shards
-    text_dim_per_head = text_dim // text_num_heads
-    text_intermediate_size = compute_intermediate_size(text_dim, multiple_of=params["multiple_of"])
-
-    if params.get("n_kv_heads", None) is not None:
-        text_num_key_value_heads = params["n_kv_heads"]  # for GQA / MQA
-        text_num_key_value_heads_per_shard = text_num_key_value_heads // num_shards
-        text_key_value_dim = text_dim_per_head * text_num_key_value_heads
-    else:  # compatibility with other checkpoints
-        text_num_key_value_heads = text_num_heads
-        text_num_key_value_heads_per_shard = text_num_heads_per_shard
-        text_key_value_dim = text_dim
-
-    # cross-attention layers: 20 for 90B, 8 for 11B
-    cross_attention_frequency = math.ceil(text_num_layers / cross_attention_num_layers)
-    text_num_total_layers = text_num_layers + cross_attention_num_layers
-    cross_attention_layers_shift = list(
-        range(cross_attention_frequency - 1, text_num_total_layers, cross_attention_frequency + 1)
-    )
-    self_attention_layers_shift = [k for k in range(text_num_total_layers) if k not in cross_attention_layers_shift]
-
-    bos_token_id = 128000
-    eos_token_id = [128001, 128008, 128009] if instruct else 128001
-    pad_token_id = 128004
-
-    text_config = MllamaTextConfig(
-        num_attention_heads=text_num_heads,
-        vocab_size=text_vocab_size,
-        hidden_size=text_dim,
-        rms_norm_eps=text_rms_norm_eps,
-        rope_theta=text_rope_theta,
-        num_hidden_layers=text_num_total_layers,
-        cross_attention_layers=cross_attention_layers_shift,
-        intermediate_size=text_intermediate_size,
-        max_position_embeddings=max_position_embeddings,
-        rope_scaling=rope_scaling,
-        bos_token_id=bos_token_id,
-        eos_token_id=eos_token_id,
-        pad_token_id=pad_token_id,
-        tie_word_embeddings=False,  # Constant set to False
-        torch_dtype=torch_dtype,
-    )
-
-    # ------------------------------------------------------------
-    # Vision model params and config
-    # ------------------------------------------------------------
-
-    # params from config
-    vision_tile_size = params["vision_chunk_size"]
-    vision_max_num_tiles = params["vision_max_num_chunks"]
-
-    # some constants from original code
-    vision_patch_size = 14
-    vision_num_channels = 3
-    vision_num_layers = 32
-    vision_num_layers_global = 8
-    vision_dim = 1280
-    vision_num_heads = 16
-    vision_intermediate_layers_indices = [3, 7, 15, 23, 30]
-
-    # compute additional params for weight conversion
-    vision_dim_per_head = vision_dim // vision_num_heads
-    vision_num_heads_per_shard = vision_num_heads // num_shards
-    vision_intermediate_size = vision_dim * 4
-    vision_supported_aspect_ratios = get_all_supported_aspect_ratios(vision_max_num_tiles)
-
-    vision_config = MllamaVisionConfig(
-        hidden_size=vision_dim,
-        patch_size=vision_patch_size,
-        num_channels=vision_num_channels,
-        intermediate_size=vision_intermediate_size,
-        num_hidden_layers=vision_num_layers,
-        num_attention_heads=vision_num_heads,
-        num_global_layers=vision_num_layers_global,
-        intermediate_layers_indices=vision_intermediate_layers_indices,
-        image_size=vision_tile_size,
-        max_num_tiles=vision_max_num_tiles,
-        supported_aspect_ratios=vision_supported_aspect_ratios,
-        torch_dtype=torch_dtype,
-    )
-
-    # save config
-    config = MllamaConfig(vision_config=vision_config, text_config=text_config, torch_dtype=torch_dtype)
-    config.architectures = ["MllamaForConditionalGeneration"]
-    config.save_pretrained(model_path)
-    print("Model config saved successfully...")
-
-    # ------------------------------------------------------------
-    # Convert weights
-    # ------------------------------------------------------------
-
-    print(f"Fetching all parameters from the checkpoint at {input_base_path}...")
-    if num_shards == 1:
-        if os.path.exists(os.path.join(input_base_path, "consolidated.00.pth")):
-            path = os.path.join(input_base_path, "consolidated.00.pth")
-        else:
-            path = os.path.join(input_base_path, "consolidated.pth")
-        loaded = [torch.load(path, map_location="cpu", mmap=True)]
-    else:
-        loaded = [
-            torch.load(os.path.join(input_base_path, f"consolidated.{i:02d}.pth"), map_location="cpu", mmap=True)
-            for i in range(num_shards)
-        ]
-
-    print("Converting model...")
-    all_keys = list(loaded[0].keys())
-    new_keys = convert_old_keys_to_new_keys(all_keys)
-
-    state_dict = {}
-    for key in all_keys:
-        new_key = new_keys[key]
-
-        # In the original model, self-attention layers and cross-attention layers are different lists of layers.
-        # In the converted model, they are merged into one list with corresponding index shift to preserve the order.
-        if ("cross_attention" in key or "text_model.layers" in key) and "language_model" in new_key:
-            shift = cross_attention_layers_shift if "cross_attention" in key else self_attention_layers_shift
-            new_key = re.sub(r"layers.(\d+).", lambda _match: f"layers.{shift[int(_match.groups()[0])]}.", new_key)
-
-        current_parameter = [chunk.pop(key).contiguous().clone() for chunk in loaded]
-        if not is_param_different_across_shards(new_key):
-            current_parameter = current_parameter[0]
-
-        concat_dim = get_concat_dim(new_key)
-
-        # Post-process the current_parameter.
-        if re.search("(k|v|q)_proj.weight", new_key) and "language_model" in new_key:
-            if "q_proj" in new_key:
-                param_num_heads = text_num_heads
-                param_num_head_per_shard = text_num_heads_per_shard
-                param_dim = text_dim
-            else:
-                param_num_heads = text_num_key_value_heads
-                param_num_head_per_shard = text_num_key_value_heads_per_shard
-                param_dim = text_key_value_dim
-            shards = [param.view(param_num_head_per_shard, text_dim_per_head, text_dim) for param in current_parameter]
-            current_parameter = torch.cat(shards, dim=concat_dim)
-            if "cross_attn" not in new_key and "v_proj.weight" not in new_key:
-                current_parameter = permute_for_rope(current_parameter, param_num_heads, param_dim, text_dim)
-            state_dict[new_key] = current_parameter.reshape(param_num_heads * text_dim_per_head, text_dim)
-
-        elif "vision_model" in new_key and re.search("(k|v|q)_proj", new_key):
-            shards = [
-                param.view(vision_num_heads_per_shard, vision_dim_per_head, vision_dim) for param in current_parameter
-            ]
-            param = torch.cat(shards, dim=concat_dim)
-            state_dict[new_key] = param.reshape(vision_num_heads * vision_dim_per_head, vision_dim)
-
-        elif new_key == "vision_model.patch_embedding.weight":
-            current_parameter = torch.cat(current_parameter, dim=concat_dim)
-            state_dict[new_key] = current_parameter.reshape(
-                -1, vision_num_channels, vision_patch_size, vision_patch_size
-            )
-
-        elif new_key.endswith("gate"):
-            state_dict[new_key] = current_parameter[0].view(1)
-
-        elif "vision_model.gated_positional_embedding.embedding" in new_key:
-            current_parameter = interpolate_positional_embedding(
-                current_parameter, vision_tile_size, vision_patch_size
-            )
-            state_dict[new_key] = current_parameter
-
-        elif "vision_model.gated_positional_embedding.tile_embedding.weight" in new_key:
-            current_parameter = current_parameter.permute(2, 0, 1, 3).flatten(1)
-            current_parameter = interpolate_positional_embedding(
-                current_parameter, vision_tile_size, vision_patch_size
-            )
-            current_parameter = current_parameter.reshape(
-                -1, vision_max_num_tiles, vision_max_num_tiles, vision_dim
-            ).permute(1, 2, 0, 3)
-            state_dict[new_key] = pre_compute_positional_embedding(current_parameter)
-
-        elif "tile_positional_embedding.embedding" in new_key:
-            state_dict[new_key] = pre_compute_positional_embedding(current_parameter)
-
-        elif new_key != "":
-            if isinstance(current_parameter, list):
-                current_parameter = torch.cat(current_parameter, dim=concat_dim)
-            state_dict[new_key] = current_parameter
-
-    state_dict["language_model.model.embed_tokens.weight"] = torch.cat(
-        [
-            state_dict["language_model.model.embed_tokens.weight"],
-            state_dict.pop("language_model.model.learnable_embedding.weight"),
-        ],
-        dim=0,
-    )
-    del loaded
-    gc.collect()
-
-    print("Loading the checkpoint in a Mllama model.")
-    with torch.device("meta"):
-        model = MllamaForConditionalGeneration(config)
-    model.load_state_dict(state_dict, strict=True, assign=True)
-    print("Checkpoint loaded successfully.")
-    del model.config._name_or_path
-
-    print("Saving the model.")
-    model.save_pretrained(model_path, safe_serialization=safe_serialization)
-    del state_dict, model
-
-    # Safety check: reload the converted model
-    gc.collect()
-    print("Reloading the model to check if it's saved correctly.")
-    MllamaForConditionalGeneration.from_pretrained(model_path, torch_dtype=torch.bfloat16, device_map="auto")
-    print("Model reloaded successfully.")
-
-    # generation config
-    if instruct:
-        print("Saving generation config...")
-        generation_config = GenerationConfig(
-            do_sample=True,
-            temperature=0.6,
-            top_p=0.9,
-            bos_token_id=bos_token_id,
-            eos_token_id=eos_token_id,
-            pad_token_id=pad_token_id,
-        )
-        generation_config.save_pretrained(model_path)
-
-
-class MllamaConverter(TikTokenConverter):
-    def __init__(
-        self,
-        vocab_file,
-        special_tokens: List[str],
-        pattern: str,
-        model_max_length: int,
-        chat_template: Optional[str] = None,
-        **kwargs,
-    ):
-        super().__init__(vocab_file, pattern=pattern)
-        self.additional_special_tokens = special_tokens
-        tokenizer = self.converted()
-        if chat_template is not None:
-            kwargs["chat_template"] = chat_template
-        self.tokenizer = PreTrainedTokenizerFast(
-            tokenizer_object=tokenizer,
-            model_input_names=["input_ids", "attention_mask"],
-            model_max_length=model_max_length,
-            **kwargs,
-        )
-
-
-def write_tokenizer(tokenizer_path: str, save_dir: str, instruct: bool = False):
-    model_max_length = CONTEXT_LENGTH
-    pattern = r"(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"  # noqa: W605
-
-    # Special tokens
-    num_reserved_special_tokens = 256
-    special_tokens = [
-        "<|begin_of_text|>",
-        "<|end_of_text|>",
-        "<|reserved_special_token_0|>",
-        "<|reserved_special_token_1|>",
-        "<|finetune_right_pad_id|>",
-        "<|step_id|>",
-        "<|start_header_id|>",
-        "<|end_header_id|>",
-        "<|eom_id|>",  # end of message
-        "<|eot_id|>",  # end of turn
-        "<|python_tag|>",
-    ]
-    special_tokens += [
-        f"<|reserved_special_token_{i + 2}|>" for i in range(num_reserved_special_tokens - len(special_tokens))
-    ]
-    # original tokenizer has <|image|> with 128011 token_id,
-    # however, later in the code it is replaced with 128256 token_id
-    special_tokens.append("<|image|>")
-
-    # Chat template
-    chat_template = (
-        "{% for message in messages %}"
-        "{% if loop.index0 == 0 %}"
-        "{{ bos_token }}"
-        "{% endif %}"
-        "{{ '<|start_header_id|>' + message['role'] + '<|end_header_id|>\n\n' }}"
-        "{% if message['content'] is string %}"
-        "{{ message['content'] }}"
-        "{% else %}"
-        "{% for content in message['content'] %}"
-        "{% if content['type'] == 'image' %}"
-        "{{ '<|image|>' }}"
-        "{% elif content['type'] == 'text' %}"
-        "{{ content['text'] }}"
-        "{% endif %}"
-        "{% endfor %}"
-        "{% endif %}"
-        "{{ '<|eot_id|>' }}"
-        "{% endfor %}"
-        "{% if add_generation_prompt %}"
-        "{{ '<|start_header_id|>assistant<|end_header_id|>\n\n' }}"
-        "{% endif %}"
-    )
-
-    converter = MllamaConverter(
-        vocab_file=tokenizer_path,
-        pattern=pattern,
-        special_tokens=special_tokens,
-        model_max_length=model_max_length,
-        chat_template=chat_template if instruct else None,
-        bos_token="<|begin_of_text|>",
-        eos_token="<|end_of_text|>" if not instruct else "<|eot_id|>",
-        pad_token="<|finetune_right_pad_id|>",
-    )
-    tokenizer = converter.tokenizer
-    tokenizer.save_pretrained(save_dir)
-
-    if instruct:
-        print("Saving chat template...")
-        chat_template_path = os.path.join(save_dir, "chat_template.json")
-        with open(chat_template_path, "w") as f:
-            json.dump({"chat_template": chat_template}, f, indent=2)
-
-
-def write_image_processor(config_path: str, save_dir: str):
-    with open(config_path, "r") as f:
-        params = json.load(f)
-
-    tile_size = params["vision_chunk_size"]
-    max_image_tiles = params["vision_max_num_chunks"]
-
-    image_processor = MllamaImageProcessor(
-        do_resize=True,
-        size={"height": tile_size, "width": tile_size},
-        do_rescale=True,
-        rescale_factor=1 / 255,
-        do_normalize=True,
-        image_mean=[0.48145466, 0.4578275, 0.40821073],
-        image_std=[0.26862954, 0.26130258, 0.27577711],
-        do_pad=True,
-        max_image_tiles=max_image_tiles,
-    )
-
-    image_processor.save_pretrained(save_dir)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        default="Llama-3.2-11B-Vision/original",
-        help="Location of LLaMA weights, which contains tokenizer.model and model folders",
-    )
-    parser.add_argument(
-        "--output_dir",
-        default="Llama-3.2-11B-Vision",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--safe_serialization", default=True, type=bool, help="Whether or not to save using `safetensors`."
-    )
-    parser.add_argument(
-        "--special_tokens",
-        default=None,
-        type=List[str],
-        help="The list of special tokens that should be added to the model.",
-    )
-    parser.add_argument(
-        "--num_shards",
-        default=1,
-        type=int,
-        help="The number of individual shards used for the model. Does not have to be the same as the number of consolidated_xx.pth",
-    )
-    parser.add_argument(
-        "--instruct",
-        action="store_true",
-        help="Whether the model is an instruct model",
-    )
-    args = parser.parse_args()
-    write_model(
-        model_path=args.output_dir,
-        input_base_path=args.input_dir,
-        safe_serialization=args.safe_serialization,
-        num_shards=args.num_shards,
-        instruct=args.instruct,
-    )
-
-    write_tokenizer(
-        tokenizer_path=os.path.join(args.input_dir, "tokenizer.model"),
-        save_dir=args.output_dir,
-        instruct=args.instruct,
-    )
-
-    write_image_processor(
-        config_path=os.path.join(args.input_dir, "params.json"),
-        save_dir=args.output_dir,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/mluke/convert_mluke_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/mluke/convert_mluke_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index f361082fb3c5..000000000000
--- a/src/transformers/models/mluke/convert_mluke_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,229 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert mLUKE checkpoint."""
-
-import argparse
-import json
-import os
-from collections import OrderedDict
-
-import torch
-
-from transformers import LukeConfig, LukeForMaskedLM, MLukeTokenizer, XLMRobertaTokenizer
-from transformers.tokenization_utils_base import AddedToken
-
-
-@torch.no_grad()
-def convert_luke_checkpoint(checkpoint_path, metadata_path, entity_vocab_path, pytorch_dump_folder_path, model_size):
-    # Load configuration defined in the metadata file
-    with open(metadata_path) as metadata_file:
-        metadata = json.load(metadata_file)
-    config = LukeConfig(use_entity_aware_attention=True, **metadata["model_config"])
-
-    # Load in the weights from the checkpoint_path
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["module"]
-
-    # Load the entity vocab file
-    entity_vocab = load_original_entity_vocab(entity_vocab_path)
-    # add an entry for [MASK2]
-    entity_vocab["[MASK2]"] = max(entity_vocab.values()) + 1
-    config.entity_vocab_size += 1
-
-    tokenizer = XLMRobertaTokenizer.from_pretrained(metadata["model_config"]["bert_model_name"])
-
-    # Add special tokens to the token vocabulary for downstream tasks
-    entity_token_1 = AddedToken("<ent>", lstrip=False, rstrip=False)
-    entity_token_2 = AddedToken("<ent2>", lstrip=False, rstrip=False)
-    tokenizer.add_special_tokens({"additional_special_tokens": [entity_token_1, entity_token_2]})
-    config.vocab_size += 2
-
-    print(f"Saving tokenizer to {pytorch_dump_folder_path}")
-    tokenizer.save_pretrained(pytorch_dump_folder_path)
-    with open(os.path.join(pytorch_dump_folder_path, "tokenizer_config.json"), "r") as f:
-        tokenizer_config = json.load(f)
-    tokenizer_config["tokenizer_class"] = "MLukeTokenizer"
-    with open(os.path.join(pytorch_dump_folder_path, "tokenizer_config.json"), "w") as f:
-        json.dump(tokenizer_config, f)
-
-    with open(os.path.join(pytorch_dump_folder_path, MLukeTokenizer.vocab_files_names["entity_vocab_file"]), "w") as f:
-        json.dump(entity_vocab, f)
-
-    tokenizer = MLukeTokenizer.from_pretrained(pytorch_dump_folder_path)
-
-    # Initialize the embeddings of the special tokens
-    ent_init_index = tokenizer.convert_tokens_to_ids(["@"])[0]
-    ent2_init_index = tokenizer.convert_tokens_to_ids(["#"])[0]
-
-    word_emb = state_dict["embeddings.word_embeddings.weight"]
-    ent_emb = word_emb[ent_init_index].unsqueeze(0)
-    ent2_emb = word_emb[ent2_init_index].unsqueeze(0)
-    state_dict["embeddings.word_embeddings.weight"] = torch.cat([word_emb, ent_emb, ent2_emb])
-    # add special tokens for 'entity_predictions.bias'
-    for bias_name in ["lm_head.decoder.bias", "lm_head.bias"]:
-        decoder_bias = state_dict[bias_name]
-        ent_decoder_bias = decoder_bias[ent_init_index].unsqueeze(0)
-        ent2_decoder_bias = decoder_bias[ent2_init_index].unsqueeze(0)
-        state_dict[bias_name] = torch.cat([decoder_bias, ent_decoder_bias, ent2_decoder_bias])
-
-    # Initialize the query layers of the entity-aware self-attention mechanism
-    for layer_index in range(config.num_hidden_layers):
-        for matrix_name in ["query.weight", "query.bias"]:
-            prefix = f"encoder.layer.{layer_index}.attention.self."
-            state_dict[prefix + "w2e_" + matrix_name] = state_dict[prefix + matrix_name]
-            state_dict[prefix + "e2w_" + matrix_name] = state_dict[prefix + matrix_name]
-            state_dict[prefix + "e2e_" + matrix_name] = state_dict[prefix + matrix_name]
-
-    # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks
-    entity_emb = state_dict["entity_embeddings.entity_embeddings.weight"]
-    entity_mask_emb = entity_emb[entity_vocab["[MASK]"]].unsqueeze(0)
-    state_dict["entity_embeddings.entity_embeddings.weight"] = torch.cat([entity_emb, entity_mask_emb])
-    # add [MASK2] for 'entity_predictions.bias'
-    entity_prediction_bias = state_dict["entity_predictions.bias"]
-    entity_mask_bias = entity_prediction_bias[entity_vocab["[MASK]"]].unsqueeze(0)
-    state_dict["entity_predictions.bias"] = torch.cat([entity_prediction_bias, entity_mask_bias])
-
-    model = LukeForMaskedLM(config=config).eval()
-
-    state_dict.pop("entity_predictions.decoder.weight")
-    state_dict.pop("lm_head.decoder.weight")
-    state_dict.pop("lm_head.decoder.bias")
-    state_dict_for_hugging_face = OrderedDict()
-    for key, value in state_dict.items():
-        if not (key.startswith("lm_head") or key.startswith("entity_predictions")):
-            state_dict_for_hugging_face[f"luke.{key}"] = state_dict[key]
-        else:
-            state_dict_for_hugging_face[key] = state_dict[key]
-
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict_for_hugging_face, strict=False)
-
-    if set(unexpected_keys) != {"luke.embeddings.position_ids"}:
-        raise ValueError(f"Unexpected unexpected_keys: {unexpected_keys}")
-    if set(missing_keys) != {
-        "lm_head.decoder.weight",
-        "lm_head.decoder.bias",
-        "entity_predictions.decoder.weight",
-    }:
-        raise ValueError(f"Unexpected missing_keys: {missing_keys}")
-
-    model.tie_weights()
-    assert (model.luke.embeddings.word_embeddings.weight == model.lm_head.decoder.weight).all()
-    assert (model.luke.entity_embeddings.entity_embeddings.weight == model.entity_predictions.decoder.weight).all()
-
-    # Check outputs
-    tokenizer = MLukeTokenizer.from_pretrained(pytorch_dump_folder_path, task="entity_classification")
-
-    text = "ISO 639-3 uses the code fas for the dialects spoken across Iran and アフガニスタン (Afghanistan)."
-    span = (0, 9)
-    encoding = tokenizer(text, entity_spans=[span], return_tensors="pt")
-
-    outputs = model(**encoding)
-
-    # Verify word hidden states
-    if model_size == "large":
-        raise NotImplementedError
-    else:  # base
-        expected_shape = torch.Size((1, 33, 768))
-        expected_slice = torch.tensor([[0.0892, 0.0596, -0.2819], [0.0134, 0.1199, 0.0573], [-0.0169, 0.0927, 0.0644]])
-
-    if not (outputs.last_hidden_state.shape == expected_shape):
-        raise ValueError(
-            f"Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}"
-        )
-    if not torch.allclose(outputs.last_hidden_state[0, :3, :3], expected_slice, atol=1e-4):
-        raise ValueError
-
-    # Verify entity hidden states
-    if model_size == "large":
-        raise NotImplementedError
-    else:  # base
-        expected_shape = torch.Size((1, 1, 768))
-        expected_slice = torch.tensor([[-0.1482, 0.0609, 0.0322]])
-
-    if not (outputs.entity_last_hidden_state.shape == expected_shape):
-        raise ValueError(
-            f"Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is"
-            f" {expected_shape}"
-        )
-    if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3], expected_slice, atol=1e-4):
-        raise ValueError
-
-    # Verify masked word/entity prediction
-    tokenizer = MLukeTokenizer.from_pretrained(pytorch_dump_folder_path)
-    text = "Tokyo is the capital of <mask>."
-    span = (24, 30)
-    encoding = tokenizer(text, entity_spans=[span], return_tensors="pt")
-
-    outputs = model(**encoding)
-
-    input_ids = encoding["input_ids"][0].tolist()
-    mask_position_id = input_ids.index(tokenizer.convert_tokens_to_ids("<mask>"))
-    predicted_id = outputs.logits[0][mask_position_id].argmax(dim=-1)
-    assert "Japan" == tokenizer.decode(predicted_id)
-
-    predicted_entity_id = outputs.entity_logits[0][0].argmax().item()
-    multilingual_predicted_entities = [
-        entity for entity, entity_id in tokenizer.entity_vocab.items() if entity_id == predicted_entity_id
-    ]
-    assert [e for e in multilingual_predicted_entities if e.startswith("en:")][0] == "en:Japan"
-
-    # Finally, save our PyTorch model and tokenizer
-    print("Saving PyTorch model to {}".format(pytorch_dump_folder_path))
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-def load_original_entity_vocab(entity_vocab_path):
-    SPECIAL_TOKENS = ["[MASK]", "[PAD]", "[UNK]"]
-
-    data = [json.loads(line) for line in open(entity_vocab_path)]
-
-    new_mapping = {}
-    for entry in data:
-        entity_id = entry["id"]
-        for entity_name, language in entry["entities"]:
-            if entity_name in SPECIAL_TOKENS:
-                new_mapping[entity_name] = entity_id
-                break
-            new_entity_name = f"{language}:{entity_name}"
-            new_mapping[new_entity_name] = entity_id
-    return new_mapping
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("--checkpoint_path", type=str, help="Path to a pytorch_model.bin file.")
-    parser.add_argument(
-        "--metadata_path", default=None, type=str, help="Path to a metadata.json file, defining the configuration."
-    )
-    parser.add_argument(
-        "--entity_vocab_path",
-        default=None,
-        type=str,
-        help="Path to an entity_vocab.tsv file, containing the entity vocabulary.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to where to dump the output PyTorch model."
-    )
-    parser.add_argument(
-        "--model_size", default="base", type=str, choices=["base", "large"], help="Size of the model to be converted."
-    )
-    args = parser.parse_args()
-    convert_luke_checkpoint(
-        args.checkpoint_path,
-        args.metadata_path,
-        args.entity_vocab_path,
-        args.pytorch_dump_folder_path,
-        args.model_size,
-    )
diff --git a/src/transformers/models/mobilebert/convert_mobilebert_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/mobilebert/convert_mobilebert_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index 022a9d036cdb..000000000000
--- a/src/transformers/models/mobilebert/convert_mobilebert_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import torch
-
-from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, mobilebert_config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = MobileBertConfig.from_json_file(mobilebert_config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = MobileBertForPreTraining(config)
-    # Load weights from tf checkpoint
-    model = load_tf_weights_in_mobilebert(model, config, tf_checkpoint_path)
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--mobilebert_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained MobileBERT model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/mobilenet_v1/convert_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/mobilenet_v1/convert_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index 1b53bbeab475..000000000000
--- a/src/transformers/models/mobilenet_v1/convert_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,141 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MobileNetV1 checkpoints from the tensorflow/models library."""
-
-import argparse
-import json
-import re
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    MobileNetV1Config,
-    MobileNetV1ForImageClassification,
-    MobileNetV1ImageProcessor,
-    load_tf_weights_in_mobilenet_v1,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_mobilenet_v1_config(model_name):
-    config = MobileNetV1Config(layer_norm_eps=0.001)
-
-    if "_quant" in model_name:
-        raise ValueError("Quantized models are not supported.")
-
-    matches = re.match(r"^mobilenet_v1_([^_]*)_([^_]*)$", model_name)
-    if matches:
-        config.depth_multiplier = float(matches[1])
-        config.image_size = int(matches[2])
-
-    # The TensorFlow version of MobileNetV1 predicts 1001 classes instead of
-    # the usual 1000. The first class (index 0) is "background".
-    config.num_labels = 1001
-    filename = "imagenet-1k-id2label.json"
-    repo_id = "huggingface/label-files"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k) + 1: v for k, v in id2label.items()}
-    id2label[0] = "background"
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_movilevit_checkpoint(model_name, checkpoint_path, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our MobileNetV1 structure.
-    """
-    config = get_mobilenet_v1_config(model_name)
-
-    # Load 🤗 model
-    model = MobileNetV1ForImageClassification(config).eval()
-
-    # Load weights from TensorFlow checkpoint
-    load_tf_weights_in_mobilenet_v1(model, config, checkpoint_path)
-
-    # Check outputs on an image, prepared by MobileNetV1ImageProcessor
-    image_processor = MobileNetV1ImageProcessor(
-        crop_size={"width": config.image_size, "height": config.image_size},
-        size={"shortest_edge": config.image_size + 32},
-    )
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    outputs = model(**encoding)
-    logits = outputs.logits
-
-    assert logits.shape == (1, 1001)
-
-    if model_name == "mobilenet_v1_1.0_224":
-        expected_logits = torch.tensor([-4.1739, -1.1233, 3.1205])
-    elif model_name == "mobilenet_v1_0.75_192":
-        expected_logits = torch.tensor([-3.9440, -2.3141, -0.3333])
-    else:
-        expected_logits = None
-
-    if expected_logits is not None:
-        assert torch.allclose(logits[0, :3], expected_logits, atol=1e-4)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing to the hub...")
-        repo_id = "google/" + model_name
-        image_processor.push_to_hub(repo_id)
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="mobilenet_v1_1.0_224",
-        type=str,
-        help="Name of the MobileNetV1 model you'd like to convert. Should in the form 'mobilenet_v1_<depth>_<size>'.",
-    )
-    parser.add_argument(
-        "--checkpoint_path", required=True, type=str, help="Path to the original TensorFlow checkpoint (.ckpt file)."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_movilevit_checkpoint(
-        args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
-    )
diff --git a/src/transformers/models/mobilenet_v2/convert_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/mobilenet_v2/convert_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index 1fdb9783ccf0..000000000000
--- a/src/transformers/models/mobilenet_v2/convert_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,177 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MobileNetV2 checkpoints from the tensorflow/models library."""
-
-import argparse
-import json
-import re
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    MobileNetV2Config,
-    MobileNetV2ForImageClassification,
-    MobileNetV2ForSemanticSegmentation,
-    MobileNetV2ImageProcessor,
-    load_tf_weights_in_mobilenet_v2,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_mobilenet_v2_config(model_name):
-    config = MobileNetV2Config(layer_norm_eps=0.001)
-
-    if "quant" in model_name:
-        raise ValueError("Quantized models are not supported.")
-
-    matches = re.match(r"^.*mobilenet_v2_([^_]*)_([^_]*)$", model_name)
-    if matches:
-        config.depth_multiplier = float(matches[1])
-        config.image_size = int(matches[2])
-
-    if model_name.startswith("deeplabv3_"):
-        config.output_stride = 8
-        config.num_labels = 21
-        filename = "pascal-voc-id2label.json"
-    else:
-        # The TensorFlow version of MobileNetV2 predicts 1001 classes instead
-        # of the usual 1000. The first class (index 0) is "background".
-        config.num_labels = 1001
-        filename = "imagenet-1k-id2label.json"
-
-    repo_id = "huggingface/label-files"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-
-    if config.num_labels == 1001:
-        id2label = {int(k) + 1: v for k, v in id2label.items()}
-        id2label[0] = "background"
-    else:
-        id2label = {int(k): v for k, v in id2label.items()}
-
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_movilevit_checkpoint(model_name, checkpoint_path, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our MobileNetV2 structure.
-    """
-    config = get_mobilenet_v2_config(model_name)
-
-    # Load 🤗 model
-    if model_name.startswith("deeplabv3_"):
-        model = MobileNetV2ForSemanticSegmentation(config).eval()
-    else:
-        model = MobileNetV2ForImageClassification(config).eval()
-
-    # Load weights from TensorFlow checkpoint
-    load_tf_weights_in_mobilenet_v2(model, config, checkpoint_path)
-
-    # Check outputs on an image, prepared by MobileNetV2ImageProcessor
-    image_processor = MobileNetV2ImageProcessor(
-        crop_size={"width": config.image_size, "height": config.image_size},
-        size={"shortest_edge": config.image_size + 32},
-    )
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    outputs = model(**encoding)
-    logits = outputs.logits
-
-    if model_name.startswith("deeplabv3_"):
-        assert logits.shape == (1, 21, 65, 65)
-
-        if model_name == "deeplabv3_mobilenet_v2_1.0_513":
-            expected_logits = torch.tensor(
-                [
-                    [[17.5790, 17.7581, 18.3355], [18.3257, 18.4230, 18.8973], [18.6169, 18.8650, 19.2187]],
-                    [[-2.1595, -2.0977, -2.3741], [-2.4226, -2.3028, -2.6835], [-2.7819, -2.5991, -2.7706]],
-                    [[4.2058, 4.8317, 4.7638], [4.4136, 5.0361, 4.9383], [4.5028, 4.9644, 4.8734]],
-                ]
-            )
-
-        else:
-            raise ValueError(f"Unknown model name: {model_name}")
-
-        assert torch.allclose(logits[0, :3, :3, :3], expected_logits, atol=1e-4)
-    else:
-        assert logits.shape == (1, 1001)
-
-        if model_name == "mobilenet_v2_1.4_224":
-            expected_logits = torch.tensor([0.0181, -1.0015, 0.4688])
-        elif model_name == "mobilenet_v2_1.0_224":
-            expected_logits = torch.tensor([0.2445, -1.1993, 0.1905])
-        elif model_name == "mobilenet_v2_0.75_160":
-            expected_logits = torch.tensor([0.2482, 0.4136, 0.6669])
-        elif model_name == "mobilenet_v2_0.35_96":
-            expected_logits = torch.tensor([0.1451, -0.4624, 0.7192])
-        else:
-            expected_logits = None
-
-        if expected_logits is not None:
-            assert torch.allclose(logits[0, :3], expected_logits, atol=1e-4)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing to the hub...")
-        repo_id = "google/" + model_name
-        image_processor.push_to_hub(repo_id)
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="mobilenet_v2_1.0_224",
-        type=str,
-        help="Name of the MobileNetV2 model you'd like to convert. Should in the form 'mobilenet_v2_<depth>_<size>'.",
-    )
-    parser.add_argument(
-        "--checkpoint_path", required=True, type=str, help="Path to the original TensorFlow checkpoint (.ckpt file)."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_movilevit_checkpoint(
-        args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
-    )
diff --git a/src/transformers/models/mobilevit/convert_mlcvnets_to_pytorch.py b/src/transformers/models/mobilevit/convert_mlcvnets_to_pytorch.py
deleted file mode 100644
index 522d6671d127..000000000000
--- a/src/transformers/models/mobilevit/convert_mlcvnets_to_pytorch.py
+++ /dev/null
@@ -1,311 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MobileViT checkpoints from the ml-cvnets library."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    MobileViTConfig,
-    MobileViTForImageClassification,
-    MobileViTForSemanticSegmentation,
-    MobileViTImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_mobilevit_config(mobilevit_name):
-    config = MobileViTConfig()
-
-    # size of the architecture
-    if "mobilevit_s" in mobilevit_name:
-        config.hidden_sizes = [144, 192, 240]
-        config.neck_hidden_sizes = [16, 32, 64, 96, 128, 160, 640]
-    elif "mobilevit_xs" in mobilevit_name:
-        config.hidden_sizes = [96, 120, 144]
-        config.neck_hidden_sizes = [16, 32, 48, 64, 80, 96, 384]
-    elif "mobilevit_xxs" in mobilevit_name:
-        config.hidden_sizes = [64, 80, 96]
-        config.neck_hidden_sizes = [16, 16, 24, 48, 64, 80, 320]
-        config.hidden_dropout_prob = 0.05
-        config.expand_ratio = 2.0
-
-    if mobilevit_name.startswith("deeplabv3_"):
-        config.image_size = 512
-        config.output_stride = 16
-        config.num_labels = 21
-        filename = "pascal-voc-id2label.json"
-    else:
-        config.num_labels = 1000
-        filename = "imagenet-1k-id2label.json"
-
-    repo_id = "huggingface/label-files"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-def rename_key(name, base_model=False):
-    for i in range(1, 6):
-        if f"layer_{i}." in name:
-            name = name.replace(f"layer_{i}.", f"encoder.layer.{i - 1}.")
-
-    if "conv_1." in name:
-        name = name.replace("conv_1.", "conv_stem.")
-    if ".block." in name:
-        name = name.replace(".block.", ".")
-
-    if "exp_1x1" in name:
-        name = name.replace("exp_1x1", "expand_1x1")
-    if "red_1x1" in name:
-        name = name.replace("red_1x1", "reduce_1x1")
-    if ".local_rep.conv_3x3." in name:
-        name = name.replace(".local_rep.conv_3x3.", ".conv_kxk.")
-    if ".local_rep.conv_1x1." in name:
-        name = name.replace(".local_rep.conv_1x1.", ".conv_1x1.")
-    if ".norm." in name:
-        name = name.replace(".norm.", ".normalization.")
-    if ".conv." in name:
-        name = name.replace(".conv.", ".convolution.")
-    if ".conv_proj." in name:
-        name = name.replace(".conv_proj.", ".conv_projection.")
-
-    for i in range(0, 2):
-        for j in range(0, 4):
-            if f".{i}.{j}." in name:
-                name = name.replace(f".{i}.{j}.", f".{i}.layer.{j}.")
-
-    for i in range(2, 6):
-        for j in range(0, 4):
-            if f".{i}.{j}." in name:
-                name = name.replace(f".{i}.{j}.", f".{i}.")
-                if "expand_1x1" in name:
-                    name = name.replace("expand_1x1", "downsampling_layer.expand_1x1")
-                if "conv_3x3" in name:
-                    name = name.replace("conv_3x3", "downsampling_layer.conv_3x3")
-                if "reduce_1x1" in name:
-                    name = name.replace("reduce_1x1", "downsampling_layer.reduce_1x1")
-
-    for i in range(2, 5):
-        if f".global_rep.{i}.weight" in name:
-            name = name.replace(f".global_rep.{i}.weight", ".layernorm.weight")
-        if f".global_rep.{i}.bias" in name:
-            name = name.replace(f".global_rep.{i}.bias", ".layernorm.bias")
-
-    if ".global_rep." in name:
-        name = name.replace(".global_rep.", ".transformer.")
-    if ".pre_norm_mha.0." in name:
-        name = name.replace(".pre_norm_mha.0.", ".layernorm_before.")
-    if ".pre_norm_mha.1.out_proj." in name:
-        name = name.replace(".pre_norm_mha.1.out_proj.", ".attention.output.dense.")
-    if ".pre_norm_ffn.0." in name:
-        name = name.replace(".pre_norm_ffn.0.", ".layernorm_after.")
-    if ".pre_norm_ffn.1." in name:
-        name = name.replace(".pre_norm_ffn.1.", ".intermediate.dense.")
-    if ".pre_norm_ffn.4." in name:
-        name = name.replace(".pre_norm_ffn.4.", ".output.dense.")
-    if ".transformer." in name:
-        name = name.replace(".transformer.", ".transformer.layer.")
-
-    if ".aspp_layer." in name:
-        name = name.replace(".aspp_layer.", ".")
-    if ".aspp_pool." in name:
-        name = name.replace(".aspp_pool.", ".")
-    if "seg_head." in name:
-        name = name.replace("seg_head.", "segmentation_head.")
-    if "segmentation_head.classifier.classifier." in name:
-        name = name.replace("segmentation_head.classifier.classifier.", "segmentation_head.classifier.")
-
-    if "classifier.fc." in name:
-        name = name.replace("classifier.fc.", "classifier.")
-    elif (not base_model) and ("segmentation_head." not in name):
-        name = "mobilevit." + name
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, model, base_model=False):
-    if base_model:
-        model_prefix = ""
-    else:
-        model_prefix = "mobilevit."
-
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if key[:8] == "encoder.":
-            key = key[8:]
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[0][6:]) - 1
-            transformer_num = int(key_split[3])
-            layer = model.get_submodule(f"{model_prefix}encoder.layer.{layer_num}")
-            dim = layer.transformer.layer[transformer_num].attention.attention.all_head_size
-            prefix = (
-                f"{model_prefix}encoder.layer.{layer_num}.transformer.layer.{transformer_num}.attention.attention."
-            )
-            if "weight" in key:
-                orig_state_dict[prefix + "query.weight"] = val[:dim, :]
-                orig_state_dict[prefix + "key.weight"] = val[dim : dim * 2, :]
-                orig_state_dict[prefix + "value.weight"] = val[-dim:, :]
-            else:
-                orig_state_dict[prefix + "query.bias"] = val[:dim]
-                orig_state_dict[prefix + "key.bias"] = val[dim : dim * 2]
-                orig_state_dict[prefix + "value.bias"] = val[-dim:]
-        else:
-            orig_state_dict[rename_key(key, base_model)] = val
-
-    return orig_state_dict
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_movilevit_checkpoint(mobilevit_name, checkpoint_path, pytorch_dump_folder_path, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our MobileViT structure.
-    """
-    config = get_mobilevit_config(mobilevit_name)
-
-    # load original state_dict
-    state_dict = torch.load(checkpoint_path, map_location="cpu")
-
-    # load 🤗 model
-    if mobilevit_name.startswith("deeplabv3_"):
-        model = MobileViTForSemanticSegmentation(config).eval()
-    else:
-        model = MobileViTForImageClassification(config).eval()
-
-    new_state_dict = convert_state_dict(state_dict, model)
-    model.load_state_dict(new_state_dict)
-
-    # Check outputs on an image, prepared by MobileViTImageProcessor
-    image_processor = MobileViTImageProcessor(crop_size=config.image_size, size=config.image_size + 32)
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    outputs = model(**encoding)
-    logits = outputs.logits
-
-    if mobilevit_name.startswith("deeplabv3_"):
-        assert logits.shape == (1, 21, 32, 32)
-
-        if mobilevit_name == "deeplabv3_mobilevit_s":
-            expected_logits = torch.tensor(
-                [
-                    [[6.2065, 6.1292, 6.2070], [6.1079, 6.1254, 6.1747], [6.0042, 6.1071, 6.1034]],
-                    [[-6.9253, -6.8653, -7.0398], [-7.3218, -7.3983, -7.3670], [-7.1961, -7.2482, -7.1569]],
-                    [[-4.4723, -4.4348, -4.3769], [-5.3629, -5.4632, -5.4598], [-5.1587, -5.3402, -5.5059]],
-                ]
-            )
-        elif mobilevit_name == "deeplabv3_mobilevit_xs":
-            expected_logits = torch.tensor(
-                [
-                    [[5.4449, 5.5733, 5.6314], [5.1815, 5.3930, 5.5963], [5.1656, 5.4333, 5.4853]],
-                    [[-9.4423, -9.7766, -9.6714], [-9.1581, -9.5720, -9.5519], [-9.1006, -9.6458, -9.5703]],
-                    [[-7.7721, -7.3716, -7.1583], [-8.4599, -8.0624, -7.7944], [-8.4172, -7.8366, -7.5025]],
-                ]
-            )
-        elif mobilevit_name == "deeplabv3_mobilevit_xxs":
-            expected_logits = torch.tensor(
-                [
-                    [[6.9811, 6.9743, 7.3123], [7.1777, 7.1931, 7.3938], [7.5633, 7.8050, 7.8901]],
-                    [[-10.5536, -10.2332, -10.2924], [-10.2336, -9.8624, -9.5964], [-10.8840, -10.8158, -10.6659]],
-                    [[-3.4938, -3.0631, -2.8620], [-3.4205, -2.8135, -2.6875], [-3.4179, -2.7945, -2.8750]],
-                ]
-            )
-        else:
-            raise ValueError(f"Unknown mobilevit_name: {mobilevit_name}")
-
-        assert torch.allclose(logits[0, :3, :3, :3], expected_logits, atol=1e-4)
-    else:
-        assert logits.shape == (1, 1000)
-
-        if mobilevit_name == "mobilevit_s":
-            expected_logits = torch.tensor([-0.9866, 0.2392, -1.1241])
-        elif mobilevit_name == "mobilevit_xs":
-            expected_logits = torch.tensor([-2.4761, -0.9399, -1.9587])
-        elif mobilevit_name == "mobilevit_xxs":
-            expected_logits = torch.tensor([-1.9364, -1.2327, -0.4653])
-        else:
-            raise ValueError(f"Unknown mobilevit_name: {mobilevit_name}")
-
-        assert torch.allclose(logits[0, :3], expected_logits, atol=1e-4)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {mobilevit_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model_mapping = {
-            "mobilevit_s": "mobilevit-small",
-            "mobilevit_xs": "mobilevit-x-small",
-            "mobilevit_xxs": "mobilevit-xx-small",
-            "deeplabv3_mobilevit_s": "deeplabv3-mobilevit-small",
-            "deeplabv3_mobilevit_xs": "deeplabv3-mobilevit-x-small",
-            "deeplabv3_mobilevit_xxs": "deeplabv3-mobilevit-xx-small",
-        }
-
-        print("Pushing to the hub...")
-        model_name = model_mapping[mobilevit_name]
-        image_processor.push_to_hub(model_name, organization="apple")
-        model.push_to_hub(model_name, organization="apple")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--mobilevit_name",
-        default="mobilevit_s",
-        type=str,
-        help=(
-            "Name of the MobileViT model you'd like to convert. Should be one of 'mobilevit_s', 'mobilevit_xs',"
-            " 'mobilevit_xxs', 'deeplabv3_mobilevit_s', 'deeplabv3_mobilevit_xs', 'deeplabv3_mobilevit_xxs'."
-        ),
-    )
-    parser.add_argument(
-        "--checkpoint_path", required=True, type=str, help="Path to the original state dict (.pt file)."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_movilevit_checkpoint(
-        args.mobilevit_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
-    )
diff --git a/src/transformers/models/mobilevitv2/convert_mlcvnets_to_pytorch.py b/src/transformers/models/mobilevitv2/convert_mlcvnets_to_pytorch.py
deleted file mode 100644
index d08642666cdb..000000000000
--- a/src/transformers/models/mobilevitv2/convert_mlcvnets_to_pytorch.py
+++ /dev/null
@@ -1,332 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MobileViTV2 checkpoints from the ml-cvnets library."""
-
-import argparse
-import collections
-import json
-from pathlib import Path
-
-import requests
-import torch
-import yaml
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    MobileViTImageProcessor,
-    MobileViTV2Config,
-    MobileViTV2ForImageClassification,
-    MobileViTV2ForSemanticSegmentation,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def load_orig_config_file(orig_cfg_file):
-    print("Loading config file...")
-
-    def flatten_yaml_as_dict(d, parent_key="", sep="."):
-        items = []
-        for k, v in d.items():
-            new_key = parent_key + sep + k if parent_key else k
-            if isinstance(v, collections.abc.MutableMapping):
-                items.extend(flatten_yaml_as_dict(v, new_key, sep=sep).items())
-            else:
-                items.append((new_key, v))
-        return dict(items)
-
-    config = argparse.Namespace()
-    with open(orig_cfg_file, "r") as yaml_file:
-        try:
-            cfg = yaml.load(yaml_file, Loader=yaml.FullLoader)
-
-            flat_cfg = flatten_yaml_as_dict(cfg)
-            for k, v in flat_cfg.items():
-                setattr(config, k, v)
-        except yaml.YAMLError as exc:
-            logger.error("Error while loading config file: {}. Error message: {}".format(orig_cfg_file, str(exc)))
-    return config
-
-
-def get_mobilevitv2_config(task_name, orig_cfg_file):
-    config = MobileViTV2Config()
-
-    is_segmentation_model = False
-
-    # dataset
-    if task_name.startswith("imagenet1k_"):
-        config.num_labels = 1000
-        if int(task_name.strip().split("_")[-1]) == 384:
-            config.image_size = 384
-        else:
-            config.image_size = 256
-        filename = "imagenet-1k-id2label.json"
-    elif task_name.startswith("imagenet21k_to_1k_"):
-        config.num_labels = 21000
-        if int(task_name.strip().split("_")[-1]) == 384:
-            config.image_size = 384
-        else:
-            config.image_size = 256
-        filename = "imagenet-22k-id2label.json"
-    elif task_name.startswith("ade20k_"):
-        config.num_labels = 151
-        config.image_size = 512
-        filename = "ade20k-id2label.json"
-        is_segmentation_model = True
-    elif task_name.startswith("voc_"):
-        config.num_labels = 21
-        config.image_size = 512
-        filename = "pascal-voc-id2label.json"
-        is_segmentation_model = True
-
-    # orig_config
-    orig_config = load_orig_config_file(orig_cfg_file)
-    assert getattr(orig_config, "model.classification.name", -1) == "mobilevit_v2", "Invalid model"
-    config.width_multiplier = getattr(orig_config, "model.classification.mitv2.width_multiplier", 1.0)
-    assert getattr(orig_config, "model.classification.mitv2.attn_norm_layer", -1) == "layer_norm_2d", (
-        "Norm layers other than layer_norm_2d is not supported"
-    )
-    config.hidden_act = getattr(orig_config, "model.classification.activation.name", "swish")
-    # config.image_size == getattr(orig_config,  'sampler.bs.crop_size_width', 256)
-
-    if is_segmentation_model:
-        config.output_stride = getattr(orig_config, "model.segmentation.output_stride", 16)
-        if "_deeplabv3" in task_name:
-            config.atrous_rates = getattr(orig_config, "model.segmentation.deeplabv3.aspp_rates", [12, 24, 36])
-            config.aspp_out_channels = getattr(orig_config, "model.segmentation.deeplabv3.aspp_out_channels", 512)
-            config.aspp_dropout_prob = getattr(orig_config, "model.segmentation.deeplabv3.aspp_dropout", 0.1)
-
-    # id2label
-    repo_id = "huggingface/label-files"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def create_rename_keys(state_dict, base_model=False):
-    if base_model:
-        model_prefix = ""
-    else:
-        model_prefix = "mobilevitv2."
-
-    rename_keys = []
-    for k in state_dict.keys():
-        if k[:8] == "encoder.":
-            k_new = k[8:]
-        else:
-            k_new = k
-
-        if ".block." in k:
-            k_new = k_new.replace(".block.", ".")
-        if ".conv." in k:
-            k_new = k_new.replace(".conv.", ".convolution.")
-        if ".norm." in k:
-            k_new = k_new.replace(".norm.", ".normalization.")
-
-        if "conv_1." in k:
-            k_new = k_new.replace("conv_1.", f"{model_prefix}conv_stem.")
-        for i in [1, 2]:
-            if f"layer_{i}." in k:
-                k_new = k_new.replace(f"layer_{i}.", f"{model_prefix}encoder.layer.{i - 1}.layer.")
-        if ".exp_1x1." in k:
-            k_new = k_new.replace(".exp_1x1.", ".expand_1x1.")
-        if ".red_1x1." in k:
-            k_new = k_new.replace(".red_1x1.", ".reduce_1x1.")
-
-        for i in [3, 4, 5]:
-            if f"layer_{i}.0." in k:
-                k_new = k_new.replace(f"layer_{i}.0.", f"{model_prefix}encoder.layer.{i - 1}.downsampling_layer.")
-            if f"layer_{i}.1.local_rep.0." in k:
-                k_new = k_new.replace(f"layer_{i}.1.local_rep.0.", f"{model_prefix}encoder.layer.{i - 1}.conv_kxk.")
-            if f"layer_{i}.1.local_rep.1." in k:
-                k_new = k_new.replace(f"layer_{i}.1.local_rep.1.", f"{model_prefix}encoder.layer.{i - 1}.conv_1x1.")
-
-        for i in [3, 4, 5]:
-            if i == 3:
-                j_in = [0, 1]
-            elif i == 4:
-                j_in = [0, 1, 2, 3]
-            elif i == 5:
-                j_in = [0, 1, 2]
-
-            for j in j_in:
-                if f"layer_{i}.1.global_rep.{j}." in k:
-                    k_new = k_new.replace(
-                        f"layer_{i}.1.global_rep.{j}.", f"{model_prefix}encoder.layer.{i - 1}.transformer.layer.{j}."
-                    )
-            if f"layer_{i}.1.global_rep.{j + 1}." in k:
-                k_new = k_new.replace(
-                    f"layer_{i}.1.global_rep.{j + 1}.", f"{model_prefix}encoder.layer.{i - 1}.layernorm."
-                )
-
-            if f"layer_{i}.1.conv_proj." in k:
-                k_new = k_new.replace(
-                    f"layer_{i}.1.conv_proj.", f"{model_prefix}encoder.layer.{i - 1}.conv_projection."
-                )
-
-        if "pre_norm_attn.0." in k:
-            k_new = k_new.replace("pre_norm_attn.0.", "layernorm_before.")
-        if "pre_norm_attn.1." in k:
-            k_new = k_new.replace("pre_norm_attn.1.", "attention.")
-        if "pre_norm_ffn.0." in k:
-            k_new = k_new.replace("pre_norm_ffn.0.", "layernorm_after.")
-        if "pre_norm_ffn.1." in k:
-            k_new = k_new.replace("pre_norm_ffn.1.", "ffn.conv1.")
-        if "pre_norm_ffn.3." in k:
-            k_new = k_new.replace("pre_norm_ffn.3.", "ffn.conv2.")
-
-        if "classifier.1." in k:
-            k_new = k_new.replace("classifier.1.", "classifier.")
-
-        if "seg_head." in k:
-            k_new = k_new.replace("seg_head.", "segmentation_head.")
-        if ".aspp_layer." in k:
-            k_new = k_new.replace(".aspp_layer.", ".")
-        if ".aspp_pool." in k:
-            k_new = k_new.replace(".aspp_pool.", ".")
-
-        rename_keys.append((k, k_new))
-    return rename_keys
-
-
-def remove_unused_keys(state_dict):
-    """remove unused keys (e.g.: seg_head.aux_head)"""
-    keys_to_ignore = []
-    for k in state_dict.keys():
-        if k.startswith("seg_head.aux_head."):
-            keys_to_ignore.append(k)
-    for k in keys_to_ignore:
-        state_dict.pop(k, None)
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    # url = "https://cdn.britannica.com/86/141086-050-9D7C75EE/Gulfstream-G450-business-jet-passengers.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_mobilevitv2_checkpoint(task_name, checkpoint_path, orig_config_path, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our MobileViTV2 structure.
-    """
-    config = get_mobilevitv2_config(task_name, orig_config_path)
-
-    # load original state_dict
-    checkpoint = torch.load(checkpoint_path, map_location="cpu")
-
-    # load huggingface model
-    if task_name.startswith("ade20k_") or task_name.startswith("voc_"):
-        model = MobileViTV2ForSemanticSegmentation(config).eval()
-        base_model = False
-    else:
-        model = MobileViTV2ForImageClassification(config).eval()
-        base_model = False
-
-    # remove and rename some keys of load the original model
-    state_dict = checkpoint
-    remove_unused_keys(state_dict)
-    rename_keys = create_rename_keys(state_dict, base_model=base_model)
-    for rename_key_src, rename_key_dest in rename_keys:
-        rename_key(state_dict, rename_key_src, rename_key_dest)
-
-    # load modified state_dict
-    model.load_state_dict(state_dict)
-
-    # Check outputs on an image, prepared by MobileViTImageProcessor
-    image_processor = MobileViTImageProcessor(crop_size=config.image_size, size=config.image_size + 32)
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    outputs = model(**encoding)
-
-    # verify classification model
-    if task_name.startswith("imagenet"):
-        logits = outputs.logits
-        predicted_class_idx = logits.argmax(-1).item()
-        print("Predicted class:", model.config.id2label[predicted_class_idx])
-        if task_name.startswith("imagenet1k_256") and config.width_multiplier == 1.0:
-            # expected_logits for base variant
-            expected_logits = torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01])
-            assert torch.allclose(logits[0, :3], expected_logits, atol=1e-4)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {task_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--task",
-        default="imagenet1k_256",
-        type=str,
-        help=(
-            "Name of the task for which the MobileViTV2 model you'd like to convert is trained on . "
-            """
-                Classification (ImageNet-1k)
-                    - MobileViTV2 (256x256) : imagenet1k_256
-                    - MobileViTV2 (Trained on 256x256 and Finetuned on 384x384) : imagenet1k_384
-                    - MobileViTV2 (Trained on ImageNet-21k and Finetuned on ImageNet-1k 256x256) :
-                      imagenet21k_to_1k_256
-                    - MobileViTV2 (Trained on ImageNet-21k, Finetuned on ImageNet-1k 256x256, and Finetuned on
-                      ImageNet-1k 384x384) : imagenet21k_to_1k_384
-                Segmentation
-                    - ADE20K Dataset : ade20k_deeplabv3
-                    - Pascal VOC 2012 Dataset: voc_deeplabv3
-            """
-        ),
-        choices=[
-            "imagenet1k_256",
-            "imagenet1k_384",
-            "imagenet21k_to_1k_256",
-            "imagenet21k_to_1k_384",
-            "ade20k_deeplabv3",
-            "voc_deeplabv3",
-        ],
-    )
-
-    parser.add_argument(
-        "--orig_checkpoint_path", required=True, type=str, help="Path to the original state dict (.pt file)."
-    )
-    parser.add_argument(
-        "--orig_config_path",
-        required=True,
-        type=str,
-        help="Path to the original config file. yaml.load will be used to load the file, please be wary of which file you're loading.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_mobilevitv2_checkpoint(
-        args.task, args.orig_checkpoint_path, args.orig_config_path, args.pytorch_dump_folder_path
-    )
diff --git a/src/transformers/models/moonshine/convert_usefulsensors_to_hf.py b/src/transformers/models/moonshine/convert_usefulsensors_to_hf.py
deleted file mode 100644
index 39d8df0f3fab..000000000000
--- a/src/transformers/models/moonshine/convert_usefulsensors_to_hf.py
+++ /dev/null
@@ -1,169 +0,0 @@
-# Copyright 2025 Useful Sensors and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import re
-
-import h5py
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers.models.moonshine.modeling_moonshine import MoonshineConfig, MoonshineForConditionalGeneration
-
-
-# Copied from https://github.com/usefulsensors/moonshine/blob/a1d77cc573b0471ac4602b86f67b3f48d67df1a9/moonshine/model.py
-def _get_weights(model_name):
-    repo = "UsefulSensors/moonshine"
-
-    return (
-        hf_hub_download(repo, f"{x}.weights.h5", subfolder=model_name) for x in ("preprocessor", "encoder", "decoder")
-    )
-
-
-def _read_h5_weights(group, current_key="", weights={}):
-    for key in group.keys():
-        full_key = f"{current_key}.{key}" if current_key else key
-        if isinstance(group[key], h5py.Dataset):
-            w = np.array(group[key])
-            w = torch.from_numpy(w)
-            if len(w.shape) > 1:
-                if len(w.shape) == 3:
-                    hidden_size = max(list(w.shape))
-                    try:
-                        w = w.reshape(hidden_size, hidden_size)
-                    except RuntimeError:
-                        # meaning its a conv layers
-                        pass
-                w = w.transpose(0, -1)
-            weights[full_key] = w
-        else:
-            _read_h5_weights(group[key], full_key, weights)
-    return weights
-
-
-def _convert_layer_names(name, gated_mlp=False):
-    name = re.sub(
-        r"layers\.functional(?:_(\d+))?\.layers",
-        lambda m: f"layers.{m.group(1) if m.group(1) else '0'}",
-        name,
-        count=1,
-    )
-    if gated_mlp:
-        name = re.sub(r"functional\.layers\.dense\.", "mlp.fc1.", name)
-        name = re.sub(r"functional\.layers\.dense_1\.", "mlp.fc2.", name)
-    else:
-        name = re.sub(r"functional\.layers\.sequential\.layers\.dense\.", "mlp.fc1.", name)
-        name = re.sub(r"functional\.layers\.sequential\.layers\.dense_1\.", "mlp.fc2.", name)
-    name = re.sub(r"layers\.sequential\.layers\.conv1d\.", "conv1.", name)
-    name = re.sub(r"layers\.sequential\.layers\.conv1d_1\.", "conv2.", name)
-    name = re.sub(r"layers\.sequential\.layers\.conv1d_2\.", "conv3.", name)
-    name = re.sub(r"layers\.sequential\.layers\.group_normalization\.", "groupnorm.", name)
-    name = re.sub(r"mha_with_rope\.key_dense", "self_attn.k_proj", name)
-    name = re.sub(r"mha_with_rope\.query_dense", "self_attn.q_proj", name)
-    name = re.sub(r"mha_with_rope\.value_dense", "self_attn.v_proj", name)
-    name = re.sub(r"mha_with_rope\.output_dense", "self_attn.o_proj", name)
-    name = re.sub(r"mha_precomputed_kv\.key_dense", "encoder_attn.k_proj", name)
-    name = re.sub(r"mha_precomputed_kv\.query_dense", "encoder_attn.q_proj", name)
-    name = re.sub(r"mha_precomputed_kv\.value_dense", "encoder_attn.v_proj", name)
-    name = re.sub(r"mha_precomputed_kv\.output_dense", "encoder_attn.o_proj", name)
-    name = re.sub(r"mha_causal_with_rope\.key_dense", "self_attn.k_proj", name)
-    name = re.sub(r"mha_causal_with_rope\.query_dense", "self_attn.q_proj", name)
-    name = re.sub(r"mha_causal_with_rope\.value_dense", "self_attn.v_proj", name)
-    name = re.sub(r"mha_causal_with_rope\.output_dense", "self_attn.o_proj", name)
-    name = re.sub(r"layer_normalization\.", "input_layernorm.", name)
-    name = re.sub(r"layer_normalization_1\.", "post_attention_layernorm.", name)
-    name = re.sub(r"layer_normalization_2\.", "final_layernorm.", name)
-    name = re.sub(r"vars\.0", "weight", name)
-    name = re.sub(r"vars\.1", "bias", name)
-    name = re.sub(r"layers\.reversible_embedding", "embed_tokens", name)
-
-    return name
-
-
-def _convert_weights(weights, encoder=True):
-    if "layers.rotary_embedding.vars.0" in weights:
-        weights.pop("layers.rotary_embedding.vars.0")
-
-    converted_weights = {}
-    if encoder:
-        converted_weights["layer_norm.weight"] = weights.pop("layers.layer_normalization.vars.0")
-    else:
-        converted_weights["norm.weight"] = weights.pop("layers.layer_normalization.vars.0")
-
-    for name, w in weights.items():
-        if encoder:
-            new_name = _convert_layer_names(name)
-        else:
-            new_name = _convert_layer_names(name, gated_mlp=True)
-        converted_weights[new_name] = w
-
-    return converted_weights
-
-
-def convert_usefulsensors_moonshine_to_hf(model_name, pytorch_dump_folder_path):
-    preprocessor_weights_path, encoder_weights_path, decoder_weights_path = _get_weights(model_name)
-
-    with h5py.File(preprocessor_weights_path, "r") as f:
-        loaded_preprocessor_weights = _read_h5_weights(f, weights={})
-
-    with h5py.File(encoder_weights_path, "r") as f:
-        loaded_encoder_weights = _read_h5_weights(f, weights={})
-
-    with h5py.File(decoder_weights_path, "r") as f:
-        loaded_decoder_weights = _read_h5_weights(f, weights={})
-
-    encoder_state_dict = {**loaded_encoder_weights, **loaded_preprocessor_weights}
-    converted_encoder_state_dict = _convert_weights(encoder_state_dict)
-
-    converted_decoder_state_dict = _convert_weights(loaded_decoder_weights, encoder=False)
-    converted_decoder_state_dict["embed_tokens.weight"] = converted_decoder_state_dict["embed_tokens.weight"].T
-
-    final_weights = {}
-    for k, v in converted_encoder_state_dict.items():
-        final_weights[f"model.encoder.{k}"] = v
-
-    for k, v in converted_decoder_state_dict.items():
-        final_weights[f"model.decoder.{k}"] = v
-
-    if model_name == "tiny":
-        config = MoonshineConfig()
-    elif model_name == "base":
-        config = MoonshineConfig(
-            hidden_size=416,
-            intermediate_size=1664,
-            encoder_num_hidden_layers=8,
-            decoder_num_hidden_layers=8,
-            encoder_num_attention_heads=8,
-            decoder_num_attention_heads=8,
-            partial_rotary_factor=0.62,
-        )
-    else:
-        raise ValueError(f"Unknown model name {model_name}")
-
-    final_weights["proj_out.weight"] = converted_decoder_state_dict["embed_tokens.weight"]
-
-    model = MoonshineForConditionalGeneration(config)
-    model.load_state_dict(final_weights)
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # # Required parameters
-    parser.add_argument("--model_name", type=str, help="Path to the downloaded checkpoints")
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    args = parser.parse_args()
-
-    convert_usefulsensors_moonshine_to_hf(args.model_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/moshi/convert_moshi_transformers.py b/src/transformers/models/moshi/convert_moshi_transformers.py
deleted file mode 100644
index 55d8f77ad045..000000000000
--- a/src/transformers/models/moshi/convert_moshi_transformers.py
+++ /dev/null
@@ -1,311 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Moshi checkpoints."""
-
-import argparse
-
-import safetensors
-import sentencepiece
-import torch
-
-from transformers import (
-    AutoFeatureExtractor,
-    GenerationConfig,
-    MimiModel,  # initial audio encoder
-    MoshiConfig,
-    MoshiForConditionalGeneration,
-    PreTrainedTokenizerFast,
-    logging,
-)
-from transformers.convert_slow_tokenizer import MoshiConverter
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.mimi")
-
-
-def assert_param_count(model_1, model_2):
-    count_1 = sum(p[1].numel() for p in model_1.named_parameters() if "final_proj" not in p[0])
-    count_2 = sum(p[1].numel() for p in model_2.named_parameters() if "final_proj" not in p[0])
-    assert count_1 == count_2, f"{model_1.__class__}: {count_1} != {model_2.__class__}: {count_2}"
-
-
-def param_count(model):
-    return sum(p[1].numel() for p in model.named_parameters() if "final_proj" not in p[0])
-
-
-def _grab_best_device(use_gpu=True):
-    if torch.cuda.device_count() > 0 and use_gpu:
-        device = "cuda"
-    else:
-        device = "cpu"
-    return torch.device(device)
-
-
-convert_list = [
-    # GENERAL
-    ("out_norm", "decoder.model.norm"),
-    ("depformer_emb", "depth_decoder.emb"),
-    ("depformer_text_emb", "depth_decoder.text_emb"),
-    ("text_emb", "decoder.model.emb"),
-    ("emb", "embed_tokens"),
-    ("text_linear", "decoder.lm_head"),
-    ("depformer", "depth_decoder"),
-    ("transformer", "decoder.model"),
-    # TRANSFORMERS PART
-    ("gating.linear_in", "mlp.fc1"),
-    ("gating.linear_out", "mlp.fc2"),
-    ("self_attn.out_proj", "self_attn.o_proj.linear"),
-    ("norm1", "input_layernorm"),
-    ("norm2", "post_attention_layernorm"),
-    ("layer_scale_1", "self_attn_layer_scale"),
-    ("layer_scale_2", "mlp_layer_scale"),
-    ("alpha", "weight"),
-]
-
-
-def _preprocess_state_dict(state_dict, config):
-    # Moshi original weights are using a gating mechanism
-
-    # pattern for depth transformer:
-    # stack(gating.{i}.linear_in)->mlp.fc1
-    # stack(gating.{i}.linear_out)->mlp.fc2
-
-    for layer_idx in range(config.depth_decoder_config.num_hidden_layers):
-        linear_layers_in = [
-            state_dict.pop(f"depformer.layers.{layer_idx}.gating.{i}.linear_in.weight")
-            for i in range(config.num_codebooks)
-        ]
-        linear_layers_out = [
-            state_dict.pop(f"depformer.layers.{layer_idx}.gating.{i}.linear_out.weight")
-            for i in range(config.num_codebooks)
-        ]
-
-        state_dict[f"depth_decoder.layers.{layer_idx}.mlp.fc1.weight"] = torch.stack(linear_layers_in)
-        state_dict[f"depth_decoder.layers.{layer_idx}.mlp.fc2.weight"] = torch.stack(linear_layers_out)
-
-    input_projections = []
-    lm_heads = []
-    for codebook_idx in range(config.num_codebooks):
-        input_projections.append(state_dict.pop(f"depformer_in.{codebook_idx}.weight"))
-        lm_heads.append(state_dict.pop(f"linears.{codebook_idx}.weight"))
-
-    state_dict["depth_decoder.input_projections.weight"] = torch.stack(input_projections, dim=0)
-    state_dict["depth_decoder.lm_heads.weight"] = torch.stack(lm_heads, dim=0)
-
-    return state_dict
-
-
-def _convert_model(
-    state_dict,
-    hf_model,
-    convert_list,
-    device,
-    config,
-    unwanted_prefix=None,
-):
-    hidden_size = config.hidden_size
-    head_dim = config.head_dim
-    num_heads = int(config.hidden_size // config.head_dim)
-    num_key_value_heads = config.num_key_value_heads
-    key_value_head_dim = config.num_key_value_heads * head_dim
-
-    state_dict = _preprocess_state_dict(state_dict, config)
-
-    # permute for sliced rotary
-    def permute(w, n_heads, dim1=hidden_size, dim2=hidden_size):
-        return w.view(n_heads, dim1 // n_heads // 2, 2, dim2).transpose(1, 2).reshape(dim1, dim2)
-
-    for k, v in list(state_dict.items()):
-        if "audio_encoder" not in k:
-            new_k = k if unwanted_prefix is None else k[len(unwanted_prefix) :]
-            for old_layer_name, new_layer_name in convert_list:
-                if old_layer_name in new_k:
-                    new_k = new_k.replace(old_layer_name, new_layer_name)
-
-            if "alpha" in k:
-                state_dict[k] = state_dict[k].squeeze()
-
-            if "in_proj_weight" in new_k:
-                # split qkv into query key and value
-                mixed_qkv = state_dict.pop(k)
-                if "depth_decoder" in new_k:
-                    mixed_qkv = mixed_qkv.view(config.num_codebooks, -1, mixed_qkv.shape[-1])
-
-                    qkv_dim = mixed_qkv.size(1) // 3
-
-                    query_layer = mixed_qkv[:, :qkv_dim]
-                    key_layer = mixed_qkv[:, qkv_dim : qkv_dim * 2]
-                    value_layer = mixed_qkv[:, qkv_dim * 2 :]
-                    state_dict[new_k.replace("in_proj_weight", "q_proj.linear.weight")] = query_layer
-                    state_dict[new_k.replace("in_proj_weight", "k_proj.linear.weight")] = key_layer
-
-                else:
-                    qkv_dim = mixed_qkv.size(0) // 3
-
-                    query_layer = mixed_qkv[:qkv_dim]
-                    key_layer = mixed_qkv[qkv_dim : qkv_dim * 2]
-                    value_layer = mixed_qkv[qkv_dim * 2 :]
-                    state_dict[new_k.replace("in_proj_weight", "q_proj.linear.weight")] = permute(
-                        query_layer, num_heads, hidden_size, hidden_size
-                    )
-                    state_dict[new_k.replace("in_proj_weight", "k_proj.linear.weight")] = permute(
-                        key_layer, num_key_value_heads, key_value_head_dim, hidden_size
-                    )
-
-                state_dict[new_k.replace("in_proj_weight", "v_proj.linear.weight")] = value_layer
-            elif "o_proj" in new_k and "depth_decoder" in new_k:
-                output_layer = state_dict.pop(k)
-                state_dict[new_k] = output_layer.view(config.num_codebooks, -1, output_layer.shape[-1])
-            else:
-                state_dict[new_k] = state_dict.pop(k)
-
-    # Do the last one by hand
-    state_dict["depth_decoder.text_embed_tokens.weight"] = state_dict.pop(
-        "depth_decoder.decoder.model.embed_tokens.weight"
-    )
-
-    extra_keys = set(state_dict.keys()) - set(hf_model.state_dict().keys())
-    missing_keys = set(hf_model.state_dict().keys()) - set(state_dict.keys())
-    if len(extra_keys) != 0:
-        raise ValueError(f"extra keys found: {extra_keys}")
-    if len(missing_keys) != 0:
-        raise ValueError(f"missing keys: {missing_keys}")
-    hf_model.load_state_dict(state_dict, strict=True)
-    n_params = param_count(hf_model)
-
-    logger.info(f"model loaded: {round(n_params / 1e6, 1)}M params")
-
-    hf_model.eval()
-    hf_model.to(device)
-    del state_dict
-
-    return hf_model
-
-
-@torch.no_grad()
-def convert_checkpoint(
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    mimi_repo_id,
-    config_path=None,
-    repo_id=None,
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    device = _grab_best_device()
-
-    mimi_model = MimiModel.from_pretrained(mimi_repo_id, torch_dtype=torch.bfloat16)
-
-    if config_path is not None:
-        config = MoshiConfig.from_pretrained(config_path)
-    else:
-        audio_encoder_config = mimi_model.config
-        config = MoshiConfig.from_audio_encoder_config(audio_encoder_config)
-
-    model = MoshiForConditionalGeneration(config).to(torch.bfloat16)
-
-    depth_decoder_generation_config = GenerationConfig(
-        do_sample=True,
-        temperature=0.8,
-        top_k=250,
-        min_length=config.num_codebooks + 1,
-        max_length=config.num_codebooks + 1,
-        cache_implementation="sliding_window",
-    )
-
-    generation_config = GenerationConfig(
-        do_sample=True,
-        temp=0.7,
-        top_k=25,
-        cache_implementation="sliding_window",
-        pad_token_id=config.vocab_size,
-        bos_token_id=config.vocab_size,
-    )
-    generation_config.depth_decoder_config = depth_decoder_generation_config.to_diff_dict()
-
-    model.generation_config = generation_config
-
-    original_checkpoint = safetensors.torch.load_file(checkpoint_path)
-    if "best_state" in original_checkpoint:
-        # we might have a training state saved, in which case discard the yaml results and just retain the weights
-        original_checkpoint = original_checkpoint["best_state"]
-
-    audio_checkpoint = mimi_model.state_dict()
-    original_checkpoint.update({f"audio_encoder.{key}": value for (key, value) in audio_checkpoint.items()})
-
-    model = _convert_model(original_checkpoint, model, convert_list, device, config)
-
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument(
-        "--tokenizer_vocab_path", required=False, default=None, type=str, help="Path to original tokenizer vocab file"
-    )
-    parser.add_argument("--mimi_repo_id", required=True, default=None, type=str, help="Repository id to HF Mimi.")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-
-    # convert tokenizer
-    if args.tokenizer_vocab_path:
-        original_tokenizer = sentencepiece.SentencePieceProcessor(args.tokenizer_vocab_path)
-        tokenizer = MoshiConverter(args.tokenizer_vocab_path).converted()
-        tokenizer = PreTrainedTokenizerFast(
-            tokenizer_object=tokenizer,
-            chat_template=None,
-            unk_token="<unk>",
-            model_input_names=["input_ids", "attention_mask"],
-            clean_up_tokenization_spaces=False,
-            bos_token_id=original_tokenizer.bos_id(),
-            eos_token_id=original_tokenizer.eos_id(),
-            pad_token_id=original_tokenizer.pad_id(),
-        )
-
-        tokenizer.save_pretrained(args.pytorch_dump_folder_path)
-
-        if args.push_to_hub:
-            print("Pushing the tokenizer to the hub...")
-            tokenizer.push_to_hub(args.push_to_hub)
-
-    # upload feature extractor
-    feature_extractor = AutoFeatureExtractor.from_pretrained(args.mimi_repo_id)
-    feature_extractor.save_pretrained(args.pytorch_dump_folder_path)
-
-    if args.push_to_hub:
-        print("Pushing the feature extractor to the hub...")
-        feature_extractor.push_to_hub(args.push_to_hub)
-
-    convert_checkpoint(
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.mimi_repo_id,
-        args.config_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/mra/convert_mra_pytorch_to_pytorch.py b/src/transformers/models/mra/convert_mra_pytorch_to_pytorch.py
deleted file mode 100644
index f558f7c7bce3..000000000000
--- a/src/transformers/models/mra/convert_mra_pytorch_to_pytorch.py
+++ /dev/null
@@ -1,110 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MRA checkpoints from the original repository. URL: https://github.com/mlpen/mra-attention"""
-
-import argparse
-
-import torch
-
-from transformers import MraConfig, MraForMaskedLM
-
-
-def rename_key(orig_key):
-    if "model" in orig_key:
-        orig_key = orig_key.replace("model.", "")
-    if "norm1" in orig_key:
-        orig_key = orig_key.replace("norm1", "attention.output.LayerNorm")
-    if "norm2" in orig_key:
-        orig_key = orig_key.replace("norm2", "output.LayerNorm")
-    if "norm" in orig_key:
-        orig_key = orig_key.replace("norm", "LayerNorm")
-    if "transformer" in orig_key:
-        layer_num = orig_key.split(".")[0].split("_")[-1]
-        orig_key = orig_key.replace(f"transformer_{layer_num}", f"encoder.layer.{layer_num}")
-    if "mha.attn" in orig_key:
-        orig_key = orig_key.replace("mha.attn", "attention.self")
-    if "mha" in orig_key:
-        orig_key = orig_key.replace("mha", "attention")
-    if "W_q" in orig_key:
-        orig_key = orig_key.replace("W_q", "self.query")
-    if "W_k" in orig_key:
-        orig_key = orig_key.replace("W_k", "self.key")
-    if "W_v" in orig_key:
-        orig_key = orig_key.replace("W_v", "self.value")
-    if "ff.0" in orig_key:
-        orig_key = orig_key.replace("ff.0", "intermediate.dense")
-    if "ff.2" in orig_key:
-        orig_key = orig_key.replace("ff.2", "output.dense")
-    if "ff" in orig_key:
-        orig_key = orig_key.replace("ff", "output.dense")
-    if "mlm_class" in orig_key:
-        orig_key = orig_key.replace("mlm.mlm_class", "cls.predictions.decoder")
-    if "mlm" in orig_key:
-        orig_key = orig_key.replace("mlm", "cls.predictions.transform")
-    if "backbone.backbone.encoders" in orig_key:
-        orig_key = orig_key.replace("backbone.backbone.encoders", "encoder.layer")
-    if "cls" not in orig_key:
-        orig_key = "mra." + orig_key
-
-    return orig_key
-
-
-def convert_checkpoint_helper(max_position_embeddings, orig_state_dict):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if ("pooler" in key) or ("sen_class" in key):
-            continue
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    orig_state_dict["cls.predictions.bias"] = orig_state_dict["cls.predictions.decoder.bias"]
-    orig_state_dict["mra.embeddings.position_ids"] = torch.arange(max_position_embeddings).expand((1, -1)) + 2
-
-    return orig_state_dict
-
-
-def convert_mra_checkpoint(checkpoint_path, mra_config_file, pytorch_dump_path):
-    orig_state_dict = torch.load(checkpoint_path, map_location="cpu")["model_state_dict"]
-    config = MraConfig.from_json_file(mra_config_file)
-    model = MraForMaskedLM(config)
-
-    new_state_dict = convert_checkpoint_helper(config.max_position_embeddings, orig_state_dict)
-
-    print(model.load_state_dict(new_state_dict))
-    model.eval()
-    model.save_pretrained(pytorch_dump_path)
-
-    print(f"Checkpoint successfuly converted. Model saved at {pytorch_dump_path}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--pytorch_model_path", default=None, type=str, required=True, help="Path to Mra pytorch checkpoint."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The json file for Mra model config.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_mra_checkpoint(args.pytorch_model_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/musicgen/convert_musicgen_transformers.py b/src/transformers/models/musicgen/convert_musicgen_transformers.py
deleted file mode 100644
index f4afd24df009..000000000000
--- a/src/transformers/models/musicgen/convert_musicgen_transformers.py
+++ /dev/null
@@ -1,236 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MusicGen checkpoints from the original repository."""
-
-import argparse
-from pathlib import Path
-from typing import Dict, OrderedDict, Tuple
-
-import torch
-from audiocraft.models import MusicGen
-
-from transformers import (
-    AutoFeatureExtractor,
-    AutoTokenizer,
-    EncodecModel,
-    MusicgenDecoderConfig,
-    MusicgenForConditionalGeneration,
-    MusicgenProcessor,
-    T5EncoderModel,
-)
-from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-EXPECTED_MISSING_KEYS = ["model.decoder.embed_positions.weights"]
-
-
-def rename_keys(name):
-    if "emb" in name:
-        name = name.replace("emb", "model.decoder.embed_tokens")
-    if "transformer" in name:
-        name = name.replace("transformer", "model.decoder")
-    if "cross_attention" in name:
-        name = name.replace("cross_attention", "encoder_attn")
-    if "linear1" in name:
-        name = name.replace("linear1", "fc1")
-    if "linear2" in name:
-        name = name.replace("linear2", "fc2")
-    if "norm1" in name:
-        name = name.replace("norm1", "self_attn_layer_norm")
-    if "norm_cross" in name:
-        name = name.replace("norm_cross", "encoder_attn_layer_norm")
-    if "norm2" in name:
-        name = name.replace("norm2", "final_layer_norm")
-    if "out_norm" in name:
-        name = name.replace("out_norm", "model.decoder.layer_norm")
-    if "linears" in name:
-        name = name.replace("linears", "lm_heads")
-    if "condition_provider.conditioners.description.output_proj" in name:
-        name = name.replace("condition_provider.conditioners.description.output_proj", "enc_to_dec_proj")
-    return name
-
-
-def rename_state_dict(state_dict: OrderedDict, hidden_size: int) -> Tuple[Dict, Dict]:
-    """Function that takes the fairseq Musicgen state dict and renames it according to the HF
-    module names. It further partitions the state dict into the decoder (LM) state dict, and that for the
-    encoder-decoder projection."""
-    keys = list(state_dict.keys())
-    enc_dec_proj_state_dict = {}
-    for key in keys:
-        val = state_dict.pop(key)
-        key = rename_keys(key)
-        if "in_proj_weight" in key:
-            # split fused qkv proj
-            state_dict[key.replace("in_proj_weight", "q_proj.weight")] = val[:hidden_size, :]
-            state_dict[key.replace("in_proj_weight", "k_proj.weight")] = val[hidden_size : 2 * hidden_size, :]
-            state_dict[key.replace("in_proj_weight", "v_proj.weight")] = val[-hidden_size:, :]
-        elif "enc_to_dec_proj" in key:
-            enc_dec_proj_state_dict[key[len("enc_to_dec_proj.") :]] = val
-        else:
-            state_dict[key] = val
-    return state_dict, enc_dec_proj_state_dict
-
-
-def decoder_config_from_checkpoint(checkpoint: str) -> MusicgenDecoderConfig:
-    if checkpoint.endswith("small"):
-        # default config values
-        hidden_size = 1024
-        num_hidden_layers = 24
-        num_attention_heads = 16
-    elif checkpoint.endswith("medium"):
-        hidden_size = 1536
-        num_hidden_layers = 48
-        num_attention_heads = 24
-    elif checkpoint.endswith("large"):
-        hidden_size = 2048
-        num_hidden_layers = 48
-        num_attention_heads = 32
-    else:
-        raise ValueError(
-            "Checkpoint should be one of `['small', 'medium', 'large']` for the mono checkpoints, "
-            "`['facebook/musicgen-stereo-small', 'facebook/musicgen-stereo-medium', 'facebook/musicgen-stereo-large']` "
-            f"for the stereo checkpoints, or a custom checkpoint with the checkpoint size as a suffix, got {checkpoint}."
-        )
-
-    if "stereo" in checkpoint:
-        audio_channels = 2
-        num_codebooks = 8
-    else:
-        audio_channels = 1
-        num_codebooks = 4
-
-    config = MusicgenDecoderConfig(
-        hidden_size=hidden_size,
-        ffn_dim=hidden_size * 4,
-        num_hidden_layers=num_hidden_layers,
-        num_attention_heads=num_attention_heads,
-        num_codebooks=num_codebooks,
-        audio_channels=audio_channels,
-    )
-    return config
-
-
-@torch.no_grad()
-def convert_musicgen_checkpoint(
-    checkpoint, pytorch_dump_folder=None, repo_id=None, device="cpu", safe_serialization=False
-):
-    fairseq_model = MusicGen.get_pretrained(checkpoint, device=device)
-    decoder_config = decoder_config_from_checkpoint(checkpoint)
-
-    decoder_state_dict = fairseq_model.lm.state_dict()
-    decoder_state_dict, enc_dec_proj_state_dict = rename_state_dict(
-        decoder_state_dict, hidden_size=decoder_config.hidden_size
-    )
-
-    text_encoder = T5EncoderModel.from_pretrained("google-t5/t5-base")
-    audio_encoder = EncodecModel.from_pretrained("facebook/encodec_32khz")
-    decoder = MusicgenForCausalLM(decoder_config).eval()
-
-    # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
-    missing_keys, unexpected_keys = decoder.load_state_dict(decoder_state_dict, strict=False)
-
-    for key in missing_keys.copy():
-        if key.startswith(("text_encoder", "audio_encoder")) or key in EXPECTED_MISSING_KEYS:
-            missing_keys.remove(key)
-
-    if len(missing_keys) > 0:
-        raise ValueError(f"Missing key(s) in state_dict: {missing_keys}")
-
-    if len(unexpected_keys) > 0:
-        raise ValueError(f"Unexpected key(s) in state_dict: {unexpected_keys}")
-
-    # init the composite model
-    model = MusicgenForConditionalGeneration(text_encoder=text_encoder, audio_encoder=audio_encoder, decoder=decoder)
-
-    # load the pre-trained enc-dec projection (from the decoder state dict)
-    model.enc_to_dec_proj.load_state_dict(enc_dec_proj_state_dict)
-
-    # check we can do a forward pass
-    input_ids = torch.arange(0, 2 * decoder_config.num_codebooks, dtype=torch.long).reshape(2, -1)
-    decoder_input_ids = input_ids.reshape(2 * decoder_config.num_codebooks, -1)
-
-    with torch.no_grad():
-        logits = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids).logits
-
-    if logits.shape != (2 * decoder_config.num_codebooks, 1, 2048):
-        raise ValueError("Incorrect shape for logits")
-
-    # now construct the processor
-    tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-base")
-    feature_extractor = AutoFeatureExtractor.from_pretrained(
-        "facebook/encodec_32khz", padding_side="left", feature_size=decoder_config.audio_channels
-    )
-
-    processor = MusicgenProcessor(feature_extractor=feature_extractor, tokenizer=tokenizer)
-
-    # set the appropriate bos/pad token ids
-    model.generation_config.decoder_start_token_id = 2048
-    model.generation_config.pad_token_id = 2048
-
-    # set other default generation config params
-    model.generation_config.max_length = int(30 * audio_encoder.config.frame_rate)
-    model.generation_config.do_sample = True
-    model.generation_config.guidance_scale = 3.0
-
-    if pytorch_dump_folder is not None:
-        Path(pytorch_dump_folder).mkdir(exist_ok=True)
-        logger.info(f"Saving model {checkpoint} to {pytorch_dump_folder}")
-        model.save_pretrained(pytorch_dump_folder, safe_serialization=safe_serialization)
-        processor.save_pretrained(pytorch_dump_folder)
-
-    if repo_id:
-        logger.info(f"Pushing model {checkpoint} to {repo_id}")
-        model.push_to_hub(repo_id, safe_serialization=safe_serialization)
-        processor.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint",
-        default="small",
-        type=str,
-        help="Checkpoint size of the MusicGen model you'd like to convert. Can be one of: "
-        "`['small', 'medium', 'large']` for the mono checkpoints, "
-        "`['facebook/musicgen-stereo-small', 'facebook/musicgen-stereo-medium', 'facebook/musicgen-stereo-large']` "
-        "for the stereo checkpoints, or a custom checkpoint with the checkpoint size as a suffix.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder",
-        required=True,
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-    parser.add_argument(
-        "--device", default="cpu", type=str, help="Torch device to run the conversion, either cpu or cuda."
-    )
-    parser.add_argument(
-        "--safe_serialization",
-        action="store_true",
-        help="Whether to save the model using `safetensors` or the traditional PyTorch way (that uses `pickle`).",
-    )
-
-    args = parser.parse_args()
-    convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
diff --git a/src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py b/src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py
deleted file mode 100644
index 52980f73ecdb..000000000000
--- a/src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py
+++ /dev/null
@@ -1,267 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Musicgen Melody checkpoints from the original repository."""
-
-import argparse
-from pathlib import Path
-from typing import Dict, OrderedDict, Tuple
-
-import torch
-from audiocraft.models import MusicGen
-
-from transformers import (
-    AutoTokenizer,
-    EncodecModel,
-    T5EncoderModel,
-)
-from transformers.models.musicgen_melody.configuration_musicgen_melody import MusicgenMelodyDecoderConfig
-from transformers.models.musicgen_melody.feature_extraction_musicgen_melody import MusicgenMelodyFeatureExtractor
-from transformers.models.musicgen_melody.modeling_musicgen_melody import (
-    MusicgenMelodyForCausalLM,
-    MusicgenMelodyForConditionalGeneration,
-)
-from transformers.models.musicgen_melody.processing_musicgen_melody import MusicgenMelodyProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-EXPECTED_MISSING_KEYS = ["model.decoder.embed_positions.weights"]
-EXPECTED_ADDITIONAL_KEYS = ["condition_provider.conditioners.self_wav.chroma.spec.window"]
-
-
-def rename_keys(name):
-    if "emb" in name:
-        name = name.replace("emb", "model.decoder.embed_tokens")
-    if "transformer" in name:
-        name = name.replace("transformer", "model.decoder")
-    if "cross_attention" in name:
-        name = name.replace("cross_attention", "encoder_attn")
-    if "linear1" in name:
-        name = name.replace("linear1", "fc1")
-    if "linear2" in name:
-        name = name.replace("linear2", "fc2")
-    if "norm1" in name:
-        name = name.replace("norm1", "self_attn_layer_norm")
-    if "norm_cross" in name:
-        name = name.replace("norm_cross", "encoder_attn_layer_norm")
-    if "norm2" in name:
-        name = name.replace("norm2", "final_layer_norm")
-    if "out_norm" in name:
-        name = name.replace("out_norm", "model.decoder.layer_norm")
-    if "linears" in name:
-        name = name.replace("linears", "lm_heads")
-    if "condition_provider.conditioners.description.output_proj" in name:
-        name = name.replace("condition_provider.conditioners.description.output_proj", "enc_to_dec_proj")
-    if "condition_provider.conditioners.self_wav.output_proj" in name:
-        name = name.replace("condition_provider.conditioners.self_wav.output_proj", "audio_enc_to_dec_proj")
-    return name
-
-
-def rename_state_dict(state_dict: OrderedDict, hidden_size: int) -> Tuple[Dict, Dict]:
-    """Function that takes the fairseq MusicgenMelody state dict and renames it according to the HF
-    module names. It further partitions the state dict into the decoder (LM) state dict, and that for the
-    text encoder projection and for the audio encoder projection."""
-    keys = list(state_dict.keys())
-    enc_dec_proj_state_dict = {}
-    audio_enc_to_dec_proj_state_dict = {}
-    for key in keys:
-        val = state_dict.pop(key)
-        key = rename_keys(key)
-        if "in_proj_weight" in key:
-            # split fused qkv proj
-            state_dict[key.replace("in_proj_weight", "q_proj.weight")] = val[:hidden_size, :]
-            state_dict[key.replace("in_proj_weight", "k_proj.weight")] = val[hidden_size : 2 * hidden_size, :]
-            state_dict[key.replace("in_proj_weight", "v_proj.weight")] = val[-hidden_size:, :]
-        elif "audio_enc_to_dec_proj" in key:
-            audio_enc_to_dec_proj_state_dict[key[len("audio_enc_to_dec_proj.") :]] = val
-        elif "enc_to_dec_proj" in key:
-            enc_dec_proj_state_dict[key[len("enc_to_dec_proj.") :]] = val
-        else:
-            state_dict[key] = val
-    return state_dict, enc_dec_proj_state_dict, audio_enc_to_dec_proj_state_dict
-
-
-def decoder_config_from_checkpoint(checkpoint: str) -> MusicgenMelodyDecoderConfig:
-    if checkpoint == "facebook/musicgen-melody" or checkpoint == "facebook/musicgen-stereo-melody":
-        hidden_size = 1536
-        num_hidden_layers = 48
-        num_attention_heads = 24
-    elif checkpoint == "facebook/musicgen-melody-large" or checkpoint == "facebook/musicgen-stereo-melody-large":
-        hidden_size = 2048
-        num_hidden_layers = 48
-        num_attention_heads = 32
-    else:
-        raise ValueError(
-            "Checkpoint should be one of `['facebook/musicgen-melody', 'facebook/musicgen-melody-large']` for the mono checkpoints, "
-            "or `['facebook/musicgen-stereo-melody', 'facebook/musicgen-stereo-melody-large']` "
-            f"for the stereo checkpoints, got {checkpoint}."
-        )
-
-    if "stereo" in checkpoint:
-        audio_channels = 2
-        num_codebooks = 8
-    else:
-        audio_channels = 1
-        num_codebooks = 4
-
-    config = MusicgenMelodyDecoderConfig(
-        hidden_size=hidden_size,
-        ffn_dim=hidden_size * 4,
-        num_hidden_layers=num_hidden_layers,
-        num_attention_heads=num_attention_heads,
-        num_codebooks=num_codebooks,
-        audio_channels=audio_channels,
-    )
-    return config
-
-
-@torch.no_grad()
-def convert_musicgen_melody_checkpoint(
-    checkpoint, pytorch_dump_folder=None, repo_id=None, device="cpu", test_same_output=False
-):
-    fairseq_model = MusicGen.get_pretrained(checkpoint, device=args.device)
-    decoder_config = decoder_config_from_checkpoint(checkpoint)
-
-    decoder_state_dict = fairseq_model.lm.state_dict()
-    decoder_state_dict, enc_dec_proj_state_dict, audio_enc_to_dec_proj_state_dict = rename_state_dict(
-        decoder_state_dict, hidden_size=decoder_config.hidden_size
-    )
-
-    text_encoder = T5EncoderModel.from_pretrained("t5-base")
-    audio_encoder = EncodecModel.from_pretrained("facebook/encodec_32khz")
-    decoder = MusicgenMelodyForCausalLM(decoder_config).eval()
-
-    # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
-    missing_keys, unexpected_keys = decoder.load_state_dict(decoder_state_dict, strict=False)
-
-    for key in missing_keys.copy():
-        if key.startswith(("text_encoder", "audio_encoder")) or key in EXPECTED_MISSING_KEYS:
-            missing_keys.remove(key)
-
-    for key in unexpected_keys.copy():
-        if key in EXPECTED_ADDITIONAL_KEYS:
-            unexpected_keys.remove(key)
-
-    if len(missing_keys) > 0:
-        raise ValueError(f"Missing key(s) in state_dict: {missing_keys}")
-
-    if len(unexpected_keys) > 0:
-        raise ValueError(f"Unexpected key(s) in state_dict: {unexpected_keys}")
-
-    # init the composite model
-    model = MusicgenMelodyForConditionalGeneration(
-        text_encoder=text_encoder, audio_encoder=audio_encoder, decoder=decoder
-    ).to(args.device)
-
-    # load the pre-trained enc-dec projection (from the decoder state dict)
-    model.enc_to_dec_proj.load_state_dict(enc_dec_proj_state_dict)
-
-    # load the pre-trained audio encoder projection (from the decoder state dict)
-    model.audio_enc_to_dec_proj.load_state_dict(audio_enc_to_dec_proj_state_dict)
-
-    # check we can do a forward pass
-    input_ids = torch.arange(0, 2 * decoder_config.num_codebooks, dtype=torch.long).reshape(2, -1).to(device)
-    decoder_input_ids = input_ids.reshape(2 * decoder_config.num_codebooks, -1).to(device)
-
-    with torch.no_grad():
-        logits = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids).logits
-
-    output_length = 1 + input_ids.shape[1] + model.config.chroma_length
-    if logits.shape != (2 * decoder_config.num_codebooks, output_length, 2048):
-        raise ValueError("Incorrect shape for logits")
-
-    # now construct the processor
-    tokenizer = AutoTokenizer.from_pretrained("t5-base")
-    feature_extractor = MusicgenMelodyFeatureExtractor()
-
-    processor = MusicgenMelodyProcessor(feature_extractor=feature_extractor, tokenizer=tokenizer)
-
-    # set the appropriate bos/pad token ids
-    model.generation_config.decoder_start_token_id = 2048
-    model.generation_config.pad_token_id = 2048
-
-    # set other default generation config params
-    model.generation_config.max_length = int(30 * audio_encoder.config.frame_rate)
-    model.generation_config.do_sample = True
-    model.generation_config.guidance_scale = 3.0
-
-    if test_same_output:
-        # check same output than original model
-        decoder_input_ids = torch.ones_like(decoder_input_ids).to(device) * model.generation_config.pad_token_id
-        with torch.no_grad():
-            decoder_input_ids = decoder_input_ids[: decoder_config.num_codebooks]
-            inputs = processor(text=["gen"], return_tensors="pt", padding=True).to(device)
-            logits = model(**inputs, decoder_input_ids=decoder_input_ids).logits
-
-            attributes, prompt_tokens = fairseq_model._prepare_tokens_and_attributes(["gen"], None)
-            original_logits = fairseq_model.lm.forward(
-                decoder_input_ids.reshape(1, decoder_config.num_codebooks, -1), attributes
-            )
-
-            torch.testing.assert_close(
-                original_logits.squeeze(2).reshape(decoder_config.num_codebooks, -1),
-                logits[:, -1],
-                rtol=1e-5,
-                atol=5e-5,
-            )
-
-    if pytorch_dump_folder is not None:
-        Path(pytorch_dump_folder).mkdir(exist_ok=True)
-        logger.info(f"Saving model {checkpoint} to {pytorch_dump_folder}")
-        model.save_pretrained(pytorch_dump_folder)
-        processor.save_pretrained(pytorch_dump_folder)
-
-    if repo_id:
-        logger.info(f"Pushing model {checkpoint} to {repo_id}")
-        model.push_to_hub(repo_id, create_pr=True)
-        processor.push_to_hub(repo_id, create_pr=True)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint",
-        default="facebook/musicgen-melody",
-        type=str,
-        help="Checkpoint size of the Musicgen Melody model you'd like to convert. Can be one of: "
-        "`['facebook/musicgen-melody', 'facebook/musicgen-melody-large']` for the mono checkpoints, or "
-        "`['facebook/musicgen-stereo-melody', 'facebook/musicgen-stereo-melody-large']` "
-        "for the stereo checkpoints.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        default="musicgen-melody",
-        type=str,
-        help="Where to upload the converted model on the 🤗 hub.",
-    )
-    parser.add_argument(
-        "--device", default="cpu", type=str, help="Torch device to run the conversion, either cpu or cuda."
-    )
-    parser.add_argument("--test_same_output", default=False, type=bool, help="If `True`, test if same output logits.")
-
-    args = parser.parse_args()
-    convert_musicgen_melody_checkpoint(
-        args.checkpoint, args.pytorch_dump_folder, args.push_to_hub, args.device, args.test_same_output
-    )
diff --git a/src/transformers/models/myt5/convert_myt5_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/myt5/convert_myt5_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index 39653e4b1c77..000000000000
--- a/src/transformers/models/myt5/convert_myt5_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The MyT5 authors and HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert MyT5 checkpoint."""
-
-import argparse
-
-from transformers import T5Config, T5ForConditionalGeneration, load_tf_weights_in_t5
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-# Copied from transformers.models.t5.convert_t5_original_tf_checkpoint_to_pytorch.convert_tf_checkpoint_to_pytorch
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = T5Config.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = T5ForConditionalGeneration(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_t5(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained MyT5 model. \nThis specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/nemotron/convert_nemotron_nemo_to_hf.py b/src/transformers/models/nemotron/convert_nemotron_nemo_to_hf.py
deleted file mode 100644
index 07a5c51a3c4b..000000000000
--- a/src/transformers/models/nemotron/convert_nemotron_nemo_to_hf.py
+++ /dev/null
@@ -1,346 +0,0 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import json
-import os
-import shutil
-from argparse import ArgumentParser
-from collections import OrderedDict
-
-import torch
-from nemo.collections.common.tokenizers.huggingface.auto_tokenizer import AutoTokenizer
-from nemo.collections.nlp.models.language_modeling.megatron_gpt_model import MegatronGPTModel
-from nemo.collections.nlp.parts.nlp_overrides import NLPDDPStrategy
-from nemo.utils import logging
-from pytorch_lightning import Trainer
-
-from transformers import LlamaTokenizer, PreTrainedTokenizerFast
-from transformers.convert_slow_tokenizer import LlamaConverter
-
-
-"""
-Script to convert a nemotron checkpoint in nemo (mcore path) into a HuggingFace checkpoint.
-This script can be used to 1) generate only the HF weights, or 2) generate an entire HF model folder.
-
-1) Generate only HF weights from a nemo file:
-
-    python convert_nemotron_nemo_to_hf.py \
-    --input_name_or_path /path/to/file.nemo or /path/to/extracted_folder \
-    --output_path /path/to/pytorch_model.bin
-
-2) Generate the full HF model folder
-
-    python convert_nemotron_nemo_to_hf.py \
-    --input_name_or_path /path/to/file.nemo or /path/to/extracted_folder \
-    --hf_input_path /path/to/input_hf_folder \
-    --hf_output_path /path/to/output_hf_folder \
-
-    Use the --cpu-only flag if the model cannot fit in the GPU (e.g. Nemotron4 340b).
-    However this option makes the conversion script significantly slower.
-"""
-
-
-def get_args():
-    parser = ArgumentParser()
-    parser.add_argument(
-        "--input_name_or_path",
-        type=str,
-        default=None,
-        required=True,
-        help="Path to .nemo file or extracted folder",
-    )
-    parser.add_argument("--output_path", type=str, default=None, required=False, help="Path to HF .bin file")
-    parser.add_argument(
-        "--hf_input_path",
-        type=str,
-        default=None,
-        help="A HF model path, e.g. a folder containing https://huggingface.co/nvidia/Minitron-8B-Base",
-    )
-    parser.add_argument(
-        "--hf_output_path",
-        type=str,
-        default=None,
-        help="Output HF model path, with the same format as above but user's own weights",
-    )
-    parser.add_argument(
-        "--precision",
-        type=str,
-        default=None,
-        help="Precision of output weights."
-        "Defaults to precision of the input nemo weights (model.cfg.trainer.precision)",
-    )
-    parser.add_argument(
-        "--cpu-only",
-        action="store_true",
-        help="Load model in cpu only. Useful if the model cannot fit in GPU memory, "
-        "but this option makes the conversion script significantly slower.",
-    )
-    args = parser.parse_args()
-    return args
-
-
-def convert_hf_config(nemo_config, tokenizer, vocab_size, dtype, hf_output_path, hf_url="nvidia/Minitron-8B-Base"):
-    """
-    Convert NeMo config to HF config
-    """
-    NEMO_ACT2HF = {
-        "squared-relu": "relu2",
-        "fast-swiglu": "silu",
-    }
-    DTYPE2HF = {
-        torch.bfloat16: "bfloat16",
-        torch.float16: "float16",
-        torch.float32: "float32",
-    }
-    hf_config = {
-        "_name_or_path": hf_url,
-        "architectures": ["NemotronForCausalLM"],
-        "bos_token_id": tokenizer.bos_id,
-        "eos_token_id": tokenizer.eos_id,
-        "hidden_act": NEMO_ACT2HF[nemo_config.activation],
-        "hidden_size": nemo_config.hidden_size,
-        "initializer_range": nemo_config.init_method_std,
-        "intermediate_size": nemo_config.ffn_hidden_size,
-        "max_position_embeddings": nemo_config.max_position_embeddings,
-        "model_type": "nemotron",
-        "num_attention_heads": nemo_config.num_attention_heads,
-        "num_hidden_layers": nemo_config.num_layers,
-        "num_key_value_heads": nemo_config.get("num_query_groups", nemo_config.num_attention_heads),
-        "norm_eps": nemo_config.layernorm_epsilon,
-        "rope_theta": nemo_config.get("rotary_base", 10000),
-        "partial_rotary_factor": nemo_config.get("rotary_percentage", 1.0),
-        "tie_word_embeddings": False,
-        "torch_dtype": DTYPE2HF[dtype],
-        "transformers_version": "4.32.0.dev0",  # TODO
-        "use_cache": True,
-        "vocab_size": vocab_size,
-    }
-    if nemo_config.kv_channels is not None:
-        hf_config["kv_channels"] = nemo_config.kv_channels
-    json.dump(hf_config, open(f"{hf_output_path}/config.json", "w"), indent=2)
-
-
-def convert(input_nemo_file, output_hf_file, precision=None, cpu_only=False) -> None:
-    """
-    Convert NeMo weights to HF weights
-    """
-    dummy_trainer = Trainer(devices=1, accelerator="cpu", strategy=NLPDDPStrategy())
-    model_config = MegatronGPTModel.restore_from(input_nemo_file, trainer=dummy_trainer, return_config=True)
-    model_config.tensor_model_parallel_size = 1
-    model_config.pipeline_model_parallel_size = 1
-    model_config.sequence_parallel = False
-    model_config.transformer_engine = True
-    if cpu_only:
-        map_location = torch.device("cpu")
-        model_config.use_cpu_initialization = True
-        model_config.dist_ckpt_load_on_device = False
-    else:
-        map_location = None
-
-    if cpu_only:
-        logging.info("******** Loading model on CPU. This will take a significant amount of time.")
-
-    model = MegatronGPTModel.restore_from(
-        input_nemo_file, trainer=dummy_trainer, override_config_path=model_config, map_location=map_location
-    )
-
-    vocab_size = model.padded_vocab_size
-
-    if precision is None:
-        precision = model.cfg.precision
-    if precision in [32, "32"]:
-        dtype = torch.float32
-    elif precision in [16, "16", "16-mixed"]:
-        dtype = torch.float16
-    elif precision in ["bf16", "bf16-mixed"]:
-        dtype = torch.bfloat16
-    else:
-        logging.warning(f"Precision string {precision} is not recognized, falling back to fp32")
-        dtype = torch.float32  # fallback
-    logging.info(f"Using precision {dtype}")
-
-    def param_to_weights(param):
-        return param.to(dtype)
-
-    checkpoint = OrderedDict()
-
-    hidden_size = model.cfg.hidden_size
-    head_num = model.cfg.num_attention_heads
-    num_layers = model.cfg.num_layers
-    ffn_hidden_size = model.cfg.ffn_hidden_size
-    num_query_groups = model.cfg.get("num_query_groups", head_num)  # different num_query_groups for 70B
-    if num_query_groups is None:
-        num_query_groups = head_num
-    heads_per_group = head_num // num_query_groups
-    qkv_total_dim = head_num + 2 * num_query_groups
-
-    # Embedding
-    embed_weight = model.state_dict()["model.embedding.word_embeddings.weight"]
-    embed_weights_base_name = "model.embed_tokens.weight"
-    checkpoint[embed_weights_base_name] = param_to_weights(embed_weight)
-
-    for l in range(int(num_layers)):
-        print(f"converting layer {l}")
-
-        qkv_weights = model.state_dict()[f"model.decoder.layers.{l}.self_attention.linear_qkv.weight"]
-        qkv_weights = qkv_weights.reshape([qkv_total_dim, -1, hidden_size])
-
-        q_slice = torch.cat(
-            [
-                torch.arange((heads_per_group + 2) * i, (heads_per_group + 2) * i + heads_per_group)
-                for i in range(num_query_groups)
-            ]
-        )
-        k_slice = torch.arange(heads_per_group, qkv_total_dim, (heads_per_group + 2))
-        v_slice = torch.arange(heads_per_group + 1, qkv_total_dim, (heads_per_group + 2))
-        ## Example of slices
-        ## (without GQA): num_query_groups = head_num = 32,
-        ## q_slice = [0, 3, 6, 9 , ... 90, 93]
-        ## k_slice = [1, 4, 7, 10, ... 91, 94]
-        ## v_slice = [2, 5, 8, 11, ... 92, 95]
-        ## (with GQA): num_query_groups = 8, head_num = 64
-        ## q_slice = [0, 1, .. 6, 7, 10, 11, .. 16, 17, 20, 21, .. 67, 70, ... 76, 77]
-        ## k_slice = [8, 18, 28, ... 68, 78]
-        ## v_slice = [9, 19, 29, ... 69, 79]
-
-        q_weights_base_name = f"model.layers.{l}.self_attn.q_proj.weight"
-        k_weights_base_name = f"model.layers.{l}.self_attn.k_proj.weight"
-        v_weights_base_name = f"model.layers.{l}.self_attn.v_proj.weight"
-
-        checkpoint[q_weights_base_name] = param_to_weights(qkv_weights[q_slice].reshape(-1, hidden_size))
-        checkpoint[k_weights_base_name] = param_to_weights(qkv_weights[k_slice].reshape(-1, hidden_size))
-        checkpoint[v_weights_base_name] = param_to_weights(qkv_weights[v_slice].reshape(-1, hidden_size))
-
-        # attention dense
-        o_weight = model.state_dict()[f"model.decoder.layers.{l}.self_attention.linear_proj.weight"]
-        o_weight_base_name = f"model.layers.{l}.self_attn.o_proj.weight"
-        checkpoint[o_weight_base_name] = param_to_weights(o_weight)
-
-        # mlp
-        mlp_weights = model.state_dict()[f"model.decoder.layers.{l}.mlp.linear_fc1.weight"]
-        mlp_up_proj_weight = model.state_dict()[f"model.decoder.layers.{l}.mlp.linear_fc2.weight"]
-
-        if mlp_weights.shape[0] != mlp_up_proj_weight.shape[1]:
-            # Has projection (used for swi-glu)
-            logging.warning(
-                "Gated projection layers detected in NeMo checkpoint. Currently Nemotron HF does not support gated MLP."
-            )
-            assert mlp_weights.shape[0] == 2 * mlp_up_proj_weight.shape[1]
-
-            mlp_down_proj_weight = mlp_weights[:ffn_hidden_size, :]
-            mlp_gate_proj_weight = mlp_weights[ffn_hidden_size:, :]
-
-            mlp_down_proj_base_name = f"model.layers.{l}.mlp.gate_proj.weight"
-            mlp_gate_proj_base_name = f"model.layers.{l}.mlp.up_proj.weight"
-
-            checkpoint[mlp_down_proj_base_name] = param_to_weights(mlp_down_proj_weight)
-            checkpoint[mlp_gate_proj_base_name] = param_to_weights(mlp_gate_proj_weight)
-        else:
-            mlp_down_proj_weight = mlp_weights
-            mlp_down_proj_base_name = f"model.layers.{l}.mlp.up_proj.weight"
-            checkpoint[mlp_down_proj_base_name] = param_to_weights(mlp_down_proj_weight)
-
-        mlp_up_proj_base_name = f"model.layers.{l}.mlp.down_proj.weight"
-        checkpoint[mlp_up_proj_base_name] = param_to_weights(mlp_up_proj_weight)
-
-        # layernorm
-        input_ln_weight = model.state_dict()[f"model.decoder.layers.{l}.self_attention.linear_qkv.layer_norm_weight"]
-        input_ln_base_name = f"model.layers.{l}.input_layernorm.weight"
-        checkpoint[input_ln_base_name] = param_to_weights(input_ln_weight)
-        if (
-            model.state_dict().get(f"model.decoder.layers.{l}.self_attention.linear_qkv.layer_norm_bias", None)
-            is not None
-        ):
-            input_ln_bias = model.state_dict()[f"model.decoder.layers.{l}.self_attention.linear_qkv.layer_norm_bias"]
-            input_ln_bias_name = f"model.layers.{l}.input_layernorm.bias"
-            checkpoint[input_ln_bias_name] = param_to_weights(input_ln_bias)
-
-        post_attn_ln_weight = model.state_dict()[f"model.decoder.layers.{l}.mlp.linear_fc1.layer_norm_weight"]
-        post_attn_ln_base_name = f"model.layers.{l}.post_attention_layernorm.weight"
-        checkpoint[post_attn_ln_base_name] = param_to_weights(post_attn_ln_weight)
-        if model.state_dict().get(f"model.decoder.layers.{l}.mlp.linear_fc1.layer_norm_bias", None) is not None:
-            post_attn_ln_bias = model.state_dict()[f"model.decoder.layers.{l}.mlp.linear_fc1.layer_norm_bias"]
-            post_attn_ln_bias_name = f"model.layers.{l}.post_attention_layernorm.bias"
-            checkpoint[post_attn_ln_bias_name] = param_to_weights(post_attn_ln_bias)
-
-        print(f"done layer {l}")
-
-    final_ln_weight = model.state_dict()["model.decoder.final_layernorm.weight"]
-    final_ln_base_name = "model.norm.weight"
-    checkpoint[final_ln_base_name] = param_to_weights(final_ln_weight)
-    if model.state_dict().get("model.decoder.final_layernorm.bias", None) is not None:
-        final_ln_bias = model.state_dict()["model.decoder.final_layernorm.bias"]
-        final_ln_bias_name = "model.norm.bias"
-        checkpoint[final_ln_bias_name] = param_to_weights(final_ln_bias)
-
-    output_layer_weight = model.state_dict()["model.output_layer.weight"]
-    output_layer_base_name = "lm_head.weight"
-    checkpoint[output_layer_base_name] = param_to_weights(output_layer_weight)
-
-    os.makedirs(os.path.dirname(output_hf_file), exist_ok=True)
-    torch.save(checkpoint, output_hf_file)
-    logging.info(f"Weights saved to {output_hf_file}")
-
-    return model_config, model.tokenizer, dtype, vocab_size
-
-
-def extract_nemotron_tokenizer(nemo_file, model_config, output_hf_path, nemo_tokenizer):
-    tokenizer_cfg = model_config.tokenizer
-    if tokenizer_cfg.library == "sentencepiece":
-        # For sentencepiece tokenizer, we are wrapping with HF's LlamaTokenizer
-        # and convert it to a PreTrainedTokenizerFast
-        tokenizer_fn = tokenizer_cfg.model[5:]
-        output_tokenizer = f"{output_hf_path}/tokenizer.model"
-        if nemo_file.endswith(".nemo"):
-            import tarfile
-
-            archive = tarfile.open(nemo_file, "r")
-            tokenizer_filename = "./" + tokenizer_fn  # exclude 'nemo:' prefix
-            archive.extract(tokenizer_filename, output_hf_path)
-            archive.close()
-            os.rename(f"{output_hf_path}/{tokenizer_fn}", output_tokenizer)
-        elif os.path.isdir(nemo_file):
-            shutil.copy(f"{nemo_file}/{tokenizer_fn}", output_tokenizer)
-        # We use LlamaTokenizer for sentencepiece based tokenizer
-        tokenizer = LlamaTokenizer.from_pretrained(output_hf_path, legacy=False)
-        # Convert the LlamaTokenizer to a PreTrainedTokenizerFast instance
-        tokenizer = PreTrainedTokenizerFast(
-            tokenizer_object=LlamaConverter(tokenizer).converted(), model_input_names=["input_ids", "token_type_ids"]
-        )
-        tokenizer.save_pretrained(output_hf_path)
-        logging.info(f"Setencepiece tokenizer has been saved to {output_tokenizer}")
-    elif isinstance(nemo_tokenizer, AutoTokenizer):
-        nemo_tokenizer.tokenizer.save_pretrained(output_hf_path)
-        logging.info(f"HF AutoTokenizer has been saved to {output_hf_path}")
-    else:
-        raise ValueError(f"Unsupported tokenizer type: library: {tokenizer_cfg.library}, type: {tokenizer_cfg.type}")
-
-
-if __name__ == "__main__":
-    args = get_args()
-    if not args.hf_output_path:
-        assert args.output_path is not None, "Need to provide either output_path or hf_output_path"
-    else:
-        args.output_path = f"{args.hf_output_path}/pytorch_model.bin"
-        logging.info(f"weight will be saved to {args.output_path}")
-
-    nemo_config, nemo_tokenizer, dtype, vocab_size = convert(
-        args.input_name_or_path, args.output_path, precision=args.precision, cpu_only=args.cpu_only
-    )
-    if args.hf_input_path and args.hf_output_path:
-        convert_hf_config(nemo_config, nemo_tokenizer, vocab_size, dtype, args.hf_output_path, args.hf_input_path)
-        extract_nemotron_tokenizer(args.input_name_or_path, nemo_config, args.hf_output_path, nemo_tokenizer)
-    else:
-        logging.info("`hf_input_path` and/or `hf_output_path` not provided, not generating full HF model.")
-        logging.info(f".bin file is saved to {args.output_path}")
diff --git a/src/transformers/models/nllb_moe/convert_nllb_moe_sharded_original_checkpoint_to_pytorch.py b/src/transformers/models/nllb_moe/convert_nllb_moe_sharded_original_checkpoint_to_pytorch.py
deleted file mode 100644
index a84138a62461..000000000000
--- a/src/transformers/models/nllb_moe/convert_nllb_moe_sharded_original_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,161 +0,0 @@
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import json
-import os
-
-import torch
-from torch import nn
-
-from transformers import NllbMoeConfig, NllbMoeModel
-from transformers.utils import WEIGHTS_INDEX_NAME, WEIGHTS_NAME
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = [
-        "encoder.version",
-        "decoder.version",
-        "model.encoder.version",
-        "model.decoder.version",
-        "decoder.output_projection.weight",
-        "_float_tensor",
-        "encoder.embed_positions._float_tensor",
-        "decoder.embed_positions._float_tensor",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-def rename_fairseq_keys(state_dict, expert_idx=None):
-    new_dict = {}
-    for old_key in state_dict.keys():
-        key = old_key
-        if "moe_layer.experts." in key:
-            if expert_idx is not None:
-                key = key.replace("moe_layer.experts.0", f"ffn.experts.expert_{expert_idx}")
-            else:
-                key = key.replace("moe_layer.experts.", "ffn.experts.expert_")
-        if "gate" in key:
-            key = key.replace(".moe_layer.gate.wg", ".ffn.router.classifier")
-        if "fc2" and "experts" not in key:
-            key = key.replace(".fc2.", ".ffn.fc2.")
-        if "fc1" and "experts" not in key:
-            key = key.replace(".fc1.", ".ffn.fc1.")
-        if ".encoder_attn." in key:
-            key = key.replace(".encoder_attn.", ".cross_attention.")
-        if "encoder_attn_layer_norm" in key:
-            key = key.replace("encoder_attn_layer_norm", "cross_attention_layer_norm")
-        if "final_layer_norm" in key:
-            key = key.replace("final_layer_norm", "ff_layer_norm")
-        new_dict[key] = state_dict[old_key]
-    return new_dict
-
-
-def shard_on_the_fly(switch_checkpoint_path, dump_path, num_experts, dtype, weights_name: str = WEIGHTS_NAME):
-    sharded_state_dicts = []
-    total_size = 0
-    os.makedirs(dump_path, exist_ok=True)
-
-    for expert in range(num_experts):
-        expert_path = switch_checkpoint_path + f"-rank-{expert}.pt"
-        if os.path.isfile(expert_path):
-            expert_state = torch.load(expert_path)["model"]
-            remove_ignore_keys_(expert_state)
-            expert_state = rename_fairseq_keys(expert_state, expert)
-            save_path = os.path.join(
-                dump_path, weights_name.replace(".bin", f"-{len(sharded_state_dicts) + 1:05d}-of-???.bin")
-            )
-            torch.save(expert_state, save_path)
-            sharded_state_dicts.append(expert_state.keys())
-            total_size += sum([value.numel() for key, value in expert_state.items()]) * (
-                expert_state[list(expert_state)[0]].element_size()
-            )
-
-    # Add the last block
-    save_path = os.path.join(
-        dump_path, weights_name.replace(".bin", f"-{len(sharded_state_dicts) + 1:05d}-of-???.bin")
-    )
-    shared_weights = torch.load(switch_checkpoint_path + "-shared.pt")["model"]
-    remove_ignore_keys_(shared_weights)
-    shared_weights = rename_fairseq_keys(shared_weights, None)
-    shared_weights["shared.weight"] = shared_weights["decoder.embed_tokens.weight"]
-    sharded_state_dicts.append(shared_weights.keys())
-
-    # If we only have the shared weights (dummy model/experts saved on the same file)
-    if len(sharded_state_dicts) == 1:
-        save_path = os.path.join(dump_path, weights_name)
-        torch.save(shared_weights, save_path)
-        return {weights_name: sharded_state_dicts[0]}, None
-    else:
-        torch.save(shared_weights, save_path)
-    # Otherwise, let's build the index
-    weight_map = {}
-    for idx, shard in enumerate(sharded_state_dicts):
-        shard_file = weights_name.replace(".bin", f"-{idx + 1:05d}-of-{len(sharded_state_dicts):05d}.bin")
-        temp_filename = os.path.join(dump_path, weights_name.replace(".bin", f"-{idx + 1:05d}-of-???.bin"))
-        os.rename(temp_filename, os.path.join(dump_path, shard_file))
-        for key in shard:
-            weight_map[key] = shard_file
-
-    # Add the metadata
-    metadata = {"total_size": total_size}
-    index = {"metadata": metadata, "weight_map": weight_map}
-
-    with open(os.path.join(dump_path, WEIGHTS_INDEX_NAME), "w", encoding="utf-8") as f:
-        content = json.dumps(index, indent=2, sort_keys=True) + "\n"
-        f.write(content)
-
-    return metadata, index
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--nllb_moe_checkpoint_path",
-        default="/home/arthur_huggingface_co/fairseq/weights/checkpoints/model_moe_54b/checkpoint_2_300000",
-        type=str,
-        required=False,
-        help="Path to a directory containing a folder per layer. Follows the original Google format.",
-    )
-    parser.add_argument("--dtype", default="float32", type=str, required=False, help="dtype of the saved model")
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="/home/arthur_huggingface_co/fairseq/weights/checkpoints/hf-converted-moe-54b",
-        type=str,
-        required=False,
-        help="Path to the output pytorch model.",
-    )
-    args = parser.parse_args()
-    metadata, index = shard_on_the_fly(
-        args.nllb_moe_checkpoint_path,
-        args.pytorch_dump_folder_path,
-        128,
-        args.dtype,
-    )
-
-    config = NllbMoeConfig.from_pretrained(
-        "facebook/nllb-200-3.3B", encoder_sparse_step=4, decoder_sparse_step=4, num_experts=128
-    )
-    config.save_pretrained(args.pytorch_dump_folder_path)
-    model = NllbMoeModel.from_pretrained(args.pytorch_dump_folder_path)
-    print("Done")
-    model.save_pretrained(args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/nougat/convert_nougat_to_hf.py b/src/transformers/models/nougat/convert_nougat_to_hf.py
deleted file mode 100644
index e42f8553ac4f..000000000000
--- a/src/transformers/models/nougat/convert_nougat_to_hf.py
+++ /dev/null
@@ -1,282 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Nougat checkpoints using the original `nougat` library. URL:
-https://github.com/facebookresearch/nougat/tree/main"""
-
-import argparse
-
-import torch
-from huggingface_hub import hf_hub_download
-from nougat import NougatModel
-from nougat.dataset.rasterize import rasterize_paper
-from nougat.utils.checkpoint import get_checkpoint
-from PIL import Image
-
-from transformers import (
-    DonutSwinConfig,
-    DonutSwinModel,
-    MBartConfig,
-    MBartForCausalLM,
-    NougatImageProcessor,
-    NougatProcessor,
-    NougatTokenizerFast,
-    VisionEncoderDecoderModel,
-)
-
-
-def get_configs(model):
-    original_config = model.config
-
-    encoder_config = DonutSwinConfig(
-        image_size=original_config.input_size,
-        patch_size=4,
-        depths=original_config.encoder_layer,
-        num_heads=[4, 8, 16, 32],
-        window_size=original_config.window_size,
-        embed_dim=128,
-    )
-    decoder_config = MBartConfig(
-        is_decoder=True,
-        is_encoder_decoder=False,
-        add_cross_attention=True,
-        decoder_layers=original_config.decoder_layer,
-        max_position_embeddings=original_config.max_position_embeddings,
-        vocab_size=len(
-            model.decoder.tokenizer
-        ),  # several special tokens are added to the vocab of XLMRobertaTokenizer, see repo on the hub (added_tokens.json)
-        scale_embedding=True,
-        add_final_layer_norm=True,
-        tie_word_embeddings=False,
-    )
-
-    return encoder_config, decoder_config
-
-
-# Copied from transformers.models.donut.convert_donut_to_pytorch.rename_key
-def rename_key(name):
-    if "encoder.model" in name:
-        name = name.replace("encoder.model", "encoder")
-    if "decoder.model" in name:
-        name = name.replace("decoder.model", "decoder")
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "embeddings.norm")
-    if name.startswith("encoder"):
-        if "layers" in name:
-            name = "encoder." + name
-        if "attn.proj" in name:
-            name = name.replace("attn.proj", "attention.output.dense")
-        if "attn" in name and "mask" not in name:
-            name = name.replace("attn", "attention.self")
-        if "norm1" in name:
-            name = name.replace("norm1", "layernorm_before")
-        if "norm2" in name:
-            name = name.replace("norm2", "layernorm_after")
-        if "mlp.fc1" in name:
-            name = name.replace("mlp.fc1", "intermediate.dense")
-        if "mlp.fc2" in name:
-            name = name.replace("mlp.fc2", "output.dense")
-
-        if name == "encoder.norm.weight":
-            name = "encoder.layernorm.weight"
-        if name == "encoder.norm.bias":
-            name = "encoder.layernorm.bias"
-
-    return name
-
-
-# Copied from transformers.models.donut.convert_donut_to_pytorch.convert_state_dict
-def convert_state_dict(orig_state_dict, model):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[3])
-            block_num = int(key_split[5])
-            dim = model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size
-
-            if "weight" in key:
-                orig_state_dict[
-                    f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.weight"
-                ] = val[:dim, :]
-                orig_state_dict[f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.weight"] = (
-                    val[dim : dim * 2, :]
-                )
-                orig_state_dict[
-                    f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.weight"
-                ] = val[-dim:, :]
-            else:
-                orig_state_dict[f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.bias"] = (
-                    val[:dim]
-                )
-                orig_state_dict[f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.bias"] = (
-                    val[dim : dim * 2]
-                )
-                orig_state_dict[f"encoder.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.bias"] = (
-                    val[-dim:]
-                )
-        elif "attn_mask" in key or key in ["encoder.model.norm.weight", "encoder.model.norm.bias"]:
-            # HuggingFace implementation doesn't use attn_mask buffer
-            # and model doesn't use final LayerNorms for the encoder
-            pass
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-def convert_nougat_checkpoint(model_tag, pytorch_dump_folder_path=None, push_to_hub=False):
-    # load original model
-    checkpoint_path = get_checkpoint(None, model_tag)
-    original_model = NougatModel.from_pretrained(checkpoint_path)
-    original_model.eval()
-
-    # load HuggingFace model
-    encoder_config, decoder_config = get_configs(original_model)
-    encoder = DonutSwinModel(encoder_config)
-    decoder = MBartForCausalLM(decoder_config)
-    model = VisionEncoderDecoderModel(encoder=encoder, decoder=decoder)
-    model.eval()
-
-    state_dict = original_model.state_dict()
-    new_state_dict = convert_state_dict(state_dict, model)
-    model.load_state_dict(new_state_dict)
-
-    # verify results on PDF
-    filepath = hf_hub_download(repo_id="ysharma/nougat", filename="input/nougat.pdf", repo_type="space")
-    images = rasterize_paper(pdf=filepath, return_pil=True)
-    image = Image.open(images[0])
-
-    tokenizer_file = checkpoint_path / "tokenizer.json"
-    tokenizer = NougatTokenizerFast(tokenizer_file=str(tokenizer_file))
-    tokenizer.pad_token = "<pad>"
-    tokenizer.bos_token = "<s>"
-    tokenizer.eos_token = "</s>"
-    tokenizer.unk_token = "<unk>"
-    tokenizer.model_max_length = original_model.config.max_length
-
-    size = {"height": original_model.config.input_size[0], "width": original_model.config.input_size[1]}
-    image_processor = NougatImageProcessor(
-        do_align_long_axis=original_model.config.align_long_axis,
-        size=size,
-    )
-    processor = NougatProcessor(image_processor=image_processor, tokenizer=tokenizer)
-
-    # verify pixel_values
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-    original_pixel_values = original_model.encoder.prepare_input(image).unsqueeze(0)
-
-    assert torch.allclose(original_pixel_values, pixel_values)
-
-    # verify patch embeddings
-    original_patch_embed = original_model.encoder.model.patch_embed(pixel_values)
-    patch_embeddings, _ = model.encoder.embeddings(pixel_values)
-    assert torch.allclose(original_patch_embed, patch_embeddings)
-
-    # verify encoder hidden states
-    original_last_hidden_state = original_model.encoder(pixel_values)
-    last_hidden_state = model.encoder(pixel_values).last_hidden_state
-    assert torch.allclose(original_last_hidden_state, last_hidden_state, atol=1e-2)
-
-    # NOTE original model does not use tied weights for embeddings of decoder
-    original_embeddings = original_model.decoder.model.model.decoder.embed_tokens
-    embeddings = model.decoder.model.decoder.embed_tokens
-    assert torch.allclose(original_embeddings.weight, embeddings.weight, atol=1e-3)
-
-    # verify decoder hidden states
-    prompt = "hello world"
-    decoder_input_ids = original_model.decoder.tokenizer(
-        prompt, add_special_tokens=False, return_tensors="pt"
-    ).input_ids
-    decoder_attention_mask = torch.ones_like(decoder_input_ids)
-    original_logits = original_model(
-        image_tensors=pixel_values, decoder_input_ids=decoder_input_ids, attention_mask=decoder_attention_mask
-    ).logits
-    logits = model(
-        pixel_values,
-        decoder_input_ids=decoder_input_ids[:, :-1],
-        decoder_attention_mask=decoder_attention_mask[:, :-1],
-    ).logits
-    assert torch.allclose(original_logits, logits, atol=1e-3)
-
-    # verify generation
-    outputs = model.generate(
-        pixel_values,
-        min_length=1,
-        max_length=30,
-        pad_token_id=tokenizer.pad_token_id,
-        eos_token_id=tokenizer.eos_token_id,
-        use_cache=True,
-        bad_words_ids=[
-            [tokenizer.unk_token_id],
-        ],
-        return_dict_in_generate=True,
-        do_sample=False,
-    )
-    generated = tokenizer.batch_decode(outputs.sequences, skip_special_tokens=True)[0]
-
-    if model_tag == "0.1.0-base":
-        expected_generation = "# Nougat: Neural Optical Understanding for Academic Documents\n\nLukas Blecher\n\nCorrespondence to: lblec"
-    elif model_tag == "0.1.0-small":
-        expected_generation = (
-            "# Nougat: Neural Optical Understanding for Academic Documents\n\nLukas Blecher\n\nCorrespondence to: lble"
-        )
-    else:
-        raise ValueError(f"Unexpected model tag: {model_tag}")
-
-    assert generated == expected_generation
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        tag_to_name = {"0.1.0-base": "nougat-base", "0.1.0-small": "nougat-small"}
-        model_name = tag_to_name[model_tag]
-
-        model.push_to_hub(f"facebook/{model_name}")
-        processor.push_to_hub(f"facebook/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_tag",
-        default="0.1.0-base",
-        required=False,
-        type=str,
-        choices=["0.1.0-base", "0.1.0-small"],
-        help="Tag of the original model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        required=False,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether or not to push the converted model and processor to the 🤗 hub.",
-    )
-
-    args = parser.parse_args()
-    convert_nougat_checkpoint(args.model_tag, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/nystromformer/convert_nystromformer_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/nystromformer/convert_nystromformer_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 8d5a52bdbf82..000000000000
--- a/src/transformers/models/nystromformer/convert_nystromformer_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,111 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert Nystromformer checkpoints from the original repository."""
-
-import argparse
-
-import torch
-
-from transformers import NystromformerConfig, NystromformerForMaskedLM
-
-
-def rename_key(orig_key):
-    if "model" in orig_key:
-        orig_key = orig_key.replace("model.", "")
-    if "norm1" in orig_key:
-        orig_key = orig_key.replace("norm1", "attention.output.LayerNorm")
-    if "norm2" in orig_key:
-        orig_key = orig_key.replace("norm2", "output.LayerNorm")
-    if "norm" in orig_key:
-        orig_key = orig_key.replace("norm", "LayerNorm")
-    if "transformer" in orig_key:
-        layer_num = orig_key.split(".")[0].split("_")[-1]
-        orig_key = orig_key.replace(f"transformer_{layer_num}", f"encoder.layer.{layer_num}")
-    if "mha.attn" in orig_key:
-        orig_key = orig_key.replace("mha.attn", "attention.self")
-    if "mha" in orig_key:
-        orig_key = orig_key.replace("mha", "attention")
-    if "W_q" in orig_key:
-        orig_key = orig_key.replace("W_q", "self.query")
-    if "W_k" in orig_key:
-        orig_key = orig_key.replace("W_k", "self.key")
-    if "W_v" in orig_key:
-        orig_key = orig_key.replace("W_v", "self.value")
-    if "ff1" in orig_key:
-        orig_key = orig_key.replace("ff1", "intermediate.dense")
-    if "ff2" in orig_key:
-        orig_key = orig_key.replace("ff2", "output.dense")
-    if "ff" in orig_key:
-        orig_key = orig_key.replace("ff", "output.dense")
-    if "mlm_class" in orig_key:
-        orig_key = orig_key.replace("mlm.mlm_class", "cls.predictions.decoder")
-    if "mlm" in orig_key:
-        orig_key = orig_key.replace("mlm", "cls.predictions.transform")
-    if "cls" not in orig_key:
-        orig_key = "nystromformer." + orig_key
-
-    return orig_key
-
-
-def convert_checkpoint_helper(config, orig_state_dict):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if ("pooler" in key) or ("sen_class" in key) or ("conv.bias" in key):
-            continue
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    orig_state_dict["cls.predictions.bias"] = orig_state_dict["cls.predictions.decoder.bias"]
-    orig_state_dict["nystromformer.embeddings.position_ids"] = (
-        torch.arange(config.max_position_embeddings).expand((1, -1)) + 2
-    )
-
-    return orig_state_dict
-
-
-def convert_nystromformer_checkpoint(checkpoint_path, nystromformer_config_file, pytorch_dump_path):
-    orig_state_dict = torch.load(checkpoint_path, map_location="cpu")["model_state_dict"]
-    config = NystromformerConfig.from_json_file(nystromformer_config_file)
-    model = NystromformerForMaskedLM(config)
-
-    new_state_dict = convert_checkpoint_helper(config, orig_state_dict)
-
-    model.load_state_dict(new_state_dict)
-    model.eval()
-    model.save_pretrained(pytorch_dump_path)
-
-    print(f"Checkpoint successfuly converted. Model saved at {pytorch_dump_path}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--pytorch_model_path", default=None, type=str, required=True, help="Path to Nystromformer pytorch checkpoint."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The json file for Nystromformer model config.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_nystromformer_checkpoint(args.pytorch_model_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/olmo/convert_olmo_weights_to_hf.py b/src/transformers/models/olmo/convert_olmo_weights_to_hf.py
deleted file mode 100644
index 0e77bdc69e7a..000000000000
--- a/src/transformers/models/olmo/convert_olmo_weights_to_hf.py
+++ /dev/null
@@ -1,248 +0,0 @@
-# Copyright 2024 EleutherAI and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import gc
-import json
-import os
-import shutil
-from pathlib import Path
-
-import torch
-import yaml
-from tokenizers import Tokenizer
-
-from transformers import OlmoConfig, OlmoForCausalLM
-from transformers.models.gpt_neox.tokenization_gpt_neox_fast import GPTNeoXTokenizerFast
-
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/olmo/convert_olmo_weights_to_hf.py \
-    --input_dir /path/to/downloaded/olmo/weights --model_size 7B --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import OlmoForCausalLM, AutoTokenizer
-
-model = OlmoForCausalLM.from_pretrained("/output/path")
-tokenizer = AutoTokenizer.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-
-def compute_intermediate_size(n, ffn_dim_multiplier=1, multiple_of=256):
-    return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3)) + multiple_of - 1) // multiple_of)
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def write_json(text, path):
-    with open(path, "w") as f:
-        json.dump(text, f)
-
-
-def write_model(model_path, input_base_path, tokenizer_path=None, safe_serialization=True, fix_eos_token_id=True):
-    os.makedirs(model_path, exist_ok=True)
-    tmp_model_path = os.path.join(model_path, "tmp")
-    os.makedirs(tmp_model_path, exist_ok=True)
-
-    config_path = Path(input_base_path) / "config.yaml"
-    olmo_config = yaml.safe_load(config_path.read_text())["model"]
-
-    n_layers = olmo_config["n_layers"]
-    n_heads = olmo_config["n_heads"]
-    dim = olmo_config["d_model"]
-    dims_per_head = dim // n_heads
-    base = 10000.0
-    inv_freq = 1.0 / (base ** (torch.arange(0, dims_per_head, 2).float() / dims_per_head))
-    max_position_embeddings = olmo_config["max_sequence_length"]
-
-    vocab_size = olmo_config.get("embedding_size", olmo_config["vocab_size"])
-
-    if olmo_config.get("n_kv_heads", None) is not None:
-        num_key_value_heads = olmo_config["n_kv_heads"]  # for GQA / MQA
-    elif olmo_config["multi_query_attention"]:  # compatibility with other checkpoints
-        num_key_value_heads = 1
-    else:
-        num_key_value_heads = n_heads
-
-    print(f"Fetching all parameters from the checkpoint at {input_base_path}.")
-
-    # Not sharded
-    # (The sharded implementation would also work, but this is simpler.)
-    loaded = torch.load(os.path.join(input_base_path, "model.pt"), map_location="cpu")
-
-    param_count = 0
-    index_dict = {"weight_map": {}}
-    for layer_i in range(n_layers):
-        filename = f"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
-        # Unsharded
-        # TODO: Layernorm stuff
-        # TODO: multi query attention
-        fused_dims = [dim, dims_per_head * num_key_value_heads, dims_per_head * num_key_value_heads]
-        q_proj_weight, k_proj_weight, v_proj_weight = torch.split(
-            loaded[f"transformer.blocks.{layer_i}.att_proj.weight"], fused_dims, dim=0
-        )
-        up_proj_weight, gate_proj_weight = torch.chunk(
-            loaded[f"transformer.blocks.{layer_i}.ff_proj.weight"], 2, dim=0
-        )
-        state_dict = {
-            f"model.layers.{layer_i}.self_attn.q_proj.weight": q_proj_weight,
-            f"model.layers.{layer_i}.self_attn.k_proj.weight": k_proj_weight,
-            f"model.layers.{layer_i}.self_attn.v_proj.weight": v_proj_weight,
-            f"model.layers.{layer_i}.self_attn.o_proj.weight": loaded[f"transformer.blocks.{layer_i}.attn_out.weight"],
-            f"model.layers.{layer_i}.mlp.gate_proj.weight": gate_proj_weight,
-            f"model.layers.{layer_i}.mlp.down_proj.weight": loaded[f"transformer.blocks.{layer_i}.ff_out.weight"],
-            f"model.layers.{layer_i}.mlp.up_proj.weight": up_proj_weight,
-        }
-
-        state_dict[f"model.layers.{layer_i}.self_attn.rotary_emb.inv_freq"] = inv_freq
-
-        for k, v in state_dict.items():
-            index_dict["weight_map"][k] = filename
-            param_count += v.numel()
-        torch.save(state_dict, os.path.join(tmp_model_path, filename))
-
-    filename = f"pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"
-
-    # Unsharded
-    # TODO: Deal with weight-tying
-    state_dict = {
-        "model.embed_tokens.weight": loaded["transformer.wte.weight"],
-        "lm_head.weight": loaded["transformer.ff_out.weight"]
-        if "transformer.ff_out.weight" in loaded
-        else loaded["transformer.wte.weight"],
-    }
-
-    for k, v in state_dict.items():
-        index_dict["weight_map"][k] = filename
-        param_count += v.numel()
-    torch.save(state_dict, os.path.join(tmp_model_path, filename))
-
-    # Write configs
-    index_dict["metadata"] = {"total_size": param_count * 2}
-    write_json(index_dict, os.path.join(tmp_model_path, "pytorch_model.bin.index.json"))
-
-    if olmo_config.get("mlp_hidden_size", None) is not None:
-        intermediate_size = olmo_config["mlp_hidden_size"] // 2
-    else:
-        intermediate_size = (dim * olmo_config["mlp_ratio"]) // 2
-
-    config = OlmoConfig(
-        vocab_size=vocab_size,
-        hidden_size=dim,
-        intermediate_size=intermediate_size,
-        num_hidden_layers=n_layers,
-        num_attention_heads=n_heads,
-        num_key_value_heads=num_key_value_heads,
-        max_position_embeddings=max_position_embeddings,
-        pad_token_id=olmo_config["pad_token_id"],
-        bos_token_id=None,
-        eos_token_id=olmo_config["eos_token_id"],
-        tie_word_embeddings=olmo_config["weight_tying"],
-        rope_theta=base,
-        clip_qkv=olmo_config.get("clip_qkv"),
-    )
-    config.save_pretrained(tmp_model_path)
-
-    # Make space so we can load the model properly now.
-    del state_dict
-    del loaded
-    gc.collect()
-
-    if tokenizer_path is not None:
-        _write_tokenizer(model_path, config, tokenizer_path, fix_eos_token_id)
-
-    print("Loading the checkpoint in a OLMo model.")
-    model = OlmoForCausalLM.from_pretrained(tmp_model_path, torch_dtype=torch.float32, low_cpu_mem_usage=True)
-    # Avoid saving this as part of the config.
-    del model.config._name_or_path
-    print("Saving in the Transformers format.")
-    model.save_pretrained(model_path, safe_serialization=safe_serialization)
-    shutil.rmtree(tmp_model_path)
-
-
-def _write_tokenizer(
-    output_path: Path, config: OlmoConfig, input_tokenizer_path: Path, fix_eos_token_id: bool = True
-) -> None:
-    print(f"Saving a {GPTNeoXTokenizerFast.__name__} to {output_path}.")
-
-    base_tokenizer = Tokenizer.from_file(str(input_tokenizer_path))
-
-    eos_token_id = config.eos_token_id if config.eos_token_id is not None else base_tokenizer.get_vocab_size() - 1
-    pad_token_id = config.pad_token_id if config.pad_token_id is not None else eos_token_id
-
-    if fix_eos_token_id and eos_token_id == 0:
-        # Fixing a bug in OLMo where eos token id was incorrectly set
-        print("Changing eos_token_id from 0 to 50279.")
-        eos_token_id = 50279
-
-    tokenizer = GPTNeoXTokenizerFast(
-        tokenizer_object=base_tokenizer,
-        eos_token=base_tokenizer.decode([eos_token_id], skip_special_tokens=False),
-        pad_token=base_tokenizer.decode([pad_token_id], skip_special_tokens=False),
-        unk_token=None,
-        bos_token=None,
-    )
-
-    tokenizer.save_pretrained(output_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        required=True,
-        help="Location of OLMo weights, which contains config.yaml and model.pt.",
-    )
-    parser.add_argument(
-        "--tokenizer_json_path",
-        default=None,
-        help="Location of OLMo tokenizer json file.",
-    )
-    parser.add_argument(
-        "--output_dir",
-        required=True,
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--no_fix_eos_token_id",
-        action="store_false",
-        dest="fix_eos_token_id",
-        help="If set, does not change eos token id from 0 to 50279 if it is 0. Changing 0 to 50279 is a bug fix, so use this option with care.",
-    )
-    parser.add_argument("--safe_serialization", type=bool, help="Whether or not to save using `safetensors`.")
-    # Different OLMo versions used different default values for max_position_embeddings, hence the need to be able to specify which version is being used.
-    args = parser.parse_args()
-    write_model(
-        model_path=args.output_dir,
-        input_base_path=args.input_dir,
-        safe_serialization=args.safe_serialization,
-        tokenizer_path=args.tokenizer_json_path,
-        fix_eos_token_id=args.fix_eos_token_id,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/olmo2/convert_olmo2_weights_to_hf.py b/src/transformers/models/olmo2/convert_olmo2_weights_to_hf.py
deleted file mode 100644
index d804e7a159e4..000000000000
--- a/src/transformers/models/olmo2/convert_olmo2_weights_to_hf.py
+++ /dev/null
@@ -1,306 +0,0 @@
-# Copyright 2024 EleutherAI and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import argparse
-import gc
-import json
-import os
-import shutil
-from pathlib import Path
-from typing import Any, Dict
-
-import torch
-import yaml
-from tokenizers import Tokenizer
-
-from transformers import Olmo2Config, Olmo2ForCausalLM
-from transformers.models.gpt2.tokenization_gpt2_fast import GPT2TokenizerFast
-
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/olmo2/convert_olmo2_weights_to_hf.py \
-    --input_dir /path/to/downloaded/olmo2/weights --model_size 7B --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import Olmo2ForCausalLM, AutoTokenizer
-
-model = Olmo2ForCausalLM.from_pretrained("/output/path")
-tokenizer = AutoTokenizer.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-
-def compute_intermediate_size(n, ffn_dim_multiplier=1, multiple_of=256):
-    return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3)) + multiple_of - 1) // multiple_of)
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def write_json(text, path):
-    with open(path, "w") as f:
-        json.dump(text, f)
-
-
-def write_model(
-    model_path,
-    input_base_path,
-    include_tokenizer=True,
-    tokenizer_path=None,
-    safe_serialization=True,
-    fix_eos_token_id=True,
-    tmp_cleanup=True,
-):
-    os.makedirs(model_path, exist_ok=True)
-    tmp_model_path = os.path.join(model_path, "tmp")
-    os.makedirs(tmp_model_path, exist_ok=True)
-
-    config_path = Path(input_base_path) / "config.yaml"
-    olmo2_config = yaml.safe_load(config_path.read_text())["model"]
-
-    if not olmo2_config.get("attention_layer_norm", False):
-        raise RuntimeError("OLMo2 checkpoints must have attention layer norm")
-    if not olmo2_config.get("norm_after", False):
-        raise RuntimeError("OLMo2 checkpoints must set norm_after to True")
-
-    n_layers = olmo2_config["n_layers"]
-    n_heads = olmo2_config["n_heads"]
-    dim = olmo2_config["d_model"]
-    dims_per_head = dim // n_heads
-    base = olmo2_config["rope_theta"]
-    inv_freq = 1.0 / (base ** (torch.arange(0, dims_per_head, 2).float() / dims_per_head))
-    max_position_embeddings = olmo2_config["max_sequence_length"]
-
-    vocab_size = olmo2_config.get("embedding_size", olmo2_config["vocab_size"])
-
-    if olmo2_config.get("n_kv_heads", None) is not None:
-        num_key_value_heads = olmo2_config["n_kv_heads"]  # for GQA / MQA
-    elif olmo2_config["multi_query_attention"]:  # compatibility with other checkpoints
-        num_key_value_heads = 1
-    else:
-        num_key_value_heads = n_heads
-
-    print(f"Fetching all parameters from the checkpoint at {input_base_path}.")
-
-    # Not sharded
-    # (The sharded implementation would also work, but this is simpler.)
-    loaded = torch.load(os.path.join(input_base_path, "model.pt"), map_location="cpu")
-
-    param_count = 0
-    index_dict: Dict[str, Any] = {"weight_map": {}}
-    for layer_i in range(n_layers):
-        filename = f"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
-        # Unsharded
-        # TODO: Layernorm stuff
-        # TODO: multi query attention
-        fused_dims = [dim, dims_per_head * num_key_value_heads, dims_per_head * num_key_value_heads]
-        q_proj_weight, k_proj_weight, v_proj_weight = torch.split(
-            loaded[f"transformer.blocks.{layer_i}.att_proj.weight"], fused_dims, dim=0
-        )
-        up_proj_weight, gate_proj_weight = torch.chunk(
-            loaded[f"transformer.blocks.{layer_i}.ff_proj.weight"], 2, dim=0
-        )
-        state_dict = {
-            f"model.layers.{layer_i}.self_attn.q_proj.weight": q_proj_weight,
-            f"model.layers.{layer_i}.self_attn.k_proj.weight": k_proj_weight,
-            f"model.layers.{layer_i}.self_attn.v_proj.weight": v_proj_weight,
-            f"model.layers.{layer_i}.self_attn.o_proj.weight": loaded[f"transformer.blocks.{layer_i}.attn_out.weight"],
-            f"model.layers.{layer_i}.self_attn.q_norm.weight": loaded[f"transformer.blocks.{layer_i}.q_norm.weight"],
-            f"model.layers.{layer_i}.self_attn.k_norm.weight": loaded[f"transformer.blocks.{layer_i}.k_norm.weight"],
-            f"model.layers.{layer_i}.mlp.gate_proj.weight": gate_proj_weight,
-            f"model.layers.{layer_i}.mlp.down_proj.weight": loaded[f"transformer.blocks.{layer_i}.ff_out.weight"],
-            f"model.layers.{layer_i}.mlp.up_proj.weight": up_proj_weight,
-            f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[
-                f"transformer.blocks.{layer_i}.attn_norm.weight"
-            ],
-            f"model.layers.{layer_i}.post_feedforward_layernorm.weight": loaded[
-                f"transformer.blocks.{layer_i}.ff_norm.weight"
-            ],
-        }
-
-        state_dict[f"model.layers.{layer_i}.self_attn.rotary_emb.inv_freq"] = inv_freq
-
-        for k, v in state_dict.items():
-            index_dict["weight_map"][k] = filename
-            param_count += v.numel()
-        torch.save(state_dict, os.path.join(tmp_model_path, filename))
-
-    filename = f"pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"
-
-    # Unsharded
-    # TODO: Deal with weight-tying
-    state_dict = {
-        "model.embed_tokens.weight": loaded["transformer.wte.weight"],
-        "model.norm.weight": loaded["transformer.ln_f.weight"],
-        "lm_head.weight": loaded["transformer.ff_out.weight"]
-        if "transformer.ff_out.weight" in loaded
-        else loaded["transformer.wte.weight"],
-    }
-
-    for k, v in state_dict.items():
-        index_dict["weight_map"][k] = filename
-        param_count += v.numel()
-    torch.save(state_dict, os.path.join(tmp_model_path, filename))
-
-    # Write configs
-    index_dict["metadata"] = {"total_size": param_count * 2}
-    write_json(index_dict, os.path.join(tmp_model_path, "pytorch_model.bin.index.json"))
-
-    if olmo2_config.get("mlp_hidden_size", None) is not None:
-        intermediate_size = olmo2_config["mlp_hidden_size"] // 2
-    else:
-        intermediate_size = (dim * olmo2_config["mlp_ratio"]) // 2
-
-    if fix_eos_token_id and olmo2_config["eos_token_id"] == 0:
-        # Fixing a bug in OLMo where eos token id was incorrectly set
-        print("Changing eos_token_id from 0 to 50279.")
-        olmo2_config["eos_token_id"] = 50279
-
-    config = Olmo2Config(
-        vocab_size=vocab_size,
-        hidden_size=dim,
-        intermediate_size=intermediate_size,
-        num_hidden_layers=n_layers,
-        num_attention_heads=n_heads,
-        num_key_value_heads=num_key_value_heads,
-        max_position_embeddings=max_position_embeddings,
-        pad_token_id=olmo2_config["pad_token_id"],
-        bos_token_id=None,
-        eos_token_id=olmo2_config["eos_token_id"],
-        tie_word_embeddings=olmo2_config["weight_tying"],
-        rms_norm_eps=olmo2_config["layer_norm_eps"],
-        rope_theta=base,
-    )
-    config.save_pretrained(tmp_model_path)
-
-    # Make space so we can load the model properly now.
-    del state_dict
-    del loaded
-    gc.collect()
-
-    if include_tokenizer:
-        _write_tokenizer(model_path, config, input_base_path, tokenizer_path)
-
-    print("Loading the checkpoint in a OLMo2 model.")
-    model = Olmo2ForCausalLM.from_pretrained(tmp_model_path, torch_dtype=torch.float32, low_cpu_mem_usage=True)
-    # Avoid saving this as part of the config.
-    del model.config._name_or_path
-    print("Saving in the Transformers format.")
-    model.save_pretrained(model_path, safe_serialization=safe_serialization)
-    if tmp_cleanup:
-        # Make cleanup optional; attempting to `rmtree` the `tmp_model_path` causes
-        # errors if using NFS.
-        shutil.rmtree(tmp_model_path)
-
-
-def _write_tokenizer(
-    output_path: Path,
-    config: Olmo2Config,
-    checkpoint_dir: str,
-    input_tokenizer_path: Path | None,
-) -> None:
-    print(f"Saving a {GPT2TokenizerFast.__name__} to {output_path}.")
-
-    if input_tokenizer_path is not None:
-        base_tokenizer = Tokenizer.from_file(str(input_tokenizer_path))
-    else:
-        config_path = Path(checkpoint_dir) / "config.yaml"
-        tokenizer_config = yaml.safe_load(config_path.read_text())["tokenizer"]
-
-        # Initialize tokenizer and validate vocab size.
-        if Path(tokenizer_config["identifier"]).is_file():
-            base_tokenizer = Tokenizer.from_file(tokenizer_config["identifier"])
-        else:
-            base_tokenizer = Tokenizer.from_pretrained(tokenizer_config["identifier"])
-
-    eos_token_id = config.eos_token_id if config.eos_token_id is not None else base_tokenizer.get_vocab_size() - 1
-    pad_token_id = config.pad_token_id if config.pad_token_id is not None else eos_token_id
-
-    tokenizer = GPT2TokenizerFast(
-        tokenizer_object=base_tokenizer,
-        eos_token=base_tokenizer.decode([eos_token_id], skip_special_tokens=False),
-        pad_token=base_tokenizer.decode([pad_token_id], skip_special_tokens=False),
-    )
-
-    tokenizer.save_pretrained(output_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        required=True,
-        help="Location of OLMo2 weights, which contains config.yaml and model.pt.",
-    )
-    parser.add_argument(
-        "--no_tokenizer",
-        action="store_false",
-        dest="include_tokenizer",
-        help="If set, do not convert OLMo tokenizer to HF tokenizer.",
-    )
-    parser.add_argument(
-        "--tokenizer_json_path",
-        type=Path,
-        default=None,
-        help="Location of OLMo2 tokenizer json file. Defaults to what is set in the config file.",
-    )
-    parser.add_argument(
-        "--output_dir",
-        required=True,
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--no_fix_eos_token_id",
-        action="store_false",
-        dest="fix_eos_token_id",
-        help="If set, does not change eos token id from 0 to 50279 if it is 0. Changing 0 to 50279 is a bug fix, so use this option with care.",
-    )
-    parser.add_argument(
-        "--no_tmp_cleanup",
-        action="store_false",
-        dest="tmp_cleanup",
-        help="If passed, don't remove temp dir at end of HF conversion.",
-    )
-    parser.add_argument(
-        "--no_safe_serialization",
-        action="store_false",
-        dest="safe_serialization",
-        help="Whether or not to save using `safetensors`.",
-    )
-    args = parser.parse_args()
-    write_model(
-        model_path=args.output_dir,
-        input_base_path=args.input_dir,
-        safe_serialization=args.safe_serialization,
-        include_tokenizer=args.include_tokenizer,
-        tokenizer_path=args.tokenizer_json_path,
-        fix_eos_token_id=args.fix_eos_token_id,
-        tmp_cleanup=args.tmp_cleanup,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/olmoe/convert_olmoe_weights_to_hf.py b/src/transformers/models/olmoe/convert_olmoe_weights_to_hf.py
deleted file mode 100644
index a14cd50a0e74..000000000000
--- a/src/transformers/models/olmoe/convert_olmoe_weights_to_hf.py
+++ /dev/null
@@ -1,281 +0,0 @@
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Example for running:
-0. Cp ckpts to local
-aws s3 cp --recursive s3://ai2-llm/checkpoints/OLMoE/olmoe-8x1b-newhp-newds-final-annealFrom1200000/step23842 /data/niklas/llm/checkpoints/olmoe-8x1b-newhp-newds-final-annealFrom1200000_step23842
-1. Unshard your OLMoE checkpoint using https://github.com/allenai/OLMo/blob/7d63fe09d23cf23714da5aa633a44a90180195da/scripts/unshard.py
-python OLMo/scripts/unshard.py /data/niklas/llm/checkpoints/23485/step954000 /data/niklas/llm/checkpoints/1b-954000-unsharded --model-only
-python OLMo/scripts/unshard.py /data/niklas/llm/checkpoints/23485/step954000 /data/niklas/llm/checkpoints/1b-954000-unsharded --model-only
-python OLMo/scripts/unshard.py /data/niklas/llm/checkpoints/olmoe-8x1b-newhp-newds-final-annealFrom1200000_step23842 /data/niklas/llm/checkpoints/olmoe-8x1b-newhp-newds-final-annealFrom1200000_step23842-unsharded --model-only
-2. Convert to transformers
-rm -rf olmoe; mkdir olmoe; python /data/niklas/transformers/src/transformers/models/olmoe/convert_olmoe_weights_to_hf.py --input_dir /data/niklas/llm/checkpoints/olmoe-8x1b-newhp-newds-final-annealFrom1200000_step23842-unsharded --tokenizer_json_path /data/niklas/llm/checkpoints/olmoe-step1200000-unsharded/tokenizer.json --output_dir olmoe
-3. Load model via:
-```
-from transformers import OlmoeForCausalLM, AutoTokenizer
-import torch
-model = OlmoeForCausalLM.from_pretrained("../transformers/olmoe", torch_dtype=torch.bfloat16).cuda()
-model = OlmoeForCausalLM.from_pretrained("../transformers/olmoe").cuda()
-tokenizer = AutoTokenizer.from_pretrained("../transformers/olmoe")
-inputs = tokenizer("Bitcoin is", return_tensors="pt")
-inputs = {k: v.cuda() for k, v in inputs.items()}
-out = model.generate(**inputs, max_length=64)
-print(tokenizer.decode(out[0]))
-# > # Bitcoin is a digital currency that is created and held electronically. No one controls it. Bitcoins aren’t printed, like dollars or euros – they’re produced by people and businesses running computers all around the world, using software that solves mathematical
-# Or quick sanity check:
-o = model(torch.tensor([[0, 1]]).cuda())
-# If the checkpoint is not converted to BF16 but kept in FP32:
-# > # Bitcoin is a digital currency that is not controlled by any central authority. It is a peer-to-peer payment system that allows users to send and receive payments from anywhere in the world. Bitcoin is also known as a cryptocurrency because it uses cryptography to secure transactions and prevent fraud.
-```
-
-Note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-
-Compare with OLMo codebase:
-```
-from olmo.model import OLMo
-import torch
-model = OLMo.from_checkpoint("/data/niklas/llm/checkpoints/olmoe-step1200000-unsharded-pt")
-model = model.cuda()
-model = model.to(torch.bfloat16)
-from transformers import AutoTokenizer
-tokenizer = AutoTokenizer.from_pretrained("../transformers/olmoe")
-inputs = tokenizer("Bitcoin is", return_tensors="pt")
-inputs = {k: v.cuda() for k, v in inputs.items()}
-out = model.generate(**inputs)
-print(tokenizer.decode(out[0][0][0]))
-# Bitcoin is a digital currency that is created and held electronically. No one controls it. Bitcoins aren’t printed, like dollars or euros – they’re produced by people and businesses running computers all around the world, using software that solves mathematical problems. It’s the first example of a growing category of money
-# Or quick sanity check:
-o = model(torch.tensor([[0, 1]]).cuda())
-```
-"""
-
-import argparse
-import gc
-import json
-import os
-import shutil
-from pathlib import Path
-
-import torch
-import yaml
-from tokenizers import Tokenizer
-
-from transformers import OlmoeConfig, OlmoeForCausalLM
-from transformers.models.gpt_neox.tokenization_gpt_neox_fast import GPTNeoXTokenizerFast
-
-
-def compute_intermediate_size(n, ffn_dim_multiplier=1, multiple_of=256):
-    return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3)) + multiple_of - 1) // multiple_of)
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def write_json(text, path):
-    with open(path, "w") as f:
-        json.dump(text, f)
-
-
-def write_model(model_path, input_base_path, tokenizer_path=None, safe_serialization=True, fix_eos_token_id=True):
-    os.makedirs(model_path, exist_ok=True)
-    tmp_model_path = os.path.join(model_path, "tmp")
-    os.makedirs(tmp_model_path, exist_ok=True)
-
-    config_path = Path(input_base_path) / "config.yaml"
-    olmoe_config = yaml.safe_load(config_path.read_text())["model"]
-
-    if fix_eos_token_id:
-        olmoe_config["eos_token_id"] = 50279
-
-    n_layers = olmoe_config["n_layers"]
-    n_heads = olmoe_config["n_heads"]
-    dim = olmoe_config["d_model"]
-    dims_per_head = dim // n_heads
-    base = 10000.0
-    inv_freq = 1.0 / (base ** (torch.arange(0, dims_per_head, 2).float() / dims_per_head))
-    max_position_embeddings = olmoe_config["max_sequence_length"]
-
-    vocab_size = olmoe_config.get("embedding_size", olmoe_config["vocab_size"])
-
-    if olmoe_config.get("n_kv_heads", None) is not None:
-        num_key_value_heads = olmoe_config["n_kv_heads"]  # for GQA / MQA
-    elif olmoe_config["multi_query_attention"]:  # compatibility with other checkpoints
-        num_key_value_heads = 1
-    else:
-        num_key_value_heads = n_heads
-
-    print(f"Fetching all parameters from the checkpoint at {input_base_path}.")
-
-    # Not sharded
-    loaded = torch.load(os.path.join(input_base_path, "model.pt"), map_location="cpu")
-
-    param_count = 0
-    index_dict = {"weight_map": {}}
-    for layer_i in range(n_layers):
-        filename = f"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
-        fused_dims = [dim, dims_per_head * num_key_value_heads, dims_per_head * num_key_value_heads]
-        q_proj_weight, k_proj_weight, v_proj_weight = torch.split(
-            loaded[f"transformer.blocks.{layer_i}.att_proj.weight"], fused_dims, dim=0
-        )
-        state_dict = {
-            f"model.layers.{layer_i}.self_attn.q_proj.weight": q_proj_weight,
-            f"model.layers.{layer_i}.self_attn.k_proj.weight": k_proj_weight,
-            f"model.layers.{layer_i}.self_attn.v_proj.weight": v_proj_weight,
-            f"model.layers.{layer_i}.self_attn.o_proj.weight": loaded[f"transformer.blocks.{layer_i}.attn_out.weight"],
-            f"model.layers.{layer_i}.self_attn.q_norm.weight": loaded[f"transformer.blocks.{layer_i}.q_norm.weight"],
-            f"model.layers.{layer_i}.self_attn.k_norm.weight": loaded[f"transformer.blocks.{layer_i}.k_norm.weight"],
-            f"model.layers.{layer_i}.mlp.gate.weight": loaded[f"transformer.blocks.{layer_i}.ffn.router.layer.weight"],
-            f"model.layers.{layer_i}.input_layernorm.weight": loaded[f"transformer.blocks.{layer_i}.attn_norm.weight"],
-            f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[
-                f"transformer.blocks.{layer_i}.ff_norm.weight"
-            ],
-        }
-
-        num_experts = loaded[f"transformer.blocks.{layer_i}.ffn.router.layer.weight"].shape[0]
-        dim_per_expert = loaded[f"transformer.blocks.{layer_i}.ffn.experts.mlp.w1"].shape[0] // num_experts
-        for expert_i in range(num_experts):
-            state_dict[f"model.layers.{layer_i}.mlp.experts.{expert_i}.gate_proj.weight"] = loaded[
-                f"transformer.blocks.{layer_i}.ffn.experts.mlp.w1"
-            ][dim_per_expert * expert_i : dim_per_expert * (expert_i + 1), :]
-            state_dict[f"model.layers.{layer_i}.mlp.experts.{expert_i}.up_proj.weight"] = loaded[
-                f"transformer.blocks.{layer_i}.ffn.experts.mlp.v1"
-            ][dim_per_expert * expert_i : dim_per_expert * (expert_i + 1), :]
-            state_dict[f"model.layers.{layer_i}.mlp.experts.{expert_i}.down_proj.weight"] = loaded[
-                f"transformer.blocks.{layer_i}.ffn.experts.mlp.w2"
-            ][dim_per_expert * expert_i : dim_per_expert * (expert_i + 1), :].T.contiguous()
-
-        state_dict[f"model.layers.{layer_i}.self_attn.rotary_emb.inv_freq"] = inv_freq
-
-        for k, v in state_dict.items():
-            index_dict["weight_map"][k] = filename
-            param_count += v.numel()
-        torch.save(state_dict, os.path.join(tmp_model_path, filename))
-
-    filename = f"pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"
-
-    # Unsharded
-    state_dict = {
-        "model.embed_tokens.weight": loaded["transformer.wte.weight"],
-        "lm_head.weight": loaded["transformer.ff_out.weight"],
-        "model.norm.weight": loaded["transformer.ln_f.weight"],
-    }
-
-    for k, v in state_dict.items():
-        index_dict["weight_map"][k] = filename
-        param_count += v.numel()
-    torch.save(state_dict, os.path.join(tmp_model_path, filename))
-
-    # Write configs
-    index_dict["metadata"] = {"total_size": param_count * 2}
-    write_json(index_dict, os.path.join(tmp_model_path, "pytorch_model.bin.index.json"))
-
-    config = OlmoeConfig(
-        vocab_size=vocab_size,
-        hidden_size=dim,
-        intermediate_size=dim_per_expert,
-        num_hidden_layers=n_layers,
-        num_attention_heads=n_heads,
-        num_key_value_heads=num_key_value_heads,
-        max_position_embeddings=max_position_embeddings,
-        pad_token_id=olmoe_config["pad_token_id"],
-        bos_token_id=None,
-        eos_token_id=olmoe_config["eos_token_id"],
-        tie_word_embeddings=olmoe_config["weight_tying"],
-        rope_theta=base,
-        clip_qkv=olmoe_config.get("clip_qkv"),
-    )
-    config.save_pretrained(tmp_model_path)
-
-    # Make space so we can load the model properly now.
-    del state_dict
-    del loaded
-    gc.collect()
-
-    if tokenizer_path is not None:
-        _write_tokenizer(model_path, config, tokenizer_path, fix_eos_token_id)
-
-    print("Loading the checkpoint in a OLMoE model.")
-    model = OlmoeForCausalLM.from_pretrained(tmp_model_path, torch_dtype=torch.bfloat16)
-    # Avoid saving this as part of the config.
-    del model.config._name_or_path
-    print("Saving in the Transformers format.")
-    model.save_pretrained(model_path, safe_serialization=safe_serialization)
-    shutil.rmtree(tmp_model_path)
-
-
-def _write_tokenizer(
-    output_path: Path, config: OlmoeConfig, input_tokenizer_path: Path, fix_eos_token_id: bool = True
-) -> None:
-    print(f"Saving a {GPTNeoXTokenizerFast.__name__} to {output_path}.")
-
-    base_tokenizer = Tokenizer.from_file(str(input_tokenizer_path))
-
-    eos_token_id = config.eos_token_id if config.eos_token_id is not None else base_tokenizer.get_vocab_size() - 1
-    pad_token_id = config.pad_token_id if config.pad_token_id is not None else eos_token_id
-
-    if fix_eos_token_id and eos_token_id == 0:
-        # Fixing a bug in OLMo where eos token id was incorrectly set
-        print("Changing eos_token_id from 0 to 50279.")
-        eos_token_id = 50279
-
-    tokenizer = GPTNeoXTokenizerFast(
-        tokenizer_object=base_tokenizer,
-        eos_token=base_tokenizer.decode([eos_token_id], skip_special_tokens=False),
-        pad_token=base_tokenizer.decode([pad_token_id], skip_special_tokens=False),
-        unk_token=None,
-        bos_token=None,
-    )
-
-    tokenizer.save_pretrained(output_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        required=True,
-        help="Location of OLMoE weights, which contains config.yaml and model.pt.",
-    )
-    parser.add_argument(
-        "--tokenizer_json_path",
-        default=None,
-        help="Location of OLMoE tokenizer json file.",
-    )
-    parser.add_argument(
-        "--output_dir",
-        required=True,
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--no_fix_eos_token_id",
-        action="store_false",
-        dest="fix_eos_token_id",
-        help="If set, does not change eos token id from 0 to 50279 if it is 0. Changing 0 to 50279 is a bug fix, so use this option with care.",
-    )
-    parser.add_argument(
-        "--safe_serialization", type=bool, default=True, help="Whether or not to save using `safetensors`."
-    )
-    args = parser.parse_args()
-    write_model(
-        model_path=args.output_dir,
-        input_base_path=args.input_dir,
-        safe_serialization=args.safe_serialization,
-        tokenizer_path=args.tokenizer_json_path,
-        fix_eos_token_id=args.fix_eos_token_id,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/omdet_turbo/convert_omdet_turbo_to_hf.py b/src/transformers/models/omdet_turbo/convert_omdet_turbo_to_hf.py
deleted file mode 100644
index 2e515e983408..000000000000
--- a/src/transformers/models/omdet_turbo/convert_omdet_turbo_to_hf.py
+++ /dev/null
@@ -1,349 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert OmDet-Turbo checkpoints from the original repository.
-
-URL: https://github.com/om-ai-lab/OmDet"""
-
-import argparse
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import (
-    CLIPTokenizer,
-    DetrImageProcessor,
-    OmDetTurboConfig,
-    OmDetTurboForObjectDetection,
-    OmDetTurboProcessor,
-)
-
-
-IMAGE_MEAN = [123.675, 116.28, 103.53]
-IMAGE_STD = [58.395, 57.12, 57.375]
-
-
-def get_omdet_turbo_config(model_name, use_timm_backbone):
-    if "tiny" in model_name:
-        window_size = 7
-        embed_dim = 96
-        depths = (2, 2, 6, 2)
-        num_heads = (3, 6, 12, 24)
-        image_size = 640
-    else:
-        raise ValueError("Model not supported, only supports tiny variant.")
-
-    config = OmDetTurboConfig(
-        backbone_window_size=window_size,
-        backbone_image_size=image_size,
-        backbone_embed_dim=embed_dim,
-        backbone_depths=depths,
-        backbone_num_heads=num_heads,
-        backbone_out_indices=(1, 2, 3),
-        text_config={"model_type": "clip_text_model"},
-        use_timm_backbone=use_timm_backbone,
-        backbone="swin_tiny_patch4_window7_224" if use_timm_backbone else None,
-        apply_layernorm_after_vision_backbone=True if use_timm_backbone else False,
-        use_pretrained_backbone=False,
-    )
-
-    return config
-
-
-def create_rename_keys_vision(state_dict, config):
-    rename_keys = []
-    # fmt: off
-    ########################################## VISION BACKBONE - START
-    for layer_name in state_dict.keys():
-        if layer_name.startswith("backbone") and not layer_name.startswith("backbone.norm"):
-            if config.use_timm_backbone:
-                layer_name_replace = layer_name.replace("backbone", "vision_backbone.vision_backbone._backbone")
-                layer_name_replace = layer_name_replace.replace(".layers.", ".layers_")
-                if "downsample" in layer_name:
-                    # get layer number
-                    layer_num = int(layer_name.split(".")[2])
-                    layer_name_replace = layer_name_replace.replace(f"{layer_num}.downsample", f"{layer_num+1}.downsample")
-            else:
-                layer_name_replace = layer_name.replace("backbone", "vision_backbone.vision_backbone")
-                layer_name_replace = layer_name_replace.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-                layer_name_replace = layer_name_replace.replace("patch_embed.norm", "embeddings.norm")
-                if layer_name.startswith("backbone.layers"):
-                    layer_name_replace = layer_name_replace.replace("norm1", "layernorm_before")
-                    layer_name_replace = layer_name_replace.replace("norm2", "layernorm_after")
-                    layer_name_replace = layer_name_replace.replace("attn.proj", "attention.output.dense")
-                    layer_name_replace = layer_name_replace.replace("mlp.fc1", "intermediate.dense")
-                    layer_name_replace = layer_name_replace.replace("mlp.fc2", "output.dense")
-                    layer_name_replace = layer_name_replace.replace(".layers.", ".encoder.layers.")
-                    layer_name_replace = layer_name_replace.replace(".attn.", ".attention.self.")
-        elif layer_name.startswith("backbone.norm"):
-            layer_num = int(layer_name.split("norm")[1].split(".")[0])
-            if config.use_timm_backbone:
-                layer_name_replace = layer_name.replace("backbone", "vision_backbone")
-                layer_name_replace = layer_name_replace.replace(f"norm{layer_num}", f"layer_norms.{layer_num-1}")
-            else:
-                layer_name_replace = layer_name.replace(f"backbone.norm{layer_num}", f"vision_backbone.vision_backbone.hidden_states_norms.stage{layer_num+1}")
-        else:
-            continue
-        rename_keys.append((layer_name, layer_name_replace))
-    ########################################## VISION BACKBONE - END
-
-    ########################################## ENCODER - START
-    for layer_name, params in state_dict.items():
-        if "neck" in layer_name:
-            layer_name_replace = layer_name.replace("neck", "encoder")
-            layer_name_replace = layer_name_replace.replace("input_proj", "channel_projection_layers")
-            if "fpn_blocks" in layer_name or "pan_blocks" in layer_name or "lateral_convs" in layer_name or "downsample_convs" in layer_name:
-                layer_name_replace = layer_name_replace.replace(".m.", ".bottlenecks.")
-                layer_name_replace = layer_name_replace.replace(".cv", ".conv")
-                layer_name_replace = layer_name_replace.replace(".bn", ".norm")
-            if "encoder_layer" in layer_name:
-                layer_name_replace = layer_name_replace.replace("encoder_layer", "encoder.0.layers.0")
-                layer_name_replace = layer_name_replace.replace(".linear", ".fc")
-                layer_name_replace = layer_name_replace.replace("norm1", "self_attn_layer_norm")
-                layer_name_replace = layer_name_replace.replace("norm2", "final_layer_norm")
-            rename_keys.append((layer_name, layer_name_replace))
-    ########################################## ENCODER - END
-
-    ########################################## DECODER - START
-    for layer_name, params in state_dict.items():
-        if layer_name.startswith("decoder"):
-            layer_name_replace = layer_name.replace("decoder.decoder.layers", "decoder.layers")
-            layer_name_replace = layer_name_replace.replace("input_proj", "channel_projection_layers")
-            layer_name_replace = layer_name_replace.replace("query_pos_head", "query_position_head")
-            layer_name_replace = layer_name_replace.replace("enc_bbox_head", "encoder_bbox_head")
-            layer_name_replace = layer_name_replace.replace("enc_output", "encoder_vision_features")
-            layer_name_replace = layer_name_replace.replace("dec_score_head", "decoder_class_head")
-            layer_name_replace = layer_name_replace.replace("dec_bbox_head", "decoder_bbox_head")
-            layer_name_replace = layer_name_replace.replace("enc_score_head", "encoder_class_head")
-            rename_keys.append((layer_name, layer_name_replace))
-    ########################################## DECODER - END
-    # fmt: on
-    return rename_keys
-
-
-def create_rename_keys_language(state_dict):
-    rename_keys = []
-    # fmt: off
-    for layer_name in state_dict.keys():
-        if layer_name.startswith("language_backbone") and not layer_name.startswith("language_backbone.text_projection"):
-            layer_name_replace = layer_name.replace("language_backbone", "language_backbone.model.text_model")
-            layer_name_replace = layer_name_replace.replace("transformer.resblocks", "encoder.layers")
-            layer_name_replace = layer_name_replace.replace("token_embedding", "embeddings.token_embedding")
-            layer_name_replace = layer_name_replace.replace("positional_embedding", "embeddings.position_embedding.weight")
-            layer_name_replace = layer_name_replace.replace(".attn", ".self_attn")
-            layer_name_replace = layer_name_replace.replace(".mlp.c_fc", ".mlp.fc1")
-            layer_name_replace = layer_name_replace.replace(".mlp.c_proj", ".mlp.fc2")
-            layer_name_replace = layer_name_replace.replace("ln_final", "final_layer_norm")
-            layer_name_replace = layer_name_replace.replace(".ln_", ".layer_norm")
-            rename_keys.append((layer_name, layer_name_replace))
-    # fmt: on
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v_vision(state_dict, config):
-    state_dict_keys = list(state_dict.keys())
-    for layer_name_vision in state_dict_keys:
-        if layer_name_vision.startswith("vision_backbone") and "qkv" in layer_name_vision:
-            layer_num = int(layer_name_vision.split(".")[4])
-            hidden_size = config.backbone_config.embed_dim * 2**layer_num
-            if "weight" in layer_name_vision:
-                in_proj_weight = state_dict.pop(layer_name_vision)
-                state_dict[layer_name_vision.replace("qkv.weight", "key.weight")] = in_proj_weight[:hidden_size, :]
-                state_dict[layer_name_vision.replace("qkv.weight", "query.weight")] = in_proj_weight[
-                    hidden_size : hidden_size * 2, :
-                ]
-                state_dict[layer_name_vision.replace("qkv.weight", "value.weight")] = in_proj_weight[-hidden_size:, :]
-            elif "bias" in layer_name_vision:
-                in_proj_bias = state_dict.pop(layer_name_vision)
-                state_dict[layer_name_vision.replace("qkv.bias", "key.bias")] = in_proj_bias[:hidden_size]
-                state_dict[layer_name_vision.replace("qkv.bias", "query.bias")] = in_proj_bias[
-                    hidden_size : hidden_size * 2
-                ]
-                state_dict[layer_name_vision.replace("qkv.bias", "value.bias")] = in_proj_bias[-hidden_size:]
-
-
-def read_in_q_k_v_text(state_dict, config):
-    state_dict_keys = list(state_dict.keys())
-    hidden_size = config.text_config.projection_dim
-    for layer_name_text in state_dict_keys:
-        if layer_name_text.startswith("language_backbone") and "in_proj" in layer_name_text:
-            if "weight" in layer_name_text:
-                in_proj_weight = state_dict.pop(layer_name_text)
-                state_dict[layer_name_text.replace("in_proj_weight", "q_proj.weight")] = in_proj_weight[
-                    :hidden_size, :
-                ]
-                state_dict[layer_name_text.replace("in_proj_weight", "k_proj.weight")] = in_proj_weight[
-                    hidden_size : hidden_size * 2, :
-                ]
-                state_dict[layer_name_text.replace("in_proj_weight", "v_proj.weight")] = in_proj_weight[
-                    -hidden_size:, :
-                ]
-            elif "bias" in layer_name_text:
-                in_proj_bias = state_dict.pop(layer_name_text)
-                state_dict[layer_name_text.replace("in_proj_bias", "q_proj.bias")] = in_proj_bias[:hidden_size]
-                state_dict[layer_name_text.replace("in_proj_bias", "k_proj.bias")] = in_proj_bias[
-                    hidden_size : hidden_size * 2
-                ]
-                state_dict[layer_name_text.replace("in_proj_bias", "v_proj.bias")] = in_proj_bias[-hidden_size:]
-
-
-def read_in_q_k_v_encoder(state_dict, config):
-    embed_dim = config.encoder_hidden_dim
-    # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-    in_proj_weight = state_dict.pop("encoder.encoder.0.layers.0.self_attn.in_proj_weight")
-    in_proj_bias = state_dict.pop("encoder.encoder.0.layers.0.self_attn.in_proj_bias")
-    # next, add query, keys and values (in that order) to the state dict
-    state_dict["encoder.encoder.0.layers.0.self_attn.query.weight"] = in_proj_weight[:embed_dim, :]
-    state_dict["encoder.encoder.0.layers.0.self_attn.query.bias"] = in_proj_bias[:embed_dim]
-    state_dict["encoder.encoder.0.layers.0.self_attn.key.weight"] = in_proj_weight[embed_dim : embed_dim * 2, :]
-    state_dict["encoder.encoder.0.layers.0.self_attn.key.bias"] = in_proj_bias[embed_dim : embed_dim * 2]
-    state_dict["encoder.encoder.0.layers.0.self_attn.value.weight"] = in_proj_weight[-embed_dim:, :]
-    state_dict["encoder.encoder.0.layers.0.self_attn.value.bias"] = in_proj_bias[-embed_dim:]
-
-
-def read_in_q_k_v_decoder(state_dict, config):
-    for layer_num in range(config.decoder_num_layers):
-        embed_dim = config.decoder_hidden_dim
-        # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"decoder.layers.{layer_num}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"decoder.layers.{layer_num}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"decoder.layers.{layer_num}.self_attn.query.weight"] = in_proj_weight[:embed_dim, :]
-        state_dict[f"decoder.layers.{layer_num}.self_attn.query.bias"] = in_proj_bias[:embed_dim]
-        state_dict[f"decoder.layers.{layer_num}.self_attn.key.weight"] = in_proj_weight[embed_dim : embed_dim * 2, :]
-        state_dict[f"decoder.layers.{layer_num}.self_attn.key.bias"] = in_proj_bias[embed_dim : embed_dim * 2]
-        state_dict[f"decoder.layers.{layer_num}.self_attn.value.weight"] = in_proj_weight[-embed_dim:, :]
-        state_dict[f"decoder.layers.{layer_num}.self_attn.value.bias"] = in_proj_bias[-embed_dim:]
-
-
-def run_test(model, processor):
-    # We will verify our results on an image of cute cats
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-
-    classes = ["cat", "remote"]
-    task = "Detect {}.".format(", ".join(classes))
-    inputs = processor(image, text=classes, task=task, return_tensors="pt")
-
-    # Running forward
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    predicted_slice = outputs[1][0, :3, :3]
-    print(predicted_slice)
-    expected_slice = torch.tensor([[0.9427, -2.5958], [0.2105, -3.4569], [-2.6364, -4.1610]])
-
-    assert torch.allclose(predicted_slice, expected_slice, atol=1e-4)
-    print("Looks ok!")
-
-
-@torch.no_grad()
-def convert_omdet_turbo_checkpoint(args):
-    model_name = args.model_name
-    pytorch_dump_folder_path = args.pytorch_dump_folder_path
-    push_to_hub = args.push_to_hub
-    use_timm_backbone = args.use_timm_backbone
-
-    checkpoint_mapping = {
-        "omdet-turbo-tiny": [
-            "https://huggingface.co/omlab/OmDet-Turbo_tiny_SWIN_T/resolve/main/OmDet-Turbo_tiny_SWIN_T.pth",
-            "https://huggingface.co/omlab/OmDet-Turbo_tiny_SWIN_T/resolve/main/ViT-B-16.pt",
-        ],
-    }
-    # Define default OmDetTurbo configuation
-    config = get_omdet_turbo_config(model_name, use_timm_backbone)
-
-    # Load original checkpoint
-    checkpoint_url = checkpoint_mapping[model_name]
-    original_state_dict_vision = torch.hub.load_state_dict_from_url(checkpoint_url[0], map_location="cpu")["model"]
-    original_state_dict_vision = {k.replace("module.", ""): v for k, v in original_state_dict_vision.items()}
-
-    # Rename keys
-    new_state_dict = original_state_dict_vision.copy()
-    rename_keys_vision = create_rename_keys_vision(new_state_dict, config)
-
-    rename_keys_language = create_rename_keys_language(new_state_dict)
-
-    for src, dest in rename_keys_vision:
-        rename_key(new_state_dict, src, dest)
-
-    for src, dest in rename_keys_language:
-        rename_key(new_state_dict, src, dest)
-
-    if not use_timm_backbone:
-        read_in_q_k_v_vision(new_state_dict, config)
-    read_in_q_k_v_text(new_state_dict, config)
-    read_in_q_k_v_encoder(new_state_dict, config)
-    read_in_q_k_v_decoder(new_state_dict, config)
-    # add "model" prefix to all keys
-    new_state_dict = {f"model.{k}": v for k, v in new_state_dict.items()}
-
-    # Load HF model
-    model = OmDetTurboForObjectDetection(config)
-    model.eval()
-    missing_keys, unexpected_keys = model.load_state_dict(new_state_dict, strict=False)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-
-    image_processor = DetrImageProcessor(
-        size={"height": config.backbone_image_size, "width": config.backbone_image_size},
-        do_rescale=False,
-        image_mean=IMAGE_MEAN,
-        image_std=IMAGE_STD,
-        do_pad=False,
-    )
-    tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32")
-    processor = OmDetTurboProcessor(image_processor=image_processor, tokenizer=tokenizer)
-
-    # end-to-end consistency test
-    run_test(model, processor)
-
-    if pytorch_dump_folder_path is not None:
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub(f"omlab/{model_name}")
-        processor.push_to_hub(f"omlab/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="omdet-turbo-tiny",
-        type=str,
-        choices=["omdet-turbo-tiny"],
-        help="Name of the OmDetTurbo model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    parser.add_argument(
-        "--use_timm_backbone", action="store_true", help="Whether or not to use timm backbone for vision backbone."
-    )
-
-    args = parser.parse_args()
-    convert_omdet_turbo_checkpoint(args)
diff --git a/src/transformers/models/oneformer/convert_to_hf_oneformer.py b/src/transformers/models/oneformer/convert_to_hf_oneformer.py
deleted file mode 100644
index 960634f9f4e8..000000000000
--- a/src/transformers/models/oneformer/convert_to_hf_oneformer.py
+++ /dev/null
@@ -1,1191 +0,0 @@
-# coding=utf-8
-# Copyright 2022 SHI Labs and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert OneFormer checkpoints from the original repository. URL: https://github.com/SHI-Labs/OneFormer"""
-
-import os
-import sys
-from argparse import ArgumentParser
-from dataclasses import dataclass
-from pathlib import Path
-from pprint import pformat
-from typing import Any, Dict, Iterator, List, Set, Tuple
-
-import requests
-import torch
-import torchvision.transforms as T
-from PIL import Image
-from torch import Tensor, nn
-
-
-try:
-    from detectron2.checkpoint import DetectionCheckpointer
-    from detectron2.config import get_cfg
-    from detectron2.data import MetadataCatalog
-    from detectron2.projects.deeplab import add_deeplab_config
-except ImportError:
-    pass
-from transformers import CLIPTokenizer, DinatConfig, SwinConfig
-from transformers.models.oneformer.image_processing_oneformer import OneFormerImageProcessor
-from transformers.models.oneformer.modeling_oneformer import (
-    OneFormerConfig,
-    OneFormerForUniversalSegmentation,
-    OneFormerForUniversalSegmentationOutput,
-    OneFormerModel,
-    OneFormerModelOutput,
-)
-from transformers.models.oneformer.processing_oneformer import OneFormerProcessor
-from transformers.utils import logging
-
-
-StateDict = Dict[str, Tensor]
-
-logging.set_verbosity_info()
-logger = logging.get_logger()
-
-torch.manual_seed(0)
-
-
-class TrackedStateDict:
-    def __init__(self, to_track: Dict):
-        """This class "tracks" a python dictionary by keeping track of which item is accessed.
-
-        Args:
-            to_track (Dict): The dictionary we wish to track
-        """
-        self.to_track = to_track
-        self._seen: Set[str] = set()
-
-    def __getitem__(self, key: str) -> Any:
-        return self.to_track[key]
-
-    def __setitem__(self, key: str, item: Any):
-        self._seen.add(key)
-        self.to_track[key] = item
-
-    def diff(self) -> List[str]:
-        """This method returns a set difference between the keys in the tracked state dict and the one we have access so far.
-        This is an effective method to check if we have update all the keys
-
-        Returns:
-            List[str]: List of keys not yet updated
-        """
-        return set(self.to_track.keys()) - self._seen
-
-    def copy(self) -> Dict:
-        # proxy the call to the internal dictionary
-        return self.to_track.copy()
-
-
-# Image to verify the result
-def prepare_img():
-    url = "https://praeclarumjj3.github.io/files/coco.jpeg"
-    img_data = requests.get(url, stream=True).raw
-    im = Image.open(img_data)
-    return im
-
-
-@dataclass
-class Args:
-    """Fake command line arguments needed by oneformer/detectron2 implementation"""
-
-    config_file: str
-
-
-def setup_cfg(args: Args):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    add_deeplab_config(cfg)
-    add_common_config(cfg)
-    add_oneformer_config(cfg)
-    add_swin_config(cfg)
-    add_dinat_config(cfg)
-    cfg.merge_from_file(args.config_file)
-    cfg.freeze()
-    return cfg
-
-
-class OriginalOneFormerConfigToOursConverter:
-    def __call__(self, original_config: object, is_swin: bool) -> OneFormerConfig:
-        model = original_config.MODEL
-
-        dataset_catalog = MetadataCatalog.get(original_config.DATASETS.TEST_PANOPTIC[0])
-        id2label = dict(enumerate(dataset_catalog.stuff_classes))
-        label2id = {label: idx for idx, label in id2label.items()}
-
-        if is_swin:
-            if model.SWIN.EMBED_DIM == 96:
-                backbone_config = SwinConfig.from_pretrained(
-                    "microsoft/swin-tiny-patch4-window7-224",
-                    drop_path_rate=model.SWIN.DROP_PATH_RATE,
-                    out_features=["stage1", "stage2", "stage3", "stage4"],
-                )
-            elif model.SWIN.EMBED_DIM == 192:
-                backbone_config = SwinConfig.from_pretrained(
-                    "microsoft/swin-large-patch4-window12-384",
-                    drop_path_rate=model.SWIN.DROP_PATH_RATE,
-                    out_features=["stage1", "stage2", "stage3", "stage4"],
-                )
-            else:
-                raise ValueError(f"embed dim {model.SWIN.EMBED_DIM} not supported for Swin!")
-        else:
-            backbone_config = DinatConfig.from_pretrained(
-                "shi-labs/dinat-large-11x11-in22k-in1k-384",
-                dilations=model.DiNAT.DILATIONS,
-                kernel_size=model.DiNAT.KERNEL_SIZE,
-                out_features=["stage1", "stage2", "stage3", "stage4"],
-            )
-
-        config: OneFormerConfig = OneFormerConfig(
-            backbone_config=backbone_config,
-            output_attentions=True,
-            output_hidden_states=True,
-            return_dict=True,
-            ignore_value=model.SEM_SEG_HEAD.IGNORE_VALUE,
-            num_classes=model.SEM_SEG_HEAD.NUM_CLASSES,
-            num_queries=model.ONE_FORMER.NUM_OBJECT_QUERIES,
-            no_object_weight=model.ONE_FORMER.NO_OBJECT_WEIGHT,
-            class_weight=model.ONE_FORMER.CLASS_WEIGHT,
-            mask_weight=model.ONE_FORMER.MASK_WEIGHT,
-            dice_weight=model.ONE_FORMER.DICE_WEIGHT,
-            contrastive_weight=model.ONE_FORMER.CONTRASTIVE_WEIGHT,
-            contrastive_temperature=model.ONE_FORMER.CONTRASTIVE_TEMPERATURE,
-            train_num_points=model.ONE_FORMER.TRAIN_NUM_POINTS,
-            oversample_ratio=model.ONE_FORMER.OVERSAMPLE_RATIO,
-            importance_sample_ratio=model.ONE_FORMER.IMPORTANCE_SAMPLE_RATIO,
-            init_std=0.02,
-            init_xavier_std=1.0,
-            layer_norm_eps=1e-05,
-            is_training=False,
-            use_auxiliary_loss=model.ONE_FORMER.DEEP_SUPERVISION,
-            output_auxiliary_logits=True,
-            strides=[4, 8, 16, 32],
-            task_seq_len=original_config.INPUT.TASK_SEQ_LEN,
-            max_seq_len=original_config.INPUT.MAX_SEQ_LEN,
-            text_encoder_width=model.TEXT_ENCODER.WIDTH,
-            text_encoder_context_length=model.TEXT_ENCODER.CONTEXT_LENGTH,
-            text_encoder_num_layers=model.TEXT_ENCODER.NUM_LAYERS,
-            text_encoder_vocab_size=model.TEXT_ENCODER.VOCAB_SIZE,
-            text_encoder_proj_layers=model.TEXT_ENCODER.PROJ_NUM_LAYERS,
-            text_encoder_n_ctx=model.TEXT_ENCODER.N_CTX,
-            conv_dim=model.SEM_SEG_HEAD.CONVS_DIM,
-            mask_dim=model.SEM_SEG_HEAD.MASK_DIM,
-            hidden_dim=model.ONE_FORMER.HIDDEN_DIM,
-            norm=model.SEM_SEG_HEAD.NORM,
-            encoder_layers=model.SEM_SEG_HEAD.TRANSFORMER_ENC_LAYERS,
-            encoder_feedforward_dim=1024,
-            decoder_layers=model.ONE_FORMER.DEC_LAYERS,
-            use_task_norm=model.ONE_FORMER.USE_TASK_NORM,
-            num_attention_heads=model.ONE_FORMER.NHEADS,
-            dropout=model.ONE_FORMER.DROPOUT,
-            dim_feedforward=model.ONE_FORMER.DIM_FEEDFORWARD,
-            pre_norm=model.ONE_FORMER.PRE_NORM,
-            enforce_input_proj=model.ONE_FORMER.ENFORCE_INPUT_PROJ,
-            query_dec_layers=model.ONE_FORMER.CLASS_DEC_LAYERS,
-            common_stride=model.SEM_SEG_HEAD.COMMON_STRIDE,
-            id2label=id2label,
-            label2id=label2id,
-        )
-
-        return config
-
-
-class OriginalOneFormerConfigToProcessorConverter:
-    def __call__(self, original_config: object, model_repo: str) -> OneFormerProcessor:
-        model = original_config.MODEL
-        model_input = original_config.INPUT
-        dataset_catalog = MetadataCatalog.get(original_config.DATASETS.TEST_PANOPTIC[0])
-
-        if "ade20k" in model_repo:
-            class_info_file = "ade20k_panoptic.json"
-        elif "coco" in model_repo:
-            class_info_file = "coco_panoptic.json"
-        elif "cityscapes" in model_repo:
-            class_info_file = "cityscapes_panoptic.json"
-        else:
-            raise ValueError("Invalid Dataset!")
-
-        image_processor = OneFormerImageProcessor(
-            image_mean=(torch.tensor(model.PIXEL_MEAN) / 255).tolist(),
-            image_std=(torch.tensor(model.PIXEL_STD) / 255).tolist(),
-            size=model_input.MIN_SIZE_TEST,
-            max_size=model_input.MAX_SIZE_TEST,
-            num_labels=model.SEM_SEG_HEAD.NUM_CLASSES,
-            ignore_index=dataset_catalog.ignore_label,
-            class_info_file=class_info_file,
-        )
-
-        tokenizer = CLIPTokenizer.from_pretrained(model_repo)
-
-        return OneFormerProcessor(
-            image_processor=image_processor,
-            tokenizer=tokenizer,
-            task_seq_length=original_config.INPUT.TASK_SEQ_LEN,
-            max_seq_length=original_config.INPUT.MAX_SEQ_LEN,
-        )
-
-
-class OriginalOneFormerCheckpointToOursConverter:
-    def __init__(self, original_model: nn.Module, config: OneFormerConfig):
-        self.original_model = original_model
-        self.config = config
-
-    def pop_all(self, renamed_keys: List[Tuple[str, str]], dst_state_dict: StateDict, src_state_dict: StateDict):
-        for src_key, dst_key in renamed_keys:
-            dst_state_dict[dst_key] = src_state_dict.pop(src_key)
-
-    # Swin Backbone
-    def replace_swin_backbone(self, dst_state_dict: StateDict, src_state_dict: StateDict, config: OneFormerConfig):
-        dst_prefix: str = "pixel_level_module.encoder"
-        src_prefix: str = "backbone"
-
-        renamed_keys = [
-            (
-                f"{src_prefix}.patch_embed.proj.weight",
-                f"{dst_prefix}.embeddings.patch_embeddings.projection.weight",
-            ),
-            (f"{src_prefix}.patch_embed.proj.bias", f"{dst_prefix}.embeddings.patch_embeddings.projection.bias"),
-            (f"{src_prefix}.patch_embed.norm.weight", f"{dst_prefix}.embeddings.norm.weight"),
-            (f"{src_prefix}.patch_embed.norm.bias", f"{dst_prefix}.embeddings.norm.bias"),
-        ]
-        num_layers = len(config.backbone_config.depths)
-        for layer_idx in range(num_layers):
-            for block_idx in range(config.backbone_config.depths[layer_idx]):
-                renamed_keys.extend(
-                    [  # src, dst
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm1.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_before.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm1.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_before.bias",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.relative_position_bias_table",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.relative_position_bias_table",
-                        ),
-                    ]
-                )
-                # now we need to handle the attentions
-                # read in weights + bias of input projection layer of cross-attention
-
-                src_att_weight = src_state_dict[f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.weight"]
-                src_att_bias = src_state_dict[f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.bias"]
-
-                size = src_att_weight.shape[0]
-                offset = size // 3
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.query.weight"
-                ] = src_att_weight[:offset, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.query.bias"
-                ] = src_att_bias[:offset]
-
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.key.weight"
-                ] = src_att_weight[offset : offset * 2, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.key.bias"
-                ] = src_att_bias[offset : offset * 2]
-
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.value.weight"
-                ] = src_att_weight[-offset:, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.value.bias"
-                ] = src_att_bias[-offset:]
-
-                # let's pop them
-                src_state_dict.pop(f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.weight")
-                src_state_dict.pop(f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.qkv.bias")
-                # proj
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.proj.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.output.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.proj.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.output.dense.bias",
-                        ),
-                    ]
-                )
-
-                # second norm
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm2.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_after.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.norm2.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.layernorm_after.bias",
-                        ),
-                    ]
-                )
-
-                # mlp
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc1.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.intermediate.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc1.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.intermediate.dense.bias",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc2.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.output.dense.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.mlp.fc2.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.output.dense.bias",
-                        ),
-                    ]
-                )
-
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.blocks.{block_idx}.attn.relative_position_index",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.blocks.{block_idx}.attention.self.relative_position_index",
-                        )
-                    ]
-                )
-
-            if layer_idx < num_layers - 1:
-                # patch merging
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.reduction.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.downsample.reduction.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.norm.weight",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.downsample.norm.weight",
-                        ),
-                        (
-                            f"{src_prefix}.layers.{layer_idx}.downsample.norm.bias",
-                            f"{dst_prefix}.encoder.layers.{layer_idx}.downsample.norm.bias",
-                        ),
-                    ]
-                )
-
-            # hidden states norms
-            renamed_keys.extend(
-                [
-                    (
-                        f"{src_prefix}.norm{layer_idx}.weight",
-                        f"{dst_prefix}.hidden_states_norms.stage{layer_idx + 1}.weight",
-                    ),
-                    (
-                        f"{src_prefix}.norm{layer_idx}.bias",
-                        f"{dst_prefix}.hidden_states_norms.stage{layer_idx + 1}.bias",
-                    ),
-                ]
-            )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    # Dinat Backbone
-    def replace_dinat_backbone(self, dst_state_dict: StateDict, src_state_dict: StateDict, config: OneFormerConfig):
-        dst_prefix: str = "pixel_level_module.encoder"
-        src_prefix: str = "backbone"
-
-        def rename_keys_for_weight_bias(src_prefix: str, dst_prefix: str):
-            return [
-                (f"{src_prefix}.weight", f"{dst_prefix}.weight"),
-                (f"{src_prefix}.bias", f"{dst_prefix}.bias"),
-            ]
-
-        renamed_keys = rename_keys_for_weight_bias(f"{src_prefix}.patch_embed.norm", f"{dst_prefix}.embeddings.norm")
-
-        for i in range(2):
-            renamed_keys.extend(
-                rename_keys_for_weight_bias(
-                    f"{src_prefix}.patch_embed.proj.{i}",
-                    f"{dst_prefix}.embeddings.patch_embeddings.projection.{i}",
-                )
-            )
-
-        num_layers = len(config.backbone_config.depths)
-        for layer_idx in range(num_layers):
-            for block_idx in range(config.backbone_config.depths[layer_idx]):
-                renamed_keys.extend(
-                    rename_keys_for_weight_bias(
-                        f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.norm1",
-                        f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.layernorm_before",
-                    )
-                )
-
-                renamed_keys.extend(
-                    rename_keys_for_weight_bias(
-                        f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.norm2",
-                        f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.layernorm_after",
-                    )
-                )
-
-                renamed_keys.extend(
-                    [  # src, dst
-                        (
-                            f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.attn.rpb",
-                            f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.attention.self.rpb",
-                        ),
-                    ]
-                )
-                # now we need to handle the attentions
-                # read in weights + bias of input projection layer of cross-attention
-
-                src_att_weight = src_state_dict[f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.attn.qkv.weight"]
-                src_att_bias = src_state_dict[f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.attn.qkv.bias"]
-
-                size = src_att_weight.shape[0]
-                offset = size // 3
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.attention.self.query.weight"
-                ] = src_att_weight[:offset, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.attention.self.query.bias"
-                ] = src_att_bias[:offset]
-
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.attention.self.key.weight"
-                ] = src_att_weight[offset : offset * 2, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.attention.self.key.bias"
-                ] = src_att_bias[offset : offset * 2]
-
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.attention.self.value.weight"
-                ] = src_att_weight[-offset:, :]
-                dst_state_dict[
-                    f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.attention.self.value.bias"
-                ] = src_att_bias[-offset:]
-
-                # let's pop them
-                src_state_dict.pop(f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.attn.qkv.weight")
-                src_state_dict.pop(f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.attn.qkv.bias")
-                # proj
-
-                renamed_keys.extend(
-                    rename_keys_for_weight_bias(
-                        f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.attn.proj",
-                        f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.attention.output.dense",
-                    )
-                )
-
-                # mlp
-                renamed_keys.extend(
-                    rename_keys_for_weight_bias(
-                        f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.mlp.fc1",
-                        f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.intermediate.dense",
-                    )
-                )
-
-                renamed_keys.extend(
-                    rename_keys_for_weight_bias(
-                        f"{src_prefix}.levels.{layer_idx}.blocks.{block_idx}.mlp.fc2",
-                        f"{dst_prefix}.encoder.levels.{layer_idx}.layers.{block_idx}.output.dense",
-                    )
-                )
-
-            if layer_idx < num_layers - 1:
-                # patch merging
-                renamed_keys.extend(
-                    [
-                        (
-                            f"{src_prefix}.levels.{layer_idx}.downsample.reduction.weight",
-                            f"{dst_prefix}.encoder.levels.{layer_idx}.downsample.reduction.weight",
-                        ),
-                        (
-                            f"{src_prefix}.levels.{layer_idx}.downsample.norm.weight",
-                            f"{dst_prefix}.encoder.levels.{layer_idx}.downsample.norm.weight",
-                        ),
-                        (
-                            f"{src_prefix}.levels.{layer_idx}.downsample.norm.bias",
-                            f"{dst_prefix}.encoder.levels.{layer_idx}.downsample.norm.bias",
-                        ),
-                    ]
-                )
-
-            # hidden states norms
-            renamed_keys.extend(
-                [
-                    (
-                        f"{src_prefix}.norm{layer_idx}.weight",
-                        f"{dst_prefix}.hidden_states_norms.stage{layer_idx + 1}.weight",
-                    ),
-                    (
-                        f"{src_prefix}.norm{layer_idx}.bias",
-                        f"{dst_prefix}.hidden_states_norms.stage{layer_idx + 1}.bias",
-                    ),
-                ]
-            )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    # Backbone + Pixel Decoder
-    def replace_pixel_module(self, dst_state_dict: StateDict, src_state_dict: StateDict, is_swin: bool):
-        dst_prefix: str = "pixel_level_module.decoder"
-        src_prefix: str = "sem_seg_head.pixel_decoder"
-
-        if is_swin:
-            self.replace_swin_backbone(dst_state_dict, src_state_dict, self.config)
-        else:
-            self.replace_dinat_backbone(dst_state_dict, src_state_dict, self.config)
-
-        def rename_keys_for_weight_bias(src_prefix: str, dst_prefix: str):
-            return [
-                (f"{src_prefix}.weight", f"{dst_prefix}.weight"),
-                (f"{src_prefix}.bias", f"{dst_prefix}.bias"),
-            ]
-
-        def rename_keys_for_self_attn(src_prefix: str, dst_prefix: str):
-            self_attn_keys = []
-            self_attn_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.attention_weights", f"{dst_prefix}.attention_weights")
-            )
-            self_attn_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.output_proj", f"{dst_prefix}.output_proj")
-            )
-            self_attn_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.sampling_offsets", f"{dst_prefix}.sampling_offsets")
-            )
-            self_attn_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.value_proj", f"{dst_prefix}.value_proj"))
-
-            return self_attn_keys
-
-        def rename_keys_for_encoder_layer(src_prefix: str, dst_prefix: str):
-            encoder_keys = []
-            encoder_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.linear1", f"{dst_prefix}.fc1"))
-            encoder_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.linear2", f"{dst_prefix}.fc2"))
-            encoder_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.norm1", f"{dst_prefix}.self_attn_layer_norm")
-            )
-            encoder_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.norm2", f"{dst_prefix}.final_layer_norm"))
-            encoder_keys.extend(rename_keys_for_self_attn(f"{src_prefix}.self_attn", f"{dst_prefix}.self_attn"))
-
-            return encoder_keys
-
-        # convolution layer for final features
-        renamed_keys = [
-            (f"{src_prefix}.adapter_1.weight", f"{dst_prefix}.adapter_1.0.weight"),
-            (f"{src_prefix}.adapter_1.norm.weight", f"{dst_prefix}.adapter_1.1.weight"),
-            (f"{src_prefix}.adapter_1.norm.bias", f"{dst_prefix}.adapter_1.1.bias"),
-        ]
-
-        renamed_keys.extend(
-            [
-                (f"{src_prefix}.layer_1.weight", f"{dst_prefix}.layer_1.0.weight"),
-                (f"{src_prefix}.layer_1.norm.weight", f"{dst_prefix}.layer_1.1.weight"),
-                (f"{src_prefix}.layer_1.norm.bias", f"{dst_prefix}.layer_1.1.bias"),
-            ]
-        )
-
-        # proj layers
-        for i in range(3):
-            for j in range(2):
-                renamed_keys.extend(
-                    [
-                        (f"{src_prefix}.input_proj.{i}.{j}.weight", f"{dst_prefix}.input_projections.{i}.{j}.weight"),
-                        (f"{src_prefix}.input_proj.{i}.{j}.bias", f"{dst_prefix}.input_projections.{i}.{j}.bias"),
-                    ]
-                )
-
-        renamed_keys.extend([(f"{src_prefix}.transformer.level_embed", f"{dst_prefix}.level_embed")])
-
-        # layers
-        for layer_idx in range(self.config.encoder_layers):
-            renamed_keys.extend(
-                rename_keys_for_encoder_layer(
-                    f"{src_prefix}.transformer.encoder.layers.{layer_idx}", f"{dst_prefix}.encoder.layers.{layer_idx}"
-                )
-            )
-
-        # proj
-        renamed_keys.extend(
-            [
-                (f"{src_prefix}.mask_features.weight", f"{dst_prefix}.mask_projection.weight"),
-                (f"{src_prefix}.mask_features.bias", f"{dst_prefix}.mask_projection.bias"),
-            ]
-        )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    # Transformer Decoder
-    def replace_keys_qkv_transformer_decoder(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module.decoder.layers"
-        src_prefix: str = "sem_seg_head.predictor"
-        for i in range(self.config.decoder_layers - 1):
-            # read in weights + bias of input projection layer of self-attention
-            in_proj_weight = src_state_dict.pop(
-                f"{src_prefix}.transformer_self_attention_layers.{i}.self_attn.in_proj_weight"
-            )
-            in_proj_bias = src_state_dict.pop(
-                f"{src_prefix}.transformer_self_attention_layers.{i}.self_attn.in_proj_bias"
-            )
-            # next, add query, keys and values (in that order) to the state dict
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.self_attn.q_proj.bias"] = in_proj_bias[:256]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-            dst_state_dict[f"{dst_prefix}.{i}.self_attn.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-
-    def replace_transformer_module(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "transformer_module"
-        src_prefix: str = "sem_seg_head.predictor"
-
-        def rename_keys_for_weight_bias(src_prefix: str, dst_prefix: str):
-            return [
-                (f"{src_prefix}.weight", f"{dst_prefix}.weight"),
-                (f"{src_prefix}.bias", f"{dst_prefix}.bias"),
-            ]
-
-        def rename_keys_for_attn(src_prefix: str, dst_prefix: str):
-            attn_keys = [
-                (f"{src_prefix}.in_proj_bias", f"{dst_prefix}.in_proj_bias"),
-                (f"{src_prefix}.in_proj_weight", f"{dst_prefix}.in_proj_weight"),
-            ]
-            attn_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.out_proj", f"{dst_prefix}.out_proj"))
-
-            return attn_keys
-
-        def rename_keys_for_self_attn(src_prefix: str, dst_prefix: str):
-            attn_keys = []
-            attn_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.out_proj", f"{dst_prefix}.out_proj"))
-
-            return attn_keys
-
-        def rename_keys_for_query_transformer_layer(src_prefix: str, dst_prefix: str):
-            query_transformer_layer_keys = []
-
-            query_transformer_layer_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.linear1", f"{dst_prefix}.linear1")
-            )
-            query_transformer_layer_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.linear2", f"{dst_prefix}.linear2")
-            )
-            query_transformer_layer_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.norm1", f"{dst_prefix}.norm1")
-            )
-            query_transformer_layer_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.norm2", f"{dst_prefix}.norm2")
-            )
-            query_transformer_layer_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.norm3", f"{dst_prefix}.norm3")
-            )
-
-            query_transformer_layer_keys.extend(
-                rename_keys_for_attn(f"{src_prefix}.self_attn", f"{dst_prefix}.self_attn")
-            )
-
-            query_transformer_layer_keys.extend(
-                rename_keys_for_attn(f"{src_prefix}.multihead_attn", f"{dst_prefix}.multihead_attn")
-            )
-
-            return query_transformer_layer_keys
-
-        def rename_keys_for_cross_attn_layer(src_prefix: str, dst_prefix: str):
-            cross_attn_layer_keys = []
-
-            cross_attn_layer_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.norm", f"{dst_prefix}.norm"))
-            cross_attn_layer_keys.extend(
-                rename_keys_for_attn(f"{src_prefix}.multihead_attn", f"{dst_prefix}.multihead_attn")
-            )
-
-            return cross_attn_layer_keys
-
-        def rename_keys_for_self_attn_layer(src_prefix: str, dst_prefix: str):
-            self_attn_layer_keys = []
-
-            self_attn_layer_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.norm", f"{dst_prefix}.norm"))
-            self_attn_layer_keys.extend(
-                rename_keys_for_self_attn(f"{src_prefix}.self_attn", f"{dst_prefix}.self_attn")
-            )
-
-            return self_attn_layer_keys
-
-        def rename_keys_for_ffn_layer(src_prefix: str, dst_prefix: str):
-            ffn_layer_keys = []
-
-            ffn_layer_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.linear1", f"{dst_prefix}.linear1"))
-            ffn_layer_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.linear2", f"{dst_prefix}.linear2"))
-            ffn_layer_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.norm", f"{dst_prefix}.norm"))
-
-            return ffn_layer_keys
-
-        def rename_keys_for_transformer_decoder_layer(src_prefix: str, dst_prefix: str, idx: int):
-            transformer_decoder_layer_keys = []
-
-            transformer_decoder_layer_keys.extend(
-                rename_keys_for_cross_attn_layer(
-                    f"{src_prefix}.transformer_cross_attention_layers.{idx}", f"{dst_prefix}.{idx}.cross_attn"
-                )
-            )
-
-            transformer_decoder_layer_keys.extend(
-                rename_keys_for_self_attn_layer(
-                    f"{src_prefix}.transformer_self_attention_layers.{idx}", f"{dst_prefix}.{idx}.self_attn"
-                )
-            )
-
-            transformer_decoder_layer_keys.extend(
-                rename_keys_for_ffn_layer(f"{src_prefix}.transformer_ffn_layers.{idx}", f"{dst_prefix}.{idx}.ffn")
-            )
-
-            return transformer_decoder_layer_keys
-
-        # positional embedding for object queries
-        renamed_keys = [
-            (f"{src_prefix}.query_embed.weight", f"{dst_prefix}.queries_embedder.weight"),
-            (f"{src_prefix}.level_embed.weight", f"{dst_prefix}.level_embed.weight"),
-        ]
-
-        # norm
-        renamed_keys.extend(
-            rename_keys_for_weight_bias(f"{src_prefix}.decoder_norm", f"{dst_prefix}.decoder.decoder_norm")
-        )
-
-        # proj
-        renamed_keys.extend(
-            rename_keys_for_weight_bias(
-                f"{src_prefix}.class_input_proj", f"{dst_prefix}.decoder.query_input_projection"
-            )
-        )
-
-        renamed_keys.extend(
-            rename_keys_for_weight_bias(f"{src_prefix}.class_embed", f"{dst_prefix}.decoder.class_embed")
-        )
-
-        for i in range(3):
-            renamed_keys.extend(
-                rename_keys_for_weight_bias(
-                    f"{src_prefix}.mask_embed.layers.{i}", f"{dst_prefix}.decoder.mask_embed.layers.{i}.0"
-                )
-            )
-
-        # norm
-        renamed_keys.extend(
-            rename_keys_for_weight_bias(
-                f"{src_prefix}.class_transformer.decoder.norm", f"{dst_prefix}.decoder.query_transformer.decoder.norm"
-            )
-        )
-
-        # transformer to update queries with task tokens
-        for i in range(self.config.query_dec_layers):
-            renamed_keys.extend(
-                rename_keys_for_query_transformer_layer(
-                    f"{src_prefix}.class_transformer.decoder.layers.{i}",
-                    f"{dst_prefix}.decoder.query_transformer.decoder.layers.{i}",
-                )
-            )
-
-        # decoder layers
-        for i in range(self.config.decoder_layers - 1):
-            renamed_keys.extend(
-                rename_keys_for_transformer_decoder_layer(
-                    f"{src_prefix}",
-                    f"{dst_prefix}.decoder.layers",
-                    i,
-                )
-            )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-        self.replace_keys_qkv_transformer_decoder(dst_state_dict, src_state_dict)
-
-    def replace_task_mlp(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "task_encoder"
-        src_prefix: str = "task_mlp"
-
-        def rename_keys_for_weight_bias(src_prefix: str, dst_prefix: str):
-            return [
-                (f"{src_prefix}.weight", f"{dst_prefix}.weight"),
-                (f"{src_prefix}.bias", f"{dst_prefix}.bias"),
-            ]
-
-        renamed_keys = []
-
-        for i in range(2):
-            renamed_keys.extend(
-                rename_keys_for_weight_bias(f"{src_prefix}.layers.{i}", f"{dst_prefix}.task_mlp.layers.{i}.0")
-            )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def replace_text_projector(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "text_mapper.text_projector"
-        src_prefix: str = "text_projector"
-
-        def rename_keys_for_weight_bias(src_prefix: str, dst_prefix: str):
-            return [
-                (f"{src_prefix}.weight", f"{dst_prefix}.weight"),
-                (f"{src_prefix}.bias", f"{dst_prefix}.bias"),
-            ]
-
-        renamed_keys = []
-
-        for i in range(self.config.text_encoder_config["text_encoder_proj_layers"]):
-            renamed_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.layers.{i}", f"{dst_prefix}.{i}.0"))
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def replace_text_mapper(self, dst_state_dict: StateDict, src_state_dict: StateDict):
-        dst_prefix: str = "text_mapper.text_encoder"
-        src_prefix: str = "text_encoder"
-
-        self.replace_text_projector(dst_state_dict, src_state_dict)
-
-        def rename_keys_for_weight_bias(src_prefix: str, dst_prefix: str):
-            return [
-                (f"{src_prefix}.weight", f"{dst_prefix}.weight"),
-                (f"{src_prefix}.bias", f"{dst_prefix}.bias"),
-            ]
-
-        def rename_keys_for_attn(src_prefix: str, dst_prefix: str):
-            attn_keys = [
-                (f"{src_prefix}.in_proj_bias", f"{dst_prefix}.in_proj_bias"),
-                (f"{src_prefix}.in_proj_weight", f"{dst_prefix}.in_proj_weight"),
-            ]
-            attn_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.out_proj", f"{dst_prefix}.out_proj"))
-
-            return attn_keys
-
-        def rename_keys_for_layer(src_prefix: str, dst_prefix: str):
-            resblock_keys = []
-
-            resblock_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.mlp.c_fc", f"{dst_prefix}.mlp.fc1"))
-            resblock_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.mlp.c_proj", f"{dst_prefix}.mlp.fc2"))
-            resblock_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.ln_1", f"{dst_prefix}.layer_norm1"))
-            resblock_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.ln_2", f"{dst_prefix}.layer_norm2"))
-            resblock_keys.extend(rename_keys_for_attn(f"{src_prefix}.attn", f"{dst_prefix}.self_attn"))
-
-            return resblock_keys
-
-        renamed_keys = [
-            ("prompt_ctx.weight", "text_mapper.prompt_ctx.weight"),
-        ]
-
-        renamed_keys.extend(
-            [
-                (f"{src_prefix}.positional_embedding", f"{dst_prefix}.positional_embedding"),
-                (f"{src_prefix}.token_embedding.weight", f"{dst_prefix}.token_embedding.weight"),
-            ]
-        )
-
-        renamed_keys.extend(rename_keys_for_weight_bias(f"{src_prefix}.ln_final", f"{dst_prefix}.ln_final"))
-
-        for i in range(self.config.text_encoder_config["text_encoder_num_layers"]):
-            renamed_keys.extend(
-                rename_keys_for_layer(
-                    f"{src_prefix}.transformer.resblocks.{i}", f"{dst_prefix}.transformer.layers.{i}"
-                )
-            )
-
-        self.pop_all(renamed_keys, dst_state_dict, src_state_dict)
-
-    def convert(self, oneformer: OneFormerModel, is_swin: bool) -> OneFormerModel:
-        dst_state_dict = TrackedStateDict(oneformer.state_dict())
-        src_state_dict = self.original_model.state_dict()
-
-        self.replace_pixel_module(dst_state_dict, src_state_dict, is_swin)
-        self.replace_transformer_module(dst_state_dict, src_state_dict)
-        self.replace_task_mlp(dst_state_dict, src_state_dict)
-        if self.config.is_training:
-            self.replace_text_mapper(dst_state_dict, src_state_dict)
-
-        logger.info(f"Missed keys are {pformat(dst_state_dict.diff())}")
-        logger.info(f"Not copied keys are {pformat(src_state_dict.keys())}")
-        logger.info("🙌 Done")
-
-        oneformer.load_state_dict(dst_state_dict)
-
-        return oneformer
-
-    @staticmethod
-    def using_dirs(checkpoints_dir: Path, config_dir: Path) -> Iterator[Tuple[object, Path, Path]]:
-        checkpoints: List[Path] = checkpoints_dir.glob("**/*.pth")
-
-        for checkpoint in checkpoints:
-            logger.info(f"💪 Converting {checkpoint.stem}")
-            # find associated config file
-            config: Path = config_dir / f"{checkpoint.stem}.yaml"
-
-            yield config, checkpoint
-
-
-def post_process_sem_seg_output(outputs: OneFormerForUniversalSegmentationOutput, target_size: Tuple[int, int]):
-    # class_queries_logits has shape [BATCH, QUERIES, CLASSES + 1]
-    class_queries_logits = outputs.class_queries_logits
-    # masks_queries_logits has shape [BATCH, QUERIES, HEIGHT, WIDTH]
-    masks_queries_logits = outputs.masks_queries_logits
-    if target_size is not None:
-        masks_queries_logits = torch.nn.functional.interpolate(
-            masks_queries_logits,
-            size=target_size,
-            mode="bilinear",
-            align_corners=False,
-        )
-    # remove the null class `[..., :-1]`
-    masks_classes = class_queries_logits.softmax(dim=-1)[..., :-1]
-    # mask probs has shape [BATCH, QUERIES, HEIGHT, WIDTH]
-    masks_probs = masks_queries_logits.sigmoid()
-    # now we want to sum over the queries,
-    # $ out_{c,h,w} =  \sum_q p_{q,c} * m_{q,h,w} $
-    # where $ softmax(p) \in R^{q, c} $ is the mask classes
-    # and $ sigmoid(m) \in R^{q, h, w}$ is the mask probabilities
-    # b(atch)q(uery)c(lasses), b(atch)q(uery)h(eight)w(idth)
-    segmentation = torch.einsum("bqc, bqhw -> bchw", masks_classes, masks_probs)
-
-    return segmentation
-
-
-def test(
-    original_model,
-    our_model: OneFormerForUniversalSegmentation,
-    processor: OneFormerProcessor,
-    model_repo: str,
-):
-    def _preprocess_text(text_list=None, max_length=77):
-        if text_list is None:
-            raise ValueError("tokens cannot be None.")
-
-        tokens = tokenizer(text_list, padding="max_length", max_length=max_length, truncation=True)
-
-        attention_masks, input_ids = tokens["attention_mask"], tokens["input_ids"]
-
-        token_inputs = []
-        for attn_mask, input_id in zip(attention_masks, input_ids):
-            token = torch.tensor(attn_mask) * torch.tensor(input_id)
-            token_inputs.append(token.unsqueeze(0))
-
-        token_inputs = torch.cat(token_inputs, dim=0)
-        return token_inputs
-
-    with torch.no_grad():
-        tokenizer = CLIPTokenizer.from_pretrained(model_repo)
-        original_model = original_model.eval()
-        our_model = our_model.eval()
-
-        im = prepare_img()
-
-        tr = T.Compose(
-            [
-                T.Resize((640, 640)),
-                T.ToTensor(),
-                T.Normalize(
-                    mean=torch.tensor([123.675, 116.280, 103.530]) / 255.0,
-                    std=torch.tensor([58.395, 57.120, 57.375]) / 255.0,
-                ),
-            ],
-        )
-
-        x = tr(im).unsqueeze(0)
-
-        task_input = ["the task is semantic"]
-        task_token = _preprocess_text(task_input, max_length=processor.task_seq_length)
-
-        original_model_backbone_features = original_model.backbone(x.clone())
-
-        our_model_output: OneFormerModelOutput = our_model.model(x.clone(), task_token, output_hidden_states=True)
-
-        for original_model_feature, our_model_feature in zip(
-            original_model_backbone_features.values(), our_model_output.encoder_hidden_states
-        ):
-            assert torch.allclose(original_model_feature, our_model_feature, atol=3e-3), (
-                "The backbone features are not the same."
-            )
-        mask_features, _, multi_scale_features, _, _ = original_model.sem_seg_head.pixel_decoder.forward_features(
-            original_model_backbone_features
-        )
-
-        original_pixel_decoder_features = []
-        original_pixel_decoder_features.append(mask_features)
-        for i in range(len(multi_scale_features)):
-            original_pixel_decoder_features.append(multi_scale_features[i])
-
-        for original_model_feature, our_model_feature in zip(
-            original_pixel_decoder_features, our_model_output.pixel_decoder_hidden_states
-        ):
-            assert torch.allclose(original_model_feature, our_model_feature, atol=3e-4), (
-                "The pixel decoder feature are not the same"
-            )
-
-        tr_complete = T.Compose(
-            [
-                T.Resize((640, 640)),
-                T.ToTensor(),
-            ],
-        )
-
-        y = (tr_complete(im) * 255.0).to(torch.int).float()
-
-        # let's test the full model
-        original_model_out = original_model([{"image": y.clone(), "task": "The task is semantic"}])
-
-        original_segmentation = original_model_out[0]["sem_seg"]
-
-        our_model_out: OneFormerForUniversalSegmentationOutput = our_model(
-            x.clone(), task_token, output_hidden_states=True
-        )
-
-        our_segmentation = post_process_sem_seg_output(our_model_out, target_size=(640, 640))[0]
-
-        assert torch.allclose(original_segmentation, our_segmentation, atol=1e-3), (
-            "The segmentation image is not the same."
-        )
-
-        logger.info("✅ Test passed!")
-
-
-def get_name(checkpoint_file: Path):
-    model_name_raw: str = checkpoint_file.stem
-
-    backbone = "swin" if "swin" in model_name_raw else "dinat"
-    dataset = ""
-    if "coco" in model_name_raw:
-        dataset = "coco"
-    elif "ade20k" in model_name_raw:
-        dataset = "ade20k"
-    elif "cityscapes" in model_name_raw:
-        dataset = "cityscapes"
-    else:
-        raise ValueError(
-            f"{model_name_raw} must be wrong since we didn't find 'coco' or 'ade20k' or 'cityscapes' in it "
-        )
-
-    backbone_types = ["tiny", "large"]
-
-    backbone_type = list(filter(lambda x: x in model_name_raw, backbone_types))[0]
-
-    model_name = f"oneformer_{dataset}_{backbone}_{backbone_type}"
-
-    return model_name
-
-
-if __name__ == "__main__":
-    parser = ArgumentParser(
-        description=(
-            "Command line to convert the original oneformer models (with swin backbone) to transformers"
-            " implementation."
-        )
-    )
-
-    parser.add_argument(
-        "--checkpoints_dir",
-        type=Path,
-        help=(
-            "A directory containing the model's checkpoints. The directory has to have the following structure:"
-            " structure: <DIR_NAME>/<DATASET_NAME>/<CONFIG_NAME>.pth; where <CONFIG_NAME> name must follow the"
-            " following nomenclature nomenclature: oneformer_<DATASET_NAME>_<BACKBONE>_<BACKBONE_TYPE>"
-        ),
-    )
-    parser.add_argument(
-        "--configs_dir",
-        type=Path,
-        help=(
-            "A directory containing the model's configs, see detectron2 doc. The directory has to have the following"
-            " structure: <DIR_NAME>/<DATASET_NAME>/<CONFIG_NAME>.yaml; where <CONFIG_NAME> name must follow the"
-            " following nomenclature nomenclature: oneformer_<DATASET_NAME>_<BACKBONE>_<BACKBONE_TYPE>"
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        required=True,
-        type=Path,
-        help="Path to the folder to output PyTorch models.",
-    )
-    parser.add_argument(
-        "--oneformer_dir",
-        required=True,
-        type=Path,
-        help=(
-            "A path to OneFormer's original implementation directory. You can download from here: "
-            "https://github.com/SHI-Labs/OneFormer"
-        ),
-    )
-
-    args = parser.parse_args()
-
-    checkpoints_dir: Path = args.checkpoints_dir
-    config_dir: Path = args.configs_dir
-    save_directory: Path = args.pytorch_dump_folder_path
-    oneformer_dir: Path = args.oneformer_dir
-    # append the path to the parents to oneformer dir
-    sys.path.append(str(oneformer_dir.parent))
-    # and import what's needed
-    from OneFormer.oneformer import add_common_config, add_dinat_config, add_oneformer_config, add_swin_config
-    from OneFormer.oneformer.oneformer_model import OneFormer as OriginalOneFormer
-
-    if not save_directory.exists():
-        save_directory.mkdir(parents=True)
-
-    for config_file, checkpoint_file in OriginalOneFormerCheckpointToOursConverter.using_dirs(
-        checkpoints_dir, config_dir
-    ):
-        processor = OriginalOneFormerConfigToProcessorConverter()(
-            setup_cfg(Args(config_file=config_file)), os.path.join("shi-labs", config_file.stem)
-        )
-
-        original_config = setup_cfg(Args(config_file=config_file))
-        oneformer_kwargs = OriginalOneFormer.from_config(original_config)
-
-        original_model = OriginalOneFormer(**oneformer_kwargs).eval()
-
-        DetectionCheckpointer(original_model).load(str(checkpoint_file))
-
-        is_swin = "swin" in config_file.stem
-
-        config: OneFormerConfig = OriginalOneFormerConfigToOursConverter()(original_config, is_swin)
-
-        oneformer = OneFormerModel(config=config).eval()
-
-        converter = OriginalOneFormerCheckpointToOursConverter(original_model, config)
-
-        oneformer = converter.convert(oneformer, is_swin)
-
-        oneformer_for_universal_segmentation = OneFormerForUniversalSegmentation(config=config).eval()
-
-        oneformer_for_universal_segmentation.model = oneformer
-
-        test(
-            original_model,
-            oneformer_for_universal_segmentation,
-            processor,
-            os.path.join("shi-labs", config_file.stem),
-        )
-
-        model_name = get_name(checkpoint_file)
-        logger.info(f"🪄 Saving {model_name}")
-
-        processor.save_pretrained(save_directory / model_name)
-        oneformer_for_universal_segmentation.save_pretrained(save_directory / model_name)
-
-        processor.push_to_hub(
-            repo_id=os.path.join("shi-labs", config_file.stem),
-            commit_message="Add configs",
-            use_temp_dir=True,
-        )
-        oneformer_for_universal_segmentation.push_to_hub(
-            repo_id=os.path.join("shi-labs", config_file.stem),
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
diff --git a/src/transformers/models/openai/convert_openai_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/openai/convert_openai_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index 3d5218c20426..000000000000
--- a/src/transformers/models/openai/convert_openai_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert OpenAI GPT checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
-from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_openai_checkpoint_to_pytorch(openai_checkpoint_folder_path, openai_config_file, pytorch_dump_folder_path):
-    # Construct model
-    if openai_config_file == "":
-        config = OpenAIGPTConfig()
-    else:
-        config = OpenAIGPTConfig.from_json_file(openai_config_file)
-    model = OpenAIGPTModel(config)
-
-    # Load weights from numpy
-    load_tf_weights_in_openai_gpt(model, config, openai_checkpoint_folder_path)
-
-    # Save pytorch-model
-    pytorch_weights_dump_path = pytorch_dump_folder_path + "/" + WEIGHTS_NAME
-    pytorch_config_dump_path = pytorch_dump_folder_path + "/" + CONFIG_NAME
-    print(f"Save PyTorch model to {pytorch_weights_dump_path}")
-    torch.save(model.state_dict(), pytorch_weights_dump_path)
-    print(f"Save configuration file to {pytorch_config_dump_path}")
-    with open(pytorch_config_dump_path, "w", encoding="utf-8") as f:
-        f.write(config.to_json_string())
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--openai_checkpoint_folder_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the TensorFlow checkpoint path.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--openai_config_file",
-        default="",
-        type=str,
-        help=(
-            "An optional config json file corresponding to the pre-trained OpenAI model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    args = parser.parse_args()
-    convert_openai_checkpoint_to_pytorch(
-        args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
-    )
diff --git a/src/transformers/models/opt/convert_opt_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/opt/convert_opt_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 486b477f973f..000000000000
--- a/src/transformers/models/opt/convert_opt_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,113 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert OPT checkpoint."""
-
-import argparse
-from pathlib import Path
-
-import torch
-
-from transformers import OPTConfig, OPTModel
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def load_checkpoint(checkpoint_path):
-    """Checkpoint path should end in model.pt"""
-    sd = torch.load(checkpoint_path, map_location="cpu")
-    if "model" in sd.keys():
-        sd = torch.load(checkpoint_path, map_location="cpu")["model"]
-
-    # pop unnecessary weights
-    keys_to_delete = [
-        "decoder.version",
-        "decoder.output_projection.weight",
-    ]
-    for key in keys_to_delete:
-        if key in sd:
-            sd.pop(key)
-
-    keys_to_rename = {
-        "decoder.project_in_dim.weight": "decoder.project_in.weight",
-        "decoder.project_out_dim.weight": "decoder.project_out.weight",
-        "decoder.layer_norm.weight": "decoder.final_layer_norm.weight",
-        "decoder.layer_norm.bias": "decoder.final_layer_norm.bias",
-    }
-    for old_key, new_key in keys_to_rename.items():
-        if old_key in sd:
-            sd[new_key] = sd.pop(old_key)
-
-    keys = list(sd.keys())
-    for key in keys:
-        if ".qkv_proj." in key:
-            value = sd[key]
-            # We split QKV in separate Q,K,V
-
-            q_name = key.replace(".qkv_proj.", ".q_proj.")
-            k_name = key.replace(".qkv_proj.", ".k_proj.")
-            v_name = key.replace(".qkv_proj.", ".v_proj.")
-
-            depth = value.shape[0]
-            assert depth % 3 == 0
-            # `SequeuceParallelTransformerBlock` has QKV weight is separated in K,V,Q despite the naming:
-            # https://cs.github.com/facebookresearch/metaseq/blob/51871bd73cd04c038f239ea2a26db1d7f6b37927/metaseq/modules/sequence_parallel_transformer_layer.py#L97
-            k, v, q = torch.split(value, depth // 3, dim=0)
-
-            sd[q_name] = q
-            sd[k_name] = k
-            sd[v_name] = v
-            del sd[key]
-
-    return sd
-
-
-@torch.no_grad()
-def convert_opt_checkpoint(checkpoint_path, pytorch_dump_folder_path, config=None):
-    """
-    Copy/paste/tweak model's weights to our BERT structure.
-    """
-    state_dict = load_checkpoint(checkpoint_path)
-
-    if config is not None:
-        config = OPTConfig.from_pretrained(config)
-    else:
-        config = OPTConfig()
-
-    model = OPTModel(config).half().eval()
-    model.load_state_dict(state_dict)
-
-    # Check results
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--fairseq_path",
-        type=str,
-        help=(
-            "path to fairseq checkpoint in correct format. You can find all checkpoints in the correct format here:"
-            " https://huggingface.co/models?other=opt_metasq"
-        ),
-    )
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--hf_config", default=None, type=str, help="Define HF config.")
-    args = parser.parse_args()
-    convert_opt_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, config=args.hf_config)
diff --git a/src/transformers/models/owlv2/convert_owlv2_to_hf.py b/src/transformers/models/owlv2/convert_owlv2_to_hf.py
deleted file mode 100644
index ed563b2c5bd0..000000000000
--- a/src/transformers/models/owlv2/convert_owlv2_to_hf.py
+++ /dev/null
@@ -1,422 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert OWLv2 checkpoints from the original repository.
-
-URL: https://github.com/google-research/scenic/tree/main/scenic/projects/owl_vit"""
-
-import argparse
-import collections
-import os
-
-import jax
-import jax.numpy as jnp
-import numpy as np
-import torch
-from flax.training import checkpoints
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    CLIPTokenizer,
-    Owlv2Config,
-    Owlv2ForObjectDetection,
-    Owlv2ImageProcessor,
-    Owlv2Processor,
-    Owlv2TextConfig,
-    Owlv2VisionConfig,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_owlv2_config(model_name):
-    if "large" in model_name:
-        image_size = 1008
-        patch_size = 14
-        vision_hidden_size = 1024
-        vision_intermediate_size = 4096
-        vision_num_hidden_layers = 24
-        vision_num_attention_heads = 16
-        projection_dim = 768
-        text_hidden_size = 768
-        text_intermediate_size = 3072
-        text_num_attention_heads = 12
-        text_num_hidden_layers = 12
-    else:
-        image_size = 960
-        patch_size = 16
-        vision_hidden_size = 768
-        vision_intermediate_size = 3072
-        vision_num_hidden_layers = 12
-        vision_num_attention_heads = 12
-        projection_dim = 512
-        text_hidden_size = 512
-        text_intermediate_size = 2048
-        text_num_attention_heads = 8
-        text_num_hidden_layers = 12
-
-    vision_config = Owlv2VisionConfig(
-        patch_size=patch_size,
-        image_size=image_size,
-        hidden_size=vision_hidden_size,
-        num_hidden_layers=vision_num_hidden_layers,
-        intermediate_size=vision_intermediate_size,
-        num_attention_heads=vision_num_attention_heads,
-    )
-    text_config = Owlv2TextConfig(
-        hidden_size=text_hidden_size,
-        intermediate_size=text_intermediate_size,
-        num_attention_heads=text_num_attention_heads,
-        num_hidden_layers=text_num_hidden_layers,
-    )
-
-    config = Owlv2Config(
-        text_config=text_config.to_dict(),
-        vision_config=vision_config.to_dict(),
-        projection_dim=projection_dim,
-    )
-
-    return config
-
-
-def flatten_nested_dict(params, parent_key="", sep="/"):
-    items = []
-
-    for k, v in params.items():
-        new_key = parent_key + sep + k if parent_key else k
-
-        if isinstance(v, collections.MutableMapping):
-            items.extend(flatten_nested_dict(v, new_key, sep=sep).items())
-        else:
-            items.append((new_key, v))
-    return dict(items)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, model_name):
-    rename_keys = []
-
-    # fmt: off
-    # CLIP vision encoder
-    rename_keys.append(("backbone/clip/visual/class_embedding", "owlv2.vision_model.embeddings.class_embedding"))
-    rename_keys.append(("backbone/clip/visual/conv1/kernel", "owlv2.vision_model.embeddings.patch_embedding.weight"))
-    rename_keys.append(("backbone/clip/visual/positional_embedding", "owlv2.vision_model.embeddings.position_embedding.weight"))
-    rename_keys.append(("backbone/clip/visual/ln_pre/scale", "owlv2.vision_model.pre_layernorm.weight"))
-    rename_keys.append(("backbone/clip/visual/ln_pre/bias", "owlv2.vision_model.pre_layernorm.bias"))
-
-    for i in range(config.vision_config.num_hidden_layers):
-        if "v2" in model_name:
-            rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/ln_0/scale", f"owlv2.vision_model.encoder.layers.{i}.layer_norm1.weight"))
-            rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/ln_0/bias", f"owlv2.vision_model.encoder.layers.{i}.layer_norm1.bias"))
-            rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/ln_1/scale", f"owlv2.vision_model.encoder.layers.{i}.layer_norm2.weight"))
-            rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/ln_1/bias", f"owlv2.vision_model.encoder.layers.{i}.layer_norm2.bias"))
-        else:
-            rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/ln_1/scale", f"owlv2.vision_model.encoder.layers.{i}.layer_norm1.weight"))
-            rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/ln_1/bias", f"owlv2.vision_model.encoder.layers.{i}.layer_norm1.bias"))
-            rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/ln_2/scale", f"owlv2.vision_model.encoder.layers.{i}.layer_norm2.weight"))
-            rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/ln_2/bias", f"owlv2.vision_model.encoder.layers.{i}.layer_norm2.bias"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/mlp/c_fc/kernel", f"owlv2.vision_model.encoder.layers.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/mlp/c_fc/bias", f"owlv2.vision_model.encoder.layers.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/mlp/c_proj/kernel", f"owlv2.vision_model.encoder.layers.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/mlp/c_proj/bias", f"owlv2.vision_model.encoder.layers.{i}.mlp.fc2.bias"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/attn/query/kernel", f"owlv2.vision_model.encoder.layers.{i}.self_attn.q_proj.weight"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/attn/query/bias", f"owlv2.vision_model.encoder.layers.{i}.self_attn.q_proj.bias"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/attn/key/kernel", f"owlv2.vision_model.encoder.layers.{i}.self_attn.k_proj.weight"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/attn/key/bias", f"owlv2.vision_model.encoder.layers.{i}.self_attn.k_proj.bias"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/attn/value/kernel", f"owlv2.vision_model.encoder.layers.{i}.self_attn.v_proj.weight"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/attn/value/bias", f"owlv2.vision_model.encoder.layers.{i}.self_attn.v_proj.bias"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/attn/out/kernel", f"owlv2.vision_model.encoder.layers.{i}.self_attn.out_proj.weight"))
-        rename_keys.append((f"backbone/clip/visual/transformer/resblocks.{i}/attn/out/bias", f"owlv2.vision_model.encoder.layers.{i}.self_attn.out_proj.bias"))
-
-    rename_keys.append(("backbone/clip/visual/ln_post/scale", "owlv2.vision_model.post_layernorm.weight"))
-    rename_keys.append(("backbone/clip/visual/ln_post/bias", "owlv2.vision_model.post_layernorm.bias"))
-
-    # CLIP text encoder
-    rename_keys.append(("backbone/clip/text/token_embedding/embedding", "owlv2.text_model.embeddings.token_embedding.weight"))
-    rename_keys.append(("backbone/clip/text/positional_embedding", "owlv2.text_model.embeddings.position_embedding.weight"))
-
-    for i in range(config.text_config.num_hidden_layers):
-        if "v2" in model_name:
-            rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/ln_0/scale", f"owlv2.text_model.encoder.layers.{i}.layer_norm1.weight"))
-            rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/ln_0/bias", f"owlv2.text_model.encoder.layers.{i}.layer_norm1.bias"))
-            rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/ln_1/scale", f"owlv2.text_model.encoder.layers.{i}.layer_norm2.weight"))
-            rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/ln_1/bias", f"owlv2.text_model.encoder.layers.{i}.layer_norm2.bias"))
-        else:
-            rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/ln_1/scale", f"owlv2.text_model.encoder.layers.{i}.layer_norm1.weight"))
-            rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/ln_1/bias", f"owlv2.text_model.encoder.layers.{i}.layer_norm1.bias"))
-            rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/ln_2/scale", f"owlv2.text_model.encoder.layers.{i}.layer_norm2.weight"))
-            rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/ln_2/bias", f"owlv2.text_model.encoder.layers.{i}.layer_norm2.bias"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/mlp/c_fc/kernel", f"owlv2.text_model.encoder.layers.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/mlp/c_fc/bias", f"owlv2.text_model.encoder.layers.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/mlp/c_proj/kernel", f"owlv2.text_model.encoder.layers.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/mlp/c_proj/bias", f"owlv2.text_model.encoder.layers.{i}.mlp.fc2.bias"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/attn/query/kernel", f"owlv2.text_model.encoder.layers.{i}.self_attn.q_proj.weight"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/attn/query/bias", f"owlv2.text_model.encoder.layers.{i}.self_attn.q_proj.bias"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/attn/key/kernel", f"owlv2.text_model.encoder.layers.{i}.self_attn.k_proj.weight"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/attn/key/bias", f"owlv2.text_model.encoder.layers.{i}.self_attn.k_proj.bias"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/attn/value/kernel", f"owlv2.text_model.encoder.layers.{i}.self_attn.v_proj.weight"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/attn/value/bias", f"owlv2.text_model.encoder.layers.{i}.self_attn.v_proj.bias"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/attn/out/kernel", f"owlv2.text_model.encoder.layers.{i}.self_attn.out_proj.weight"))
-        rename_keys.append((f"backbone/clip/text/transformer/resblocks.{i}/attn/out/bias", f"owlv2.text_model.encoder.layers.{i}.self_attn.out_proj.bias"))
-
-    rename_keys.append(("backbone/clip/text/ln_final/scale", "owlv2.text_model.final_layer_norm.weight"))
-    rename_keys.append(("backbone/clip/text/ln_final/bias", "owlv2.text_model.final_layer_norm.bias"))
-
-    # logit scale
-    rename_keys.append(("backbone/clip/logit_scale", "owlv2.logit_scale"))
-
-    # projection heads
-    rename_keys.append(("backbone/clip/text/text_projection/kernel", "owlv2.text_projection.weight"))
-
-    # class and box heads
-    rename_keys.append(("backbone/merged_class_token/scale", "layer_norm.weight"))
-    rename_keys.append(("backbone/merged_class_token/bias", "layer_norm.bias"))
-    rename_keys.append(("class_head/Dense_0/kernel", "class_head.dense0.weight"))
-    rename_keys.append(("class_head/Dense_0/bias", "class_head.dense0.bias"))
-    rename_keys.append(("class_head/logit_shift/kernel", "class_head.logit_shift.weight"))
-    rename_keys.append(("class_head/logit_scale/kernel", "class_head.logit_scale.weight"))
-    rename_keys.append(("class_head/logit_scale/bias", "class_head.logit_scale.bias"))
-    rename_keys.append(("class_head/logit_shift/bias", "class_head.logit_shift.bias"))
-    rename_keys.append(("obj_box_head/Dense_0/kernel", "box_head.dense0.weight"))
-    rename_keys.append(("obj_box_head/Dense_0/bias", "box_head.dense0.bias"))
-    rename_keys.append(("obj_box_head/Dense_1/kernel", "box_head.dense1.weight"))
-    rename_keys.append(("obj_box_head/Dense_1/bias", "box_head.dense1.bias"))
-    rename_keys.append(("obj_box_head/Dense_2/kernel", "box_head.dense2.weight"))
-    rename_keys.append(("obj_box_head/Dense_2/bias", "box_head.dense2.bias"))
-
-    # objectness head (only for v2)
-    if "v2" in model_name:
-        rename_keys.append(("objectness_head/Dense_0/kernel", "objectness_head.dense0.weight"))
-        rename_keys.append(("objectness_head/Dense_0/bias", "objectness_head.dense0.bias"))
-        rename_keys.append(("objectness_head/Dense_1/kernel", "objectness_head.dense1.weight"))
-        rename_keys.append(("objectness_head/Dense_1/bias", "objectness_head.dense1.bias"))
-        rename_keys.append(("objectness_head/Dense_2/kernel", "objectness_head.dense2.weight"))
-        rename_keys.append(("objectness_head/Dense_2/bias", "objectness_head.dense2.bias"))
-
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_and_reshape_key(dct, old, new, config):
-    val = dct.pop(old)
-
-    if ("out_proj" in new or "v_proj" in new or "k_proj" in new or "q_proj" in new) and "vision" in new:
-        val = val.reshape(-1, config.vision_config.hidden_size)
-    if ("out_proj" in new or "v_proj" in new or "k_proj" in new or "q_proj" in new) and "text" in new:
-        val = val.reshape(-1, config.text_config.hidden_size)
-
-    if "patch_embedding" in new:
-        print("Reshaping patch embedding... for", new)
-        val = val.transpose(3, 2, 0, 1)
-    elif new.endswith("weight") and "position_embedding" not in new and "token_embedding" not in new:
-        val = val.T
-
-    if new.endswith("bias"):
-        val = val.reshape(-1)
-
-    dct[new] = torch.from_numpy(np.array(val))
-
-
-@torch.no_grad()
-def convert_owlv2_checkpoint(model_name, checkpoint_path, pytorch_dump_folder_path, push_to_hub, verify_logits):
-    """
-    Copy/paste/tweak model's weights to our OWL-ViT structure.
-    """
-    config = get_owlv2_config(model_name)
-
-    # see available checkpoints at https://github.com/google-research/scenic/tree/main/scenic/projects/owl_vit#pretrained-checkpoints
-    variables = checkpoints.restore_checkpoint(checkpoint_path, target=None)
-    variables = variables["params"] if "v2" in model_name else variables["optimizer"]["target"]
-    flax_params = jax.tree_util.tree_map(lambda x: x.astype(jnp.float32) if x.dtype == jnp.bfloat16 else x, variables)
-    state_dict = flatten_nested_dict(flax_params)
-
-    # Rename keys
-    rename_keys = create_rename_keys(config, model_name)
-    for src, dest in rename_keys:
-        rename_and_reshape_key(state_dict, src, dest, config)
-
-    # load HuggingFace model
-    model = Owlv2ForObjectDetection(config)
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    assert missing_keys == ["owlv2.visual_projection.weight"]
-    assert unexpected_keys == []
-    model.eval()
-
-    # Initialize image processor
-    size = {"height": config.vision_config.image_size, "width": config.vision_config.image_size}
-    image_processor = Owlv2ImageProcessor(size=size)
-    # Initialize tokenizer
-    tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32", pad_token="!", model_max_length=16)
-    # Initialize processor
-    processor = Owlv2Processor(image_processor=image_processor, tokenizer=tokenizer)
-
-    # Verify pixel_values and input_ids
-    filepath = hf_hub_download(repo_id="nielsr/test-image", filename="owlvit_pixel_values_960.pt", repo_type="dataset")
-    original_pixel_values = torch.load(filepath).permute(0, 3, 1, 2)
-
-    filepath = hf_hub_download(repo_id="nielsr/test-image", filename="owlv2_input_ids.pt", repo_type="dataset")
-    original_input_ids = torch.load(filepath).squeeze()
-
-    filepath = hf_hub_download(repo_id="adirik/OWL-ViT", repo_type="space", filename="assets/astronaut.png")
-    image = Image.open(filepath)
-    texts = [["face", "rocket", "nasa badge", "star-spangled banner"]]
-    inputs = processor(text=texts, images=image, return_tensors="pt")
-
-    if "large" not in model_name:
-        assert torch.allclose(inputs.pixel_values, original_pixel_values.float(), atol=1e-6)
-    assert torch.allclose(inputs.input_ids[:4, :], original_input_ids[:4, :], atol=1e-6)
-
-    with torch.no_grad():
-        outputs = model(**inputs)
-        logits = outputs.logits
-        pred_boxes = outputs.pred_boxes
-        objectness_logits = outputs.objectness_logits
-
-    if verify_logits:
-        if model_name == "owlv2-base-patch16":
-            expected_logits = torch.tensor(
-                [[-10.0043, -9.0226, -8.0433], [-12.4569, -14.0380, -12.6153], [-21.0731, -22.2705, -21.8850]]
-            )
-            expected_boxes = torch.tensor(
-                [[0.0136, 0.0223, 0.0269], [0.0406, 0.0327, 0.0797], [0.0638, 0.1539, 0.1255]]
-            )
-            expected_objectness_logits = torch.tensor(
-                [[-5.6589, -7.7702, -16.3965]],
-            )
-        elif model_name == "owlv2-base-patch16-finetuned":
-            expected_logits = torch.tensor(
-                [[-9.2391, -9.2313, -8.0295], [-14.5498, -16.8450, -14.7166], [-15.1278, -17.3060, -15.7169]],
-            )
-            expected_boxes = torch.tensor(
-                [[0.0103, 0.0094, 0.0207], [0.0483, 0.0729, 0.1013], [0.0629, 0.1396, 0.1313]]
-            )
-            expected_objectness_logits = torch.tensor(
-                [[-6.5234, -13.3788, -14.6627]],
-            )
-        elif model_name == "owlv2-base-patch16-ensemble":
-            expected_logits = torch.tensor(
-                [[-8.6353, -9.5409, -6.6154], [-7.9442, -9.6151, -6.7117], [-12.4593, -15.3332, -12.1048]]
-            )
-            expected_boxes = torch.tensor(
-                [[0.0126, 0.0090, 0.0238], [0.0387, 0.0227, 0.0754], [0.0582, 0.1058, 0.1139]]
-            )
-            expected_objectness_logits = torch.tensor(
-                [[-6.0628, -5.9507, -10.4486]],
-            )
-        elif model_name == "owlv2-large-patch14":
-            expected_logits = torch.tensor(
-                [[-12.6662, -11.8384, -12.1880], [-16.0599, -16.5835, -16.9364], [-21.4957, -26.7038, -25.1313]],
-            )
-            expected_boxes = torch.tensor(
-                [[0.0136, 0.0161, 0.0256], [0.0126, 0.0135, 0.0202], [0.0498, 0.0948, 0.0915]],
-            )
-            expected_objectness_logits = torch.tensor(
-                [[-6.7196, -9.4590, -13.9472]],
-            )
-        elif model_name == "owlv2-large-patch14-finetuned":
-            expected_logits = torch.tensor(
-                [[-9.5413, -9.7130, -7.9762], [-9.5731, -9.7277, -8.2252], [-15.4434, -19.3084, -16.5490]],
-            )
-            expected_boxes = torch.tensor(
-                [[0.0089, 0.0080, 0.0175], [0.0112, 0.0098, 0.0179], [0.0375, 0.0821, 0.0528]],
-            )
-            expected_objectness_logits = torch.tensor(
-                [[-6.2655, -6.5845, -11.3105]],
-            )
-        elif model_name == "owlv2-large-patch14-ensemble":
-            expected_logits = torch.tensor(
-                [[-12.2037, -12.2070, -11.5371], [-13.4875, -13.8235, -13.1586], [-18.2007, -22.9834, -20.6816]],
-            )
-            expected_boxes = torch.tensor(
-                [[0.0126, 0.0127, 0.0222], [0.0107, 0.0113, 0.0164], [0.0482, 0.1162, 0.0885]],
-            )
-            expected_objectness_logits = torch.tensor(
-                [[-7.7572, -8.3637, -13.0334]],
-            )
-
-        print("Objectness logits:", objectness_logits[:3, :3])
-        print("Logits:", logits[0, :3, :3])
-        print("Pred boxes:", pred_boxes[0, :3, :3])
-
-        assert torch.allclose(logits[0, :3, :3], expected_logits, atol=1e-3)
-        assert torch.allclose(pred_boxes[0, :3, :3], expected_boxes, atol=1e-3)
-        assert torch.allclose(objectness_logits[:3, :3], expected_objectness_logits, atol=1e-3)
-        print("Looks ok!")
-    else:
-        print("Model converted without verifying logits")
-
-    if pytorch_dump_folder_path is not None:
-        print("Saving model and processor locally...")
-        # Create folder to save model
-        if not os.path.isdir(pytorch_dump_folder_path):
-            os.mkdir(pytorch_dump_folder_path)
-
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing {model_name} to the hub...")
-        model.push_to_hub(f"google/{model_name}")
-        processor.push_to_hub(f"google/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="owlv2-base-patch16",
-        choices=[
-            "owlv2-base-patch16",
-            "owlv2-base-patch16-finetuned",
-            "owlv2-base-patch16-ensemble",
-            "owlv2-large-patch14",
-            "owlv2-large-patch14-finetuned",
-            "owlv2-large-patch14-ensemble",
-        ],
-        type=str,
-        help="Name of the Owlv2 model you'd like to convert from FLAX to PyTorch.",
-    )
-    parser.add_argument(
-        "--checkpoint_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the original Flax checkpoint.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=False,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_false",
-        required=False,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--push_to_hub", action="store_true", help="Push model and image preprocessor to the hub")
-
-    args = parser.parse_args()
-    convert_owlv2_checkpoint(
-        args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub, args.verify_logits
-    )
diff --git a/src/transformers/models/owlvit/convert_owlvit_original_flax_to_hf.py b/src/transformers/models/owlvit/convert_owlvit_original_flax_to_hf.py
deleted file mode 100644
index 1e9fbb950467..000000000000
--- a/src/transformers/models/owlvit/convert_owlvit_original_flax_to_hf.py
+++ /dev/null
@@ -1,406 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert OWL-ViT checkpoints from the original repository. URL:
-https://github.com/google-research/scenic/tree/main/scenic/projects/owl_vit"""
-
-import argparse
-import collections
-
-import jax
-import jax.numpy as jnp
-import torch
-import torch.nn as nn
-from clip.model import CLIP
-from flax.training import checkpoints
-from huggingface_hub import Repository
-
-from transformers import (
-    CLIPTokenizer,
-    OwlViTConfig,
-    OwlViTForObjectDetection,
-    OwlViTImageProcessor,
-    OwlViTModel,
-    OwlViTProcessor,
-)
-
-
-CONFIGS = {
-    "vit_b32": {
-        "embed_dim": 512,
-        "image_resolution": 768,
-        "context_length": 16,
-        "vocab_size": 49408,
-        "vision_layers": 12,
-        "vision_width": 768,
-        "vision_patch_size": 32,
-        "transformer_width": 512,
-        "transformer_heads": 8,
-        "transformer_layers": 12,
-    },
-    "vit_b16": {
-        "embed_dim": 512,
-        "image_resolution": 768,
-        "context_length": 16,
-        "vocab_size": 49408,
-        "vision_layers": 12,
-        "vision_width": 768,
-        "vision_patch_size": 16,
-        "transformer_width": 512,
-        "transformer_heads": 8,
-        "transformer_layers": 12,
-    },
-    "vit_l14": {
-        "embed_dim": 768,
-        "image_resolution": 840,
-        "context_length": 16,
-        "vocab_size": 49408,
-        "vision_layers": 24,
-        "vision_width": 1024,
-        "vision_patch_size": 14,
-        "transformer_width": 768,
-        "transformer_heads": 12,
-        "transformer_layers": 12,
-    },
-}
-
-
-def flatten_nested_dict(params, parent_key="", sep="/"):
-    items = []
-
-    for k, v in params.items():
-        new_key = parent_key + sep + k if parent_key else k
-
-        if isinstance(v, collections.MutableMapping):
-            items.extend(flatten_nested_dict(v, new_key, sep=sep).items())
-        else:
-            items.append((new_key, v))
-    return dict(items)
-
-
-def to_f32(params):
-    return jax.tree_util.tree_map(lambda x: x.astype(jnp.float32) if x.dtype == jnp.bfloat16 else x, params)
-
-
-def copy_attn_layer(hf_attn_layer, pt_attn_layer):
-    q_proj, k_proj, v_proj = pt_attn_layer.in_proj_weight.chunk(3, dim=0)
-    q_proj_bias, k_proj_bias, v_proj_bias = pt_attn_layer.in_proj_bias.chunk(3, dim=0)
-
-    out_proj_weights = pt_attn_layer.out_proj.weight
-    out_proj_bias = pt_attn_layer.out_proj.bias
-
-    hf_attn_layer.q_proj.weight.data = q_proj
-    hf_attn_layer.q_proj.bias.data = q_proj_bias
-
-    hf_attn_layer.k_proj.weight.data = k_proj
-    hf_attn_layer.k_proj.bias.data = k_proj_bias
-
-    hf_attn_layer.v_proj.weight.data = v_proj
-    hf_attn_layer.v_proj.bias.data = v_proj_bias
-
-    hf_attn_layer.out_proj.weight = out_proj_weights
-    hf_attn_layer.out_proj.bias = out_proj_bias
-
-
-def copy_mlp(hf_mlp, pt_mlp):
-    copy_linear(hf_mlp.fc1, pt_mlp.c_fc)
-    copy_linear(hf_mlp.fc2, pt_mlp.c_proj)
-
-
-def copy_linear(hf_linear, pt_linear):
-    hf_linear.weight = pt_linear.weight
-    hf_linear.bias = pt_linear.bias
-
-
-def copy_layer(hf_layer, pt_layer):
-    # copy layer norms
-    copy_linear(hf_layer.layer_norm1, pt_layer.ln_1)
-    copy_linear(hf_layer.layer_norm2, pt_layer.ln_2)
-
-    # copy MLP
-    copy_mlp(hf_layer.mlp, pt_layer.mlp)
-
-    # copy attn
-    copy_attn_layer(hf_layer.self_attn, pt_layer.attn)
-
-
-def copy_layers(hf_layers, pt_layers):
-    for hf_layer, pt_layer in zip(hf_layers, pt_layers):
-        copy_layer(hf_layer, pt_layer)
-
-
-def copy_encoder(hf_encoder, pt_model):
-    # copy  embeds
-    hf_encoder.embeddings.token_embedding.weight = pt_model.token_embedding.weight
-    hf_encoder.embeddings.position_embedding.weight.data = pt_model.positional_embedding
-
-    # copy layer norm
-    copy_linear(hf_encoder.final_layer_norm, pt_model.ln_final)
-
-    # copy hidden layers
-    copy_layers(hf_encoder.encoder.layers, pt_model.transformer.resblocks)
-
-
-def copy_text_model_and_projection(hf_model, pt_model):
-    # copy projection
-    hf_model.text_projection.weight.data = pt_model.text_projection.data.T
-
-    # copy text encoder
-    copy_encoder(hf_model.text_model, pt_model)
-
-
-def copy_vision_model_and_projection(hf_model, pt_model):
-    # copy projection
-    hf_model.visual_projection.weight.data = pt_model.visual.proj.data.T
-
-    # copy layer norms
-    copy_linear(hf_model.vision_model.pre_layernorm, pt_model.visual.ln_pre)
-    copy_linear(hf_model.vision_model.post_layernorm, pt_model.visual.ln_post)
-
-    # copy embeds
-    hf_model.vision_model.embeddings.patch_embedding.weight.data = pt_model.visual.conv1.weight.data
-    hf_model.vision_model.embeddings.class_embedding = pt_model.visual.class_embedding
-    hf_model.vision_model.embeddings.position_embedding.weight.data = pt_model.visual.positional_embedding.data
-
-    # copy encoder
-    copy_layers(hf_model.vision_model.encoder.layers, pt_model.visual.transformer.resblocks)
-
-
-def copy_class_merge_token(hf_model, flax_params):
-    flax_class_token_params = flatten_nested_dict(flax_params["backbone"]["merged_class_token"])
-
-    weight = torch.from_numpy(flax_class_token_params["scale"])
-    bias = torch.from_numpy(flax_class_token_params["bias"])
-    hf_model.layer_norm.weight = nn.Parameter(weight)
-    hf_model.layer_norm.bias = nn.Parameter(bias)
-
-
-def copy_class_box_heads(hf_model, flax_params):
-    pt_params = hf_model.state_dict()
-    new_params = {}
-
-    # Rename class prediction head flax params to pytorch HF
-    flax_class_params = flatten_nested_dict(flax_params["class_head"])
-
-    for flax_key, v in flax_class_params.items():
-        torch_key = flax_key.replace("/", ".")
-        torch_key = torch_key.replace(".kernel", ".weight")
-        torch_key = torch_key.replace("Dense_0", "dense0")
-        torch_key = "class_head." + torch_key
-
-        if "weight" in torch_key and v.ndim == 2:
-            v = v.T
-
-        new_params[torch_key] = nn.Parameter(torch.from_numpy(v))
-
-    # Rename box prediction box flax params to pytorch HF
-    flax_box_params = flatten_nested_dict(flax_params["obj_box_head"])
-
-    for flax_key, v in flax_box_params.items():
-        torch_key = flax_key.replace("/", ".")
-        torch_key = torch_key.replace(".kernel", ".weight")
-        torch_key = torch_key.replace("_", "").lower()
-        torch_key = "box_head." + torch_key
-
-        if "weight" in torch_key and v.ndim == 2:
-            v = v.T
-
-        new_params[torch_key] = nn.Parameter(torch.from_numpy(v))
-
-    # Copy flax params to PyTorch params
-    for name, param in new_params.items():
-        if name in pt_params.keys():
-            pt_params[name].copy_(param)
-
-
-def copy_flax_attn_params(hf_backbone, flax_attn_params):
-    for k, v in flax_attn_params.items():
-        if k.startswith("transformer"):
-            torch_key = k.replace("transformer.resblocks", "text_model.encoder.layers")
-        else:
-            torch_key = k.replace("visual.transformer.resblocks", "vision_model.encoder.layers")
-
-        torch_key = torch_key.replace("attn", "self_attn")
-        torch_key = torch_key.replace("key", "k_proj")
-        torch_key = torch_key.replace("value", "v_proj")
-        torch_key = torch_key.replace("query", "q_proj")
-        torch_key = torch_key.replace("out", "out_proj")
-
-        if "bias" in torch_key and v.ndim == 2:
-            shape = v.shape[0] * v.shape[1]
-            v = v.reshape(shape)
-
-        if "weight" in torch_key and "out" in torch_key:
-            shape = (v.shape[0] * v.shape[1], v.shape[2])
-            v = v.reshape(shape).T
-
-        if "weight" in torch_key and "out" not in torch_key:
-            shape = (v.shape[0], v.shape[1] * v.shape[2])
-            v = v.reshape(shape).T
-
-        # Copy flax CLIP attn params to HF PyTorch params
-        v = torch.from_numpy(v)
-        hf_backbone.state_dict()[torch_key].copy_(v)
-
-
-def _convert_attn_layers(params):
-    new_params = {}
-    processed_attn_layers = []
-
-    for k, v in params.items():
-        if "attn." in k:
-            base = k[: k.rindex("attn.") + 5]
-            if base in processed_attn_layers:
-                continue
-
-            processed_attn_layers.append(base)
-            dim = params[base + "out.weight"].shape[-1]
-            new_params[base + "out_proj.weight"] = params[base + "out.weight"].reshape(dim, dim).T
-            new_params[base + "out_proj.bias"] = params[base + "out.bias"]
-        else:
-            new_params[k] = v
-    return new_params
-
-
-def convert_clip_backbone(flax_params, torch_config):
-    torch_model = CLIP(**torch_config)
-    torch_model.eval()
-    torch_clip_params = torch_model.state_dict()
-
-    flax_clip_params = flatten_nested_dict(flax_params["backbone"]["clip"])
-    new_torch_params = {}
-
-    for flax_key, v in flax_clip_params.items():
-        torch_key = flax_key.replace("/", ".")
-        torch_key = torch_key.replace("text.token_embedding.embedding", "token_embedding.kernel")
-
-        if (
-            torch_key.startswith("text.transformer")
-            or torch_key.startswith("text.text_projection")
-            or torch_key.startswith("text.ln_final")
-            or torch_key.startswith("text.positional_embedding")
-        ):
-            torch_key = torch_key[5:]
-
-        torch_key = torch_key.replace("text_projection.kernel", "text_projection")
-        torch_key = torch_key.replace("visual.proj.kernel", "visual.proj")
-        torch_key = torch_key.replace(".scale", ".weight")
-        torch_key = torch_key.replace(".kernel", ".weight")
-
-        if "conv" in torch_key or "downsample.0.weight" in torch_key:
-            v = v.transpose(3, 2, 0, 1)
-
-        elif "weight" in torch_key and v.ndim == 2 and "embedding" not in torch_key:
-            # Fully connected layers are transposed, embeddings are not
-            v = v.T
-
-        new_torch_params[torch_key] = v
-
-    attn_params = _convert_attn_layers(new_torch_params)
-    new_torch_params.update(attn_params)
-    attn_params = {}
-
-    # Copy flax CLIP backbone params to PyTorch params
-    for name, param in new_torch_params.items():
-        if name in torch_clip_params.keys():
-            new_param = torch.from_numpy(new_torch_params[name])
-            torch_clip_params[name].copy_(new_param)
-        else:
-            attn_params[name] = param
-
-    return torch_clip_params, torch_model, attn_params
-
-
-@torch.no_grad()
-def convert_owlvit_checkpoint(pt_backbone, flax_params, attn_params, pytorch_dump_folder_path, config_path=None):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    repo = Repository(pytorch_dump_folder_path, clone_from=f"google/{pytorch_dump_folder_path}")
-    repo.git_pull()
-
-    if config_path is not None:
-        config = OwlViTConfig.from_pretrained(config_path)
-    else:
-        config = OwlViTConfig()
-
-    hf_backbone = OwlViTModel(config).eval()
-    hf_model = OwlViTForObjectDetection(config).eval()
-
-    copy_text_model_and_projection(hf_backbone, pt_backbone)
-    copy_vision_model_and_projection(hf_backbone, pt_backbone)
-    hf_backbone.logit_scale = pt_backbone.logit_scale
-    copy_flax_attn_params(hf_backbone, attn_params)
-
-    hf_model.owlvit = hf_backbone
-    copy_class_merge_token(hf_model, flax_params)
-    copy_class_box_heads(hf_model, flax_params)
-
-    # Save HF model
-    hf_model.save_pretrained(repo.local_dir)
-
-    # Initialize image processor
-    image_processor = OwlViTImageProcessor(
-        size=config.vision_config.image_size, crop_size=config.vision_config.image_size
-    )
-    # Initialize tokenizer
-    tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32", pad_token="!", model_max_length=16)
-
-    # Initialize processor
-    processor = OwlViTProcessor(image_processor=image_processor, tokenizer=tokenizer)
-    image_processor.save_pretrained(repo.local_dir)
-    processor.save_pretrained(repo.local_dir)
-
-    repo.git_add()
-    repo.git_commit("Upload model and processor")
-    repo.git_push()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--owlvit_version",
-        default=None,
-        type=str,
-        required=True,
-        help="OWL-ViT model name [clip_b16, clip_b32, clip_l14].",
-    )
-    parser.add_argument(
-        "--owlvit_checkpoint", default=None, type=str, required=True, help="Path to flax model checkpoint."
-    )
-    parser.add_argument("--hf_config", default=None, type=str, required=True, help="Path to HF model config.")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default="hf_model", type=str, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-
-    # Initialize PyToch clip model
-    model_name = args.owlvit_version
-    if model_name == "clip_b16":
-        torch_config = CONFIGS["vit_b16"]
-    elif model_name == "clip_b32":
-        torch_config = CONFIGS["vit_b32"]
-    elif model_name == "clip_l14":
-        torch_config = CONFIGS["vit_l14"]
-
-    # Load from checkpoint and convert params to float-32
-    variables = checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)["optimizer"]["target"]
-    flax_params = jax.tree_util.tree_map(lambda x: x.astype(jnp.float32) if x.dtype == jnp.bfloat16 else x, variables)
-    del variables
-
-    # Convert CLIP backbone
-    pt_backbone_params, clip_pt, attn_params = convert_clip_backbone(flax_params, torch_config)
-
-    convert_owlvit_checkpoint(clip_pt, flax_params, attn_params, args.pytorch_dump_folder_path, args.hf_config)
diff --git a/src/transformers/models/paligemma/convert_paligemma2_weights_to_hf.py b/src/transformers/models/paligemma/convert_paligemma2_weights_to_hf.py
deleted file mode 100644
index df869fcefb2b..000000000000
--- a/src/transformers/models/paligemma/convert_paligemma2_weights_to_hf.py
+++ /dev/null
@@ -1,415 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert PaliGemma2 checkpoints from the original repository."""
-
-import argparse
-import collections
-
-import jax.numpy as jnp
-import ml_dtypes
-import numpy as np
-import torch
-
-from transformers import (
-    AutoTokenizer,
-    Gemma2Config,
-    PaliGemmaConfig,
-    PaliGemmaForConditionalGeneration,
-    PaliGemmaProcessor,
-    SiglipImageProcessor,
-)
-from transformers.tokenization_utils_base import AddedToken
-from transformers.utils import logging
-
-
-device = "cpu"
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-# TODO add sequence length variations here
-
-PALIGEMMA2_VARIANTS = ["2b-224", "2b-448", "2b-896", "9b-224", "9b-448", "9b-896", "27b-224", "27b-448", "27b-896"]
-VARIANT_CONFIGS = {
-    "2b": {
-        "num_positions": 256,
-        "hidden_size": 2304,
-        "num_hidden_layers": 26,
-        "intermediate_size": 9216,
-        "num_key_value_heads": 4,
-        "num_attention_heads": 8,
-        "head_dim": 256,
-        "query_pre_attn_scalar": 256,
-    },
-    "9b": {
-        "num_positions": 1024,
-        "hidden_size": 3584,
-        "num_hidden_layers": 42,
-        "intermediate_size": 14336,
-        "num_key_value_heads": 8,
-        "num_attention_heads": 16,
-        "head_dim": 256,
-        "query_pre_attn_scalar": 256,
-    },
-    "27b": {
-        "num_positions": 4096,
-        "hidden_size": 4608,
-        "num_hidden_layers": 46,
-        "intermediate_size": 36864,
-        "num_key_value_heads": 16,
-        "num_attention_heads": 32,
-        "head_dim": 128,
-        "query_pre_attn_scalar": 4608 // 32,  # scaling is different for the 28b
-    },
-}
-
-DTYPES = {"float32": torch.float32, "bfloat16": torch.bfloat16, "float16": torch.float16}
-
-
-def get_paligemma2_config(variant: str, precision: str):
-    config = {
-        "image_token_index": None,
-        "pad_token_id": 0,
-        "bos_token_id": 2,
-        "eos_token_id": 1,
-    }
-    base_variant = variant.split("-")[0]
-
-    if variant in PALIGEMMA2_VARIANTS:
-        image_size = int(variant.split("-")[1])
-        variant_config = VARIANT_CONFIGS[base_variant]
-        patch_size = 14
-        num_image_tokens = (image_size**2) // (patch_size**2)
-        config["projection_dim"] = variant_config["hidden_size"]
-        config["image_token_index"] = 257152
-        config["num_hidden_layers"] = variant_config["num_hidden_layers"]  # For generate
-        text_config = Gemma2Config.from_pretrained("google/gemma-2-2b-it").to_dict()
-        sup_text_config = {
-            "model_type": "gemma2",
-            "vocab_size": 257152,
-            "num_hidden_layers": variant_config["num_hidden_layers"],
-            "num_key_value_heads": variant_config["num_key_value_heads"],
-            "head_dim": variant_config["head_dim"],
-            "torch_dtype": precision,
-            "hidden_size": variant_config["hidden_size"],
-            "hidden_activation": "gelu_pytorch_tanh",
-            "num_attention_heads": variant_config["num_attention_heads"],
-            "intermediate_size": variant_config["intermediate_size"],
-            "is_encoder_decoder": False,
-            "query_pre_attn_scalar": variant_config["query_pre_attn_scalar"],
-        }
-        text_config.update(sup_text_config)
-
-        vision_config = {
-            "num_positions": variant_config["num_positions"],  # not useful, to remove
-            "torch_dtype": precision,
-            "image_size": image_size,
-            "patch_size": patch_size,
-            "num_image_tokens": num_image_tokens,
-            "hidden_size": 1152,
-            "intermediate_size": 4304,
-            "num_hidden_layers": 27,
-            "num_attention_heads": 16,
-            "projection_dim": variant_config["hidden_size"],
-            "hidden_act": "gelu_pytorch_tanh",
-            "vision_use_head": False,
-        }
-        final_config = PaliGemmaConfig(text_config=text_config, vision_config=vision_config, **config)
-    else:
-        raise ValueError(f"Identifier {variant} not supported. Available: {PALIGEMMA2_VARIANTS}")
-    return final_config
-
-
-def slice_state_dict(state_dict, config):
-    # fmt: off
-    # patch embeddings
-    state_dict["vision_tower.vision_model.embeddings.patch_embedding.weight"] = state_dict.pop("img/embedding/kernel").transpose(
-        3, 2, 0, 1
-    )
-    state_dict["vision_tower.vision_model.embeddings.patch_embedding.bias"] = state_dict.pop("img/embedding/bias")
-    # positional embeddings
-    state_dict["vision_tower.vision_model.embeddings.position_embedding.weight"] = state_dict.pop("img/pos_embedding").reshape(
-        -1, config.vision_config.hidden_size
-    )
-
-    # extract vision layers to be sliced at index 0. There are 27 layers in the base model.
-    encoderblock_layernorm0_scale = state_dict.pop("img/Transformer/encoderblock/LayerNorm_0/scale")
-    encoderblock_layernorm0_bias = state_dict.pop("img/Transformer/encoderblock/LayerNorm_0/bias")
-    encoderblock_layernorm1_scale = state_dict.pop("img/Transformer/encoderblock/LayerNorm_1/scale")
-    encoderblock_layernorm1_bias = state_dict.pop("img/Transformer/encoderblock/LayerNorm_1/bias")
-
-    encoderblock_mlp_dense0_kernel= state_dict.pop("img/Transformer/encoderblock/MlpBlock_0/Dense_0/kernel")
-    encoderblock_mlp_dense0_bias= state_dict.pop("img/Transformer/encoderblock/MlpBlock_0/Dense_0/bias")
-    encoderblock_mlp_dense1_kernel= state_dict.pop("img/Transformer/encoderblock/MlpBlock_0/Dense_1/kernel")
-    encoderblock_mlp_dense1_bias= state_dict.pop("img/Transformer/encoderblock/MlpBlock_0/Dense_1/bias")
-
-    encoderblock_attention_0_key_kernel = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/key/kernel")
-    encoderblock_attention_0_key_bias = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/key/bias")
-    encoderblock_attention_0_value_kernel = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/value/kernel")
-    encoderblock_attention_0_value_bias = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/value/bias")
-    encoderblock_attention_0_query_kernel = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/query/kernel")
-    encoderblock_attention_0_query_bias = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/query/bias")
-    encoderblock_attention_0_out_kernel = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/out/kernel")
-    encoderblock_attention_0_out_bias = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/out/bias")
-
-    for i in range(config.vision_config.num_hidden_layers):
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.layer_norm1.weight"] = encoderblock_layernorm0_scale[i].transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.layer_norm1.bias"] = encoderblock_layernorm0_bias[i]
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.layer_norm2.weight"] = encoderblock_layernorm1_scale[i].transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.layer_norm2.bias"] = encoderblock_layernorm1_bias[i]
-
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc1.weight"] = encoderblock_mlp_dense0_kernel[i].transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc1.bias"] = encoderblock_mlp_dense0_bias[i]
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc2.weight"] = encoderblock_mlp_dense1_kernel[i].transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc2.bias"] = encoderblock_mlp_dense1_bias[i]
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.k_proj.weight"] = encoderblock_attention_0_key_kernel[i].reshape(-1, config.vision_config.hidden_size).transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.k_proj.bias"] = encoderblock_attention_0_key_bias[i].reshape(-1, config.vision_config.hidden_size).reshape(-1)
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.v_proj.weight"] = encoderblock_attention_0_value_kernel[i].reshape(-1, config.vision_config.hidden_size).transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.v_proj.bias"] = encoderblock_attention_0_value_bias[i].reshape(-1, config.vision_config.hidden_size).reshape(-1)
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.q_proj.weight"] = encoderblock_attention_0_query_kernel[i].reshape(-1, config.vision_config.hidden_size).transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.q_proj.bias"] = encoderblock_attention_0_query_bias[i].reshape(-1, config.vision_config.hidden_size).reshape(-1)
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.out_proj.weight"] = encoderblock_attention_0_out_kernel[i].reshape(-1, config.vision_config.hidden_size).transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.out_proj.bias"] = encoderblock_attention_0_out_bias[i].reshape(-1, config.vision_config.hidden_size).reshape(-1)
-
-    state_dict["vision_tower.vision_model.post_layernorm.weight"] = state_dict.pop("img/Transformer/encoder_norm/scale").transpose()
-    state_dict["vision_tower.vision_model.post_layernorm.bias"] = state_dict.pop("img/Transformer/encoder_norm/bias")
-
-    # multimodal projector
-
-    state_dict['multi_modal_projector.linear.weight'] = state_dict.pop("img/head/kernel").transpose()
-    state_dict['multi_modal_projector.linear.bias'] = state_dict.pop("img/head/bias")
-
-    # text decoder (gemma)
-
-    embedding_vector = state_dict.pop("llm/embedder/input_embedding")
-    state_dict["language_model.model.embed_tokens.weight"] = embedding_vector
-
-    # pop the einsum attention + mlp representations. There are 26 layers in gemma2-2b.
-
-    llm_attention_attn_vec_einsum = state_dict.pop("llm/layers/attn/attn_vec_einsum/w")
-    #  (26, 2, 4, 2304, 256) for 2b-224, 4 kv heads and 26 layers
-    llm_attention_kv_einsum = state_dict.pop("llm/layers/attn/kv_einsum/w")
-    llm_attention_q_einsum = state_dict.pop("llm/layers/attn/q_einsum/w")
-    llm_mlp_gating_einsum = state_dict.pop("llm/layers/mlp/gating_einsum")
-    llm_mlp_linear = state_dict.pop("llm/layers/mlp/linear")
-    # TODO verify correctness of layer norm loading
-    llm_input_layernorm = state_dict.pop("llm/layers/pre_attention_norm/scale")
-    llm_pre_feedforward_layernorm = state_dict.pop("llm/layers/pre_ffw_norm/scale")
-
-    llm_post_attention_layernorm = state_dict.pop("llm/layers/post_attention_norm/scale")
-    llm_post_feedforward_layernorm = state_dict.pop("llm/layers/post_ffw_norm/scale")
-
-    for i in range(config.text_config.num_hidden_layers):
-        # llm_attention_q_einsum[i].shape = (8, 2048, 256)
-        # q_proj_weight_reshaped = llm_attention_q_einsum[i].transpose(0, 2, 1).reshape(config.text_config.num_attention_heads * config.text_config.head_dim, config.text_config.hidden_size)
-
-        """
-        q shape (8, 2304, 256)
-        k shape (4, 2304, 256)
-        v shape (4, 2304, 256)
-        o shape (8, 256, 2304)
-
-        """
-        q_transpose = (0, 2, 1)
-        k_transpose = (0, 2, 1)
-        v_transpose = (0, 2, 1)
-        o_transpose = (2, 0, 1)
-
-        q_weight_matrices = llm_attention_q_einsum[i].transpose(*q_transpose)
-        q_proj_weight_reshaped = q_weight_matrices
-        q_proj_weight_reshaped = q_proj_weight_reshaped.reshape(config.text_config.num_attention_heads * config.text_config.head_dim, config.text_config.hidden_size)
-        state_dict[f"language_model.model.layers.{i}.self_attn.q_proj.weight"] = q_proj_weight_reshaped
-        # Shape: (4, 2304, 256)
-        k_weight_matrices = llm_attention_kv_einsum[i, 0].transpose(*k_transpose)
-        k_proj_weight_reshaped = k_weight_matrices.reshape(
-            config.text_config.num_key_value_heads * config.text_config.head_dim,
-            config.text_config.hidden_size
-        )
-        state_dict[f"language_model.model.layers.{i}.self_attn.k_proj.weight"] = k_proj_weight_reshaped
-        # llm_attention_kv_einsum[i, 1].shape = (num_key_value_heads, hidden_size, head_dim)
-        v_weight_matrices = llm_attention_kv_einsum[i, 1].transpose(*v_transpose) # Shape: (4, 2304, 256)
-        v_proj_weight_reshaped = v_weight_matrices.reshape(
-            config.text_config.num_key_value_heads * config.text_config.head_dim,
-            config.text_config.hidden_size
-        )
-        state_dict[f"language_model.model.layers.{i}.self_attn.v_proj.weight"] = v_proj_weight_reshaped
-
-        # output projection.
-
-        # llm_attention_attn_vec_einsum[i].shape = (8, 256, 2304)
-        o_proj_weight_reshaped = llm_attention_attn_vec_einsum[i].transpose(*o_transpose).reshape(config.text_config.hidden_size, config.text_config.num_attention_heads * config.text_config.head_dim)
-        state_dict[f"language_model.model.layers.{i}.self_attn.o_proj.weight"] = o_proj_weight_reshaped
-        # mlp layers
-        gate_proj_weight = llm_mlp_gating_einsum[i, 0]
-        state_dict[f"language_model.model.layers.{i}.mlp.gate_proj.weight"] = gate_proj_weight.transpose()
-        up_proj_weight = llm_mlp_gating_einsum[i, 1]
-        state_dict[f"language_model.model.layers.{i}.mlp.up_proj.weight"] = up_proj_weight.transpose()
-        state_dict[f"language_model.model.layers.{i}.mlp.down_proj.weight"] = llm_mlp_linear[i].transpose()
-        state_dict[f"language_model.model.layers.{i}.input_layernorm.weight"] = llm_input_layernorm[i]
-        state_dict[f"language_model.model.layers.{i}.post_attention_layernorm.weight"] = llm_post_attention_layernorm[i]
-        state_dict[f"language_model.model.layers.{i}.pre_feedforward_layernorm.weight"] = llm_pre_feedforward_layernorm[i]
-        state_dict[f"language_model.model.layers.{i}.post_feedforward_layernorm.weight"] = llm_post_feedforward_layernorm[i]
-    state_dict["language_model.model.norm.weight"] = state_dict.pop("llm/final_norm/scale")
-    state_dict["language_model.lm_head.weight"] = embedding_vector # weights are tied.
-    [k for k in state_dict.keys() if not k.startswith('vision') and not k.startswith('language')]
-    # fmt: on
-    for key, value in state_dict.items():
-        if not isinstance(value, torch.Tensor):
-            try:
-                if value.dtype == jnp.bfloat16:
-                    value = jnp.array(value).astype(jnp.float32)
-                    value = np.array(value)
-                    state_dict[key] = torch.from_numpy(value).to(torch.bfloat16)
-                else:
-                    state_dict[key] = torch.from_numpy(value)
-            except Exception as initial_exception:
-                raise ValueError(f"Conversion failed from jax weights with {initial_exception}. Check your inputs.")
-    return state_dict
-
-
-def flatten_nested_dict(params, parent_key="", sep="/", precision: int = "float32"):
-    items = []
-
-    for k, v in params.items():
-        k = k.removeprefix("params/")
-        new_key = parent_key + sep + k if parent_key else k
-
-        if isinstance(v, collections.abc.MutableMapping):
-            items.extend(flatten_nested_dict(v, parent_key=new_key, sep=sep, precision=precision).items())
-        else:
-            if precision == "bfloat16":
-                try:
-                    v = v.view(ml_dtypes.bfloat16)
-                except Exception as initial_exception:
-                    raise ValueError(f"Conversion failed from bfloat16 with {initial_exception}, check your inputs.")
-            items.append((new_key, v))
-    return dict(items)
-
-
-@torch.no_grad()
-def convert_paligemma2_checkpoint(
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    variant: str,
-    precision: str,
-    do_convert_weights=False,
-):
-    """
-    Read checkpoints from flax npz files, rename/reshape, send result to state dict and verify logits if needed.
-    """
-    config = get_paligemma2_config(variant, precision=precision)
-    if do_convert_weights:
-        tokenizer_id = "google/paligemma-3b-pt-224"  # same tokenizer as paligemma 1
-        tokenizer = AutoTokenizer.from_pretrained(tokenizer_id)
-        image_token = AddedToken("<image>", normalized=False, special=True)
-        tokens_to_add = {"additional_special_tokens": [image_token]}
-        tokenizer.add_special_tokens(tokens_to_add)
-
-        # tokenizer.padding_side = 'right' # uncomment for testing purposes only.
-
-        image_processor = SiglipImageProcessor.from_pretrained("google/paligemma-3b-pt-224")
-        image_processor.size = {"width": config.vision_config.image_size, "height": config.vision_config.image_size}
-        image_processor.image_seq_length = config.vision_config.num_image_tokens
-
-        processor = PaliGemmaProcessor(image_processor=image_processor, tokenizer=tokenizer)
-        data = jnp.load(checkpoint_path)
-        state_dict = flatten_nested_dict(data, precision=precision)
-        del data
-        state_dict_transformers = slice_state_dict(state_dict, config)
-        del state_dict
-        del config.hidden_size  # this key is unused
-        model = PaliGemmaForConditionalGeneration(config).to(device).eval()
-        model.load_state_dict(state_dict_transformers)
-        del state_dict_transformers
-        model.config.text_config._attn_implementation = "sdpa"
-
-        # model expansion to get random embeds of image tokens
-        pad_shape = 64  # for performance reasons
-        pre_expansion_embeddings = model.language_model.model.embed_tokens.weight.data
-        mu = torch.mean(pre_expansion_embeddings, dim=0).float()
-        n = pre_expansion_embeddings.size()[0]
-        sigma = ((pre_expansion_embeddings - mu).T @ (pre_expansion_embeddings - mu)) / n
-        dist = torch.distributions.multivariate_normal.MultivariateNormal(mu, covariance_matrix=1e-5 * sigma)
-
-        # We add an image token so we resize the model
-        model.resize_token_embeddings(config.text_config.vocab_size + 2, pad_shape)
-        model.language_model.model.embed_tokens.weight.data[257152:] = torch.stack(
-            tuple(
-                (dist.sample() for _ in range(model.language_model.model.embed_tokens.weight.data[257152:].shape[0]))
-            ),
-            dim=0,
-        )
-        model.language_model.lm_head.weight.data[257152:] = torch.stack(
-            tuple((dist.sample() for _ in range(model.language_model.lm_head.weight.data[257152:].shape[0]))),
-            dim=0,
-        )
-        # convert to needed precision
-
-        model.to(DTYPES[precision])
-        model.save_pretrained(pytorch_dump_folder_path, safe_serialization=True)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    else:
-        processor = PaliGemmaProcessor.from_pretrained(pytorch_dump_folder_path, do_rescale=False)
-        model = (
-            PaliGemmaForConditionalGeneration.from_pretrained(pytorch_dump_folder_path, attn_implementation="sdpa")
-            .to(device)
-            .eval()
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--checkpoint_path",
-        required=True,
-        type=str,
-        help="Path to the .npz checkpoint",
-    )
-
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        required=True,
-        type=str,
-        help="Path to the output directory where model and processor will be saved.",
-    )
-
-    parser.add_argument(
-        "--precision",
-        choices=["float32", "bfloat16", "float16"],
-        type=str,
-        help="Precision identifier for model conversion - should match the base checkpoint precision.",
-    )
-
-    parser.add_argument(
-        "--variant",
-        default="2b-224",
-        choices=PALIGEMMA2_VARIANTS,
-        type=str,
-        help="String identifier of the paligemma2 variant to convert.",
-    )
-
-    parser.add_argument(
-        "--do_convert_weights", action="store_true", help="Whether or not to reload and convert the weights."
-    )
-
-    args = parser.parse_args()
-    convert_paligemma2_checkpoint(
-        checkpoint_path=args.checkpoint_path,
-        pytorch_dump_folder_path=args.pytorch_dump_folder_path,
-        variant=args.variant,
-        precision=args.precision,
-        do_convert_weights=args.do_convert_weights,
-    )
diff --git a/src/transformers/models/paligemma/convert_paligemma_weights_to_hf.py b/src/transformers/models/paligemma/convert_paligemma_weights_to_hf.py
deleted file mode 100644
index bcea5372e57a..000000000000
--- a/src/transformers/models/paligemma/convert_paligemma_weights_to_hf.py
+++ /dev/null
@@ -1,347 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert PaliGemma checkpoints from the original repository."""
-
-import argparse
-import collections
-
-import torch
-from numpy import load
-
-from transformers import (
-    AutoTokenizer,
-    GemmaTokenizer,
-    GemmaTokenizerFast,
-    PaliGemmaConfig,
-    PaliGemmaForConditionalGeneration,
-    PaliGemmaProcessor,
-    SiglipImageProcessor,
-)
-from transformers.tokenization_utils_base import AddedToken
-from transformers.utils import logging
-
-
-device = "cuda"  # "cpu"
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-# TODO add sequence length variations here
-
-PALIGEMMA_VARIANTS = ["2b-test", "3b-224px", "3b-448px", "3b-896px"]
-
-
-def get_paligemma_config(variant: str, precision: str):
-    config = {
-        "image_token_index": None,
-        "pad_token_id": 0,
-        "bos_token_id": 2,
-        "eos_token_id": 1,
-    }
-
-    image_sizes = {"2b-test": 224, "3b-224px": 224, "3b-448px": 448, "3b-896px": 896}
-
-    if variant in PALIGEMMA_VARIANTS:
-        image_size = image_sizes[variant]
-        patch_size = 14
-        num_image_tokens = (image_size**2) // (patch_size**2)
-
-        config["image_token_index"] = 257152 if variant != "2b-test" else 256000
-        text_config = {
-            "vocab_size": 257152,
-            "num_hidden_layers": 18,
-            "num_key_value_heads": 1,
-            "head_dim": 256,
-            "torch_dtype": precision,
-            "hidden_size": 2048,
-            "hidden_activation": "gelu_pytorch_tanh",
-            "num_attention_heads": 8,
-            "intermediate_size": 16384,
-            "is_encoder_decoder": False,
-        }
-        vision_config = {
-            "torch_dtype": precision,
-            "image_size": image_size,
-            "patch_size": patch_size,
-            "num_image_tokens": num_image_tokens,
-            "hidden_size": 1152,
-            "intermediate_size": 4304,
-            "num_hidden_layers": 27,
-            "num_attention_heads": 16,
-            "projector_hidden_act": "gelu_fast",
-            "vision_use_head": False,
-        }
-        final_config = PaliGemmaConfig(text_config=text_config, vision_config=vision_config, **config)
-    else:
-        raise ValueError(f"Identifier {variant} not supported. Available: {PALIGEMMA_VARIANTS}")
-    return final_config
-
-
-def slice_state_dict(state_dict, config):
-    # fmt: off
-    # patch embeddings
-    state_dict["vision_tower.vision_model.embeddings.patch_embedding.weight"] = state_dict.pop("img/embedding/kernel").transpose(
-        3, 2, 0, 1
-    )
-    state_dict["vision_tower.vision_model.embeddings.patch_embedding.bias"] = state_dict.pop("img/embedding/bias")
-    # positional embeddings
-    state_dict["vision_tower.vision_model.embeddings.position_embedding.weight"] = state_dict.pop("img/pos_embedding").reshape(
-        -1, config.vision_config.hidden_size
-    )
-
-    # extract vision layers to be sliced at index 0. There are 27 layers in the base model.
-    encoderblock_layernorm0_scale = state_dict.pop("img/Transformer/encoderblock/LayerNorm_0/scale")
-    encoderblock_layernorm0_bias = state_dict.pop("img/Transformer/encoderblock/LayerNorm_0/bias")
-    encoderblock_layernorm1_scale = state_dict.pop("img/Transformer/encoderblock/LayerNorm_1/scale")
-    encoderblock_layernorm1_bias = state_dict.pop("img/Transformer/encoderblock/LayerNorm_1/bias")
-
-    encoderblock_mlp_dense0_kernel= state_dict.pop("img/Transformer/encoderblock/MlpBlock_0/Dense_0/kernel")
-    encoderblock_mlp_dense0_bias= state_dict.pop("img/Transformer/encoderblock/MlpBlock_0/Dense_0/bias")
-    encoderblock_mlp_dense1_kernel= state_dict.pop("img/Transformer/encoderblock/MlpBlock_0/Dense_1/kernel")
-    encoderblock_mlp_dense1_bias= state_dict.pop("img/Transformer/encoderblock/MlpBlock_0/Dense_1/bias")
-
-    encoderblock_attention_0_key_kernel = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/key/kernel")
-    encoderblock_attention_0_key_bias = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/key/bias")
-    encoderblock_attention_0_value_kernel = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/value/kernel")
-    encoderblock_attention_0_value_bias = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/value/bias")
-    encoderblock_attention_0_query_kernel = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/query/kernel")
-    encoderblock_attention_0_query_bias = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/query/bias")
-    encoderblock_attention_0_out_kernel = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/out/kernel")
-    encoderblock_attention_0_out_bias = state_dict.pop("img/Transformer/encoderblock/MultiHeadDotProductAttention_0/out/bias")
-
-    for i in range(config.vision_config.num_hidden_layers):
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.layer_norm1.weight"] = encoderblock_layernorm0_scale[i].transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.layer_norm1.bias"] = encoderblock_layernorm0_bias[i]
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.layer_norm2.weight"] = encoderblock_layernorm1_scale[i].transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.layer_norm2.bias"] = encoderblock_layernorm1_bias[i]
-
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc1.weight"] = encoderblock_mlp_dense0_kernel[i].transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc1.bias"] = encoderblock_mlp_dense0_bias[i]
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc2.weight"] = encoderblock_mlp_dense1_kernel[i].transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc2.bias"] = encoderblock_mlp_dense1_bias[i]
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.k_proj.weight"] = encoderblock_attention_0_key_kernel[i].reshape(-1, config.vision_config.hidden_size).transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.k_proj.bias"] = encoderblock_attention_0_key_bias[i].reshape(-1, config.vision_config.hidden_size).reshape(-1)
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.v_proj.weight"] = encoderblock_attention_0_value_kernel[i].reshape(-1, config.vision_config.hidden_size).transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.v_proj.bias"] = encoderblock_attention_0_value_bias[i].reshape(-1, config.vision_config.hidden_size).reshape(-1)
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.q_proj.weight"] = encoderblock_attention_0_query_kernel[i].reshape(-1, config.vision_config.hidden_size).transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.q_proj.bias"] = encoderblock_attention_0_query_bias[i].reshape(-1, config.vision_config.hidden_size).reshape(-1)
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.out_proj.weight"] = encoderblock_attention_0_out_kernel[i].reshape(-1, config.vision_config.hidden_size).transpose()
-        state_dict[f"vision_tower.vision_model.encoder.layers.{i}.self_attn.out_proj.bias"] = encoderblock_attention_0_out_bias[i].reshape(-1, config.vision_config.hidden_size).reshape(-1)
-
-    state_dict["vision_tower.vision_model.post_layernorm.weight"] = state_dict.pop("img/Transformer/encoder_norm/scale").transpose()
-    state_dict["vision_tower.vision_model.post_layernorm.bias"] = state_dict.pop("img/Transformer/encoder_norm/bias")
-
-    # multimodal projector
-
-    state_dict['multi_modal_projector.linear.weight'] = state_dict.pop("img/head/kernel").transpose()
-    state_dict['multi_modal_projector.linear.bias'] = state_dict.pop("img/head/bias")
-
-    # text decoder (gemma)
-
-    embedding_vector = state_dict.pop("llm/embedder/input_embedding")
-    state_dict["language_model.model.embed_tokens.weight"] = embedding_vector
-
-    # pop the einsum attention + mlp representations. There are 18 layers in gemma-2b.
-
-    llm_attention_attn_vec_einsum = state_dict.pop("llm/layers/attn/attn_vec_einsum/w")
-    llm_attention_kv_einsum = state_dict.pop("llm/layers/attn/kv_einsum/w")
-    llm_attention_q_einsum = state_dict.pop("llm/layers/attn/q_einsum/w")
-
-    llm_mlp_gating_einsum = state_dict.pop("llm/layers/mlp/gating_einsum")
-    llm_mlp_linear = state_dict.pop("llm/layers/mlp/linear")
-    # TODO verify correctness of layer norm loading
-
-    llm_input_layernorm = state_dict.pop("llm/layers/pre_attention_norm/scale")
-    llm_post_attention_layernorm = state_dict.pop("llm/layers/pre_ffw_norm/scale")
-
-    for i in range(config.text_config.num_hidden_layers):
-        # llm_attention_q_einsum[i].shape = (8, 2048, 256)
-        q_proj_weight_reshaped = llm_attention_q_einsum[i].transpose(0, 2, 1).reshape(config.text_config.num_attention_heads * config.text_config.head_dim, config.text_config.hidden_size)
-
-        state_dict[f"language_model.model.layers.{i}.self_attn.q_proj.weight"] = q_proj_weight_reshaped
-
-        # llm_attention_kv_einsum[i, 0, 0].shape = (2048, 256)
-        k_proj_weight_reshaped = llm_attention_kv_einsum[i, 0, 0].transpose()
-        state_dict[f"language_model.model.layers.{i}.self_attn.k_proj.weight"] = k_proj_weight_reshaped
-        # llm_attention_kv_einsum[i, 1, 0].shape = (2048, 256)
-        v_proj_weight_reshaped = llm_attention_kv_einsum[i, 1, 0].transpose()
-        state_dict[f"language_model.model.layers.{i}.self_attn.v_proj.weight"] = v_proj_weight_reshaped
-
-        # output projection.
-
-        # llm_attention_attn_vec_einsum[i].shape = (8, 256, 2048)
-        o_proj_weight_reshaped = llm_attention_attn_vec_einsum[i].transpose(2, 0, 1).reshape(config.text_config.num_attention_heads * config.text_config.head_dim, config.text_config.hidden_size)
-
-        state_dict[f"language_model.model.layers.{i}.self_attn.o_proj.weight"] = o_proj_weight_reshaped
-        # mlp layers
-        gate_proj_weight = llm_mlp_gating_einsum[i, 0]
-        state_dict[f"language_model.model.layers.{i}.mlp.gate_proj.weight"] = gate_proj_weight.transpose()
-        up_proj_weight = llm_mlp_gating_einsum[i, 1]
-        state_dict[f"language_model.model.layers.{i}.mlp.up_proj.weight"] = up_proj_weight.transpose()
-        state_dict[f"language_model.model.layers.{i}.mlp.down_proj.weight"] = llm_mlp_linear[i].transpose()
-        state_dict[f"language_model.model.layers.{i}.input_layernorm.weight"] = llm_input_layernorm[i]
-        state_dict[f"language_model.model.layers.{i}.post_attention_layernorm.weight"] = llm_post_attention_layernorm[i]
-
-    state_dict["language_model.model.norm.weight"] = state_dict.pop("llm/final_norm/scale")
-    state_dict["language_model.lm_head.weight"] = embedding_vector # weights are tied.
-
-    # fmt: on
-    for key, value in state_dict.items():
-        state_dict[key] = torch.from_numpy(value)
-    return state_dict
-
-
-def flatten_nested_dict(params, parent_key="", sep="/"):
-    items = []
-
-    for k, v in params.items():
-        k = k.removeprefix("params/")
-        new_key = parent_key + sep + k if parent_key else k
-
-        if isinstance(v, collections.abc.MutableMapping):
-            items.extend(flatten_nested_dict(v, parent_key=new_key, sep=sep).items())
-        else:
-            items.append((new_key, v))
-    return dict(items)
-
-
-@torch.no_grad()
-def convert_paligemma_checkpoint(
-    checkpoint_path,
-    tokenizer_model_file,
-    pytorch_dump_folder_path,
-    variant: str,
-    precision: str,
-    do_convert_weights=False,
-):
-    """
-    Read checkpoints from flax npz files, rename/reshape, send result to state dict and verify logits if needed.
-    """
-    config = get_paligemma_config(variant, precision=precision)
-    if do_convert_weights:
-        if variant == "2b-test":
-            # for the test model, the vocabulary was smaller
-            tokenizer_id = "google/gemma-2b"
-            tokenizer = AutoTokenizer.from_pretrained(tokenizer_id)
-        else:
-            tokenizer_class = GemmaTokenizer if GemmaTokenizerFast is None else GemmaTokenizerFast
-            tokenizer = tokenizer_class(tokenizer_model_file)
-        image_token = AddedToken("<image>", normalized=False, special=True)
-        tokens_to_add = {"additional_special_tokens": [image_token]}
-        tokenizer.add_special_tokens(tokens_to_add)
-
-        # tokenizer.padding_side = 'right' # uncomment for testing purposes only.
-
-        image_processor = SiglipImageProcessor.from_pretrained("google/siglip-so400m-patch14-384")
-        image_processor.size = {"width": config.vision_config.image_size, "height": config.vision_config.image_size}
-        image_processor.image_seq_length = config.vision_config.num_image_tokens
-
-        processor = PaliGemmaProcessor(image_processor=image_processor, tokenizer=tokenizer)
-        data = load(checkpoint_path)
-        state_dict = flatten_nested_dict(data)
-        del data
-        state_dict_transformers = slice_state_dict(state_dict, config)
-        del state_dict
-
-        model = PaliGemmaForConditionalGeneration(config).to(device).eval()
-        model.load_state_dict(state_dict_transformers)
-        del state_dict_transformers
-
-    else:
-        processor = PaliGemmaProcessor.from_pretrained(pytorch_dump_folder_path)
-        model = (
-            PaliGemmaForConditionalGeneration.from_pretrained(pytorch_dump_folder_path, attn_implementation="sdpa")
-            .to(device)
-            .eval()
-        )
-    model.config.text_config._attn_implementation = "sdpa"
-
-    # model expansion to get random embeds of image tokens
-    pad_shape = 64  # for performance reasons
-    pre_expansion_embeddings = model.language_model.model.embed_tokens.weight.data
-    mu = torch.mean(pre_expansion_embeddings, dim=0).float()
-    n = pre_expansion_embeddings.size()[0]
-    sigma = ((pre_expansion_embeddings - mu).T @ (pre_expansion_embeddings - mu)) / n
-    dist = torch.distributions.multivariate_normal.MultivariateNormal(mu, covariance_matrix=1e-5 * sigma)
-
-    # We add an image token so we resize the model
-    model.resize_token_embeddings(config.text_config.vocab_size + 2, pad_shape)
-    model.language_model.model.embed_tokens.weight.data[257152:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.model.embed_tokens.weight.data[257152:].shape[0]))),
-        dim=0,
-    )
-    model.language_model.lm_head.weight.data[257152:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.lm_head.weight.data[257152:].shape[0]))),
-        dim=0,
-    )
-
-    model.save_pretrained(pytorch_dump_folder_path, max_shard_size="2GB", safe_serialization=True)
-    processor.save_pretrained(pytorch_dump_folder_path)
-
-
-#
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--checkpoint_path",
-        required=True,
-        type=str,
-        help="Path to the .npz checkpoint",
-    )
-
-    parser.add_argument(
-        "--tokenizer_model_file",
-        required=True,
-        type=str,
-        help="Path to the sentencepiece tokenizer.model file",
-    )
-
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        required=True,
-        type=str,
-        help="Path to the output directory where model and processor will be saved.",
-    )
-
-    parser.add_argument(
-        "--precision",
-        choices=["float32", "bfloat16", "float16"],
-        type=str,
-        help="Precision identifier for model conversion - should match the base checkpoint precision.",
-    )
-
-    parser.add_argument(
-        "--variant",
-        default="2b-test",
-        choices=PALIGEMMA_VARIANTS,
-        type=str,
-        help="String identifier of the paligemma variant to convert.",
-    )
-
-    parser.add_argument(
-        "--do_convert_weights", action="store_true", help="Whether or not to reload and convert the weights."
-    )
-
-    args = parser.parse_args()
-    convert_paligemma_checkpoint(
-        checkpoint_path=args.checkpoint_path,
-        tokenizer_model_file=args.tokenizer_model_file,
-        pytorch_dump_folder_path=args.pytorch_dump_folder_path,
-        variant=args.variant,
-        precision=args.precision,
-        do_convert_weights=args.do_convert_weights,
-    )
diff --git a/src/transformers/models/pegasus/convert_pegasus_tf_to_pytorch.py b/src/transformers/models/pegasus/convert_pegasus_tf_to_pytorch.py
deleted file mode 100644
index cf183b590c1b..000000000000
--- a/src/transformers/models/pegasus/convert_pegasus_tf_to_pytorch.py
+++ /dev/null
@@ -1,131 +0,0 @@
-# coding=utf-8
-# Copyright 2020 Google and The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import os
-from pathlib import Path
-from typing import Dict
-
-import tensorflow as tf
-import torch
-from tqdm import tqdm
-
-from transformers import PegasusConfig, PegasusForConditionalGeneration, PegasusTokenizer
-from transformers.models.pegasus.configuration_pegasus import DEFAULTS, task_specific_params
-
-
-PATTERNS = [
-    # replace left string with right string to get the relevant state_dict key (identical state dict to bart)
-    ["memory_attention", "encoder_attn"],
-    ["attention", "attn"],
-    ["/", "."],
-    [".LayerNorm.gamma", "_layer_norm.weight"],
-    [".LayerNorm.beta", "_layer_norm.bias"],
-    ["r.layer_", "r.layers."],
-    ["output_proj", "out_proj"],
-    ["ffn.dense_1.", "fc2."],
-    ["ffn.dense.", "fc1."],
-    ["ffn_layer_norm", "final_layer_norm"],
-    ["kernel", "weight"],
-    ["encoder_layer_norm.", "encoder.layer_norm."],
-    ["decoder_layer_norm.", "decoder.layer_norm."],
-    ["embeddings.weights", "shared.weight"],
-]
-
-
-def rename_state_dict_key(k):
-    for pegasus_name, hf_name in PATTERNS:
-        k = k.replace(pegasus_name, hf_name)
-    return k
-
-
-# See appendix C of paper for all hyperparams
-
-
-def convert_pegasus(tf_weights: dict, cfg_updates: dict) -> PegasusForConditionalGeneration:
-    cfg_kwargs = DEFAULTS.copy()
-    cfg_kwargs.update(cfg_updates)
-    cfg = PegasusConfig(**cfg_kwargs)
-    torch_model = PegasusForConditionalGeneration(cfg)
-    sd = torch_model.model.state_dict()
-    mapping = {}
-    for k, v in tf_weights.items():
-        new_k = rename_state_dict_key(k)
-        if new_k not in sd:
-            raise ValueError(f"could not find new key {new_k} in state dict. (converted from {k})")
-
-        if "dense" in k or "proj" in new_k:
-            v = v.T
-        mapping[new_k] = torch.tensor(v, dtype=sd[new_k].dtype)
-        assert v.shape == sd[new_k].shape, f"{new_k}, {k}, {v.shape}, {sd[new_k].shape}"
-    # make sure embedding.padding_idx is respected
-    mapping["shared.weight"][cfg.pad_token_id] = torch.zeros_like(mapping["shared.weight"][cfg.pad_token_id + 1])
-    mapping["encoder.embed_tokens.weight"] = mapping["shared.weight"]
-    mapping["decoder.embed_tokens.weight"] = mapping["shared.weight"]
-    empty_biases = {k: torch.zeros_like(v) for k, v in sd.items() if k.endswith("bias") and k not in mapping}
-    mapping.update(**empty_biases)
-    missing, extra = torch_model.model.load_state_dict(mapping, strict=False)
-    unexpected_missing = [
-        k for k in missing if k not in ["encoder.embed_positions.weight", "decoder.embed_positions.weight"]
-    ]
-    assert unexpected_missing == [], f"no matches found for the following torch keys {unexpected_missing}"
-    assert extra == [], f"no matches found for the following tf keys {extra}"
-    return torch_model
-
-
-def get_tf_weights_as_numpy(path="./ckpt/aeslc/model.ckpt-32000") -> Dict:
-    init_vars = tf.train.list_variables(path)
-    tf_weights = {}
-    ignore_name = ["Adafactor", "global_step"]
-    for name, shape in tqdm(init_vars, desc="converting tf checkpoint to dict"):
-        skip_key = any(pat in name for pat in ignore_name)
-        if skip_key:
-            continue
-        array = tf.train.load_variable(path, name)
-        tf_weights[name] = array
-    return tf_weights
-
-
-def convert_pegasus_ckpt_to_pytorch(ckpt_path: str, save_dir: str):
-    # save tokenizer first
-    dataset = Path(ckpt_path).parent.name
-    desired_max_model_length = task_specific_params[f"summarization_{dataset}"]["max_position_embeddings"]
-    tok = PegasusTokenizer.from_pretrained("sshleifer/pegasus", model_max_length=desired_max_model_length)
-    assert tok.model_max_length == desired_max_model_length
-    tok.save_pretrained(save_dir)
-
-    # convert model
-    tf_weights = get_tf_weights_as_numpy(ckpt_path)
-    cfg_updates = task_specific_params[f"summarization_{dataset}"]
-    if dataset == "large":
-        cfg_updates["task_specific_params"] = task_specific_params
-    torch_model = convert_pegasus(tf_weights, cfg_updates)
-    torch_model.save_pretrained(save_dir)
-    sd = torch_model.state_dict()
-    sd.pop("model.decoder.embed_positions.weight")
-    sd.pop("model.encoder.embed_positions.weight")
-    torch.save(sd, Path(save_dir) / "pytorch_model.bin")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("tf_ckpt_path", type=str, help="passed to tf.train.list_variables")
-    parser.add_argument("save_dir", default=None, type=str, help="Path to the output PyTorch model.")
-    args = parser.parse_args()
-    if args.save_dir is None:
-        dataset = Path(args.tf_ckpt_path).parent.name
-        args.save_dir = os.path.join("pegasus", dataset)
-    convert_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir)
diff --git a/src/transformers/models/perceiver/convert_perceiver_haiku_to_pytorch.py b/src/transformers/models/perceiver/convert_perceiver_haiku_to_pytorch.py
deleted file mode 100644
index 082b9449374a..000000000000
--- a/src/transformers/models/perceiver/convert_perceiver_haiku_to_pytorch.py
+++ /dev/null
@@ -1,468 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Perceiver checkpoints originally implemented in Haiku."""
-
-import argparse
-import json
-import pickle
-from pathlib import Path
-
-import haiku as hk
-import numpy as np
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    PerceiverConfig,
-    PerceiverForImageClassificationConvProcessing,
-    PerceiverForImageClassificationFourier,
-    PerceiverForImageClassificationLearned,
-    PerceiverForMaskedLM,
-    PerceiverForMultimodalAutoencoding,
-    PerceiverForOpticalFlow,
-    PerceiverImageProcessor,
-    PerceiverTokenizer,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def prepare_img():
-    # We will verify our results on an image of a dog
-    url = "https://storage.googleapis.com/perceiver_io/dalmation.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-def rename_keys(state_dict, architecture):
-    for name in list(state_dict):
-        param = state_dict.pop(name)
-
-        # PREPROCESSORS
-        # rename text preprocessor embeddings (for MLM model)
-        name = name.replace("embed/embeddings", "input_preprocessor.embeddings.weight")
-        if name.startswith("trainable_position_encoding/pos_embs"):
-            name = name.replace(
-                "trainable_position_encoding/pos_embs", "input_preprocessor.position_embeddings.weight"
-            )
-
-        # rename image preprocessor embeddings (for image classification model with learned position embeddings)
-        name = name.replace("image_preprocessor/~/conv2_d/w", "input_preprocessor.convnet_1x1.weight")
-        name = name.replace("image_preprocessor/~/conv2_d/b", "input_preprocessor.convnet_1x1.bias")
-        name = name.replace(
-            "image_preprocessor/~_build_network_inputs/trainable_position_encoding/pos_embs",
-            "input_preprocessor.position_embeddings.position_embeddings",
-        )
-        name = name.replace(
-            "image_preprocessor/~_build_network_inputs/position_encoding_projector/linear/w",
-            "input_preprocessor.positions_projection.weight",
-        )
-        name = name.replace(
-            "image_preprocessor/~_build_network_inputs/position_encoding_projector/linear/b",
-            "input_preprocessor.positions_projection.bias",
-        )
-
-        # rename image preprocessor embeddings (for image classification model with conv processing)
-        if "counter" in name or "hidden" in name:
-            continue
-        name = name.replace(
-            "image_preprocessor/~/conv2_d_downsample/~/conv/w", "input_preprocessor.convnet.conv.weight"
-        )
-        name = name.replace(
-            "image_preprocessor/~/conv2_d_downsample/~/batchnorm/offset", "input_preprocessor.convnet.batchnorm.bias"
-        )
-        name = name.replace(
-            "image_preprocessor/~/conv2_d_downsample/~/batchnorm/scale", "input_preprocessor.convnet.batchnorm.weight"
-        )
-        name = name.replace(
-            "image_preprocessor/~/conv2_d_downsample/~/batchnorm/~/mean_ema/average",
-            "input_preprocessor.convnet.batchnorm.running_mean",
-        )
-        name = name.replace(
-            "image_preprocessor/~/conv2_d_downsample/~/batchnorm/~/var_ema/average",
-            "input_preprocessor.convnet.batchnorm.running_var",
-        )
-
-        # rename image preprocessor embeddings (for optical flow model)
-        name = name.replace("image_preprocessor/patches_linear/b", "input_preprocessor.conv_after_patches.bias")
-        name = name.replace("image_preprocessor/patches_linear/w", "input_preprocessor.conv_after_patches.weight")
-
-        # rename multimodal preprocessor embeddings
-        name = name.replace("multimodal_preprocessor/audio_mask_token/pos_embs", "input_preprocessor.mask.audio")
-        name = name.replace("multimodal_preprocessor/audio_padding/pos_embs", "input_preprocessor.padding.audio")
-        name = name.replace("multimodal_preprocessor/image_mask_token/pos_embs", "input_preprocessor.mask.image")
-        name = name.replace("multimodal_preprocessor/image_padding/pos_embs", "input_preprocessor.padding.image")
-        name = name.replace("multimodal_preprocessor/label_mask_token/pos_embs", "input_preprocessor.mask.label")
-        name = name.replace("multimodal_preprocessor/label_padding/pos_embs", "input_preprocessor.padding.label")
-
-        # DECODERS
-        # rename prefix of decoders
-        # multimodal autoencoding model
-        name = name.replace(
-            "multimodal_decoder/~/basic_decoder/cross_attention/", "decoder.decoder.decoding_cross_attention."
-        )
-        name = name.replace("multimodal_decoder/~decoder_query/audio_padding/pos_embs", "decoder.padding.audio")
-        name = name.replace("multimodal_decoder/~decoder_query/image_padding/pos_embs", "decoder.padding.image")
-        name = name.replace("multimodal_decoder/~decoder_query/label_padding/pos_embs", "decoder.padding.label")
-        name = name.replace("multimodal_decoder/~/basic_decoder/output/b", "decoder.decoder.final_layer.bias")
-        name = name.replace("multimodal_decoder/~/basic_decoder/output/w", "decoder.decoder.final_layer.weight")
-        if architecture == "multimodal_autoencoding":
-            name = name.replace(
-                "classification_decoder/~/basic_decoder/~/trainable_position_encoding/pos_embs",
-                "decoder.modalities.label.decoder.output_position_encodings.position_embeddings",
-            )
-        # flow model
-        name = name.replace(
-            "flow_decoder/~/basic_decoder/cross_attention/", "decoder.decoder.decoding_cross_attention."
-        )
-        name = name.replace("flow_decoder/~/basic_decoder/output/w", "decoder.decoder.final_layer.weight")
-        name = name.replace("flow_decoder/~/basic_decoder/output/b", "decoder.decoder.final_layer.bias")
-        # image models
-        name = name.replace(
-            "classification_decoder/~/basic_decoder/~/trainable_position_encoding/pos_embs",
-            "decoder.decoder.output_position_encodings.position_embeddings",
-        )
-        name = name.replace(
-            "basic_decoder/~/trainable_position_encoding/pos_embs",
-            "decoder.output_position_encodings.position_embeddings",
-        )
-        name = name.replace(
-            "classification_decoder/~/basic_decoder/cross_attention/", "decoder.decoder.decoding_cross_attention."
-        )
-        name = name.replace("classification_decoder/~/basic_decoder/output/b", "decoder.decoder.final_layer.bias")
-        name = name.replace("classification_decoder/~/basic_decoder/output/w", "decoder.decoder.final_layer.weight")
-        name = name = name.replace("classification_decoder/~/basic_decoder/~/", "decoder.decoder.")
-        name = name.replace("basic_decoder/cross_attention/", "decoder.decoding_cross_attention.")
-        name = name.replace("basic_decoder/~/", "decoder.")
-
-        # POSTPROCESSORS
-        name = name.replace(
-            "projection_postprocessor/linear/b", "output_postprocessor.modalities.image.classifier.bias"
-        )
-        name = name.replace(
-            "projection_postprocessor/linear/w", "output_postprocessor.modalities.image.classifier.weight"
-        )
-        name = name.replace(
-            "classification_postprocessor/linear/b", "output_postprocessor.modalities.label.classifier.bias"
-        )
-        name = name.replace(
-            "classification_postprocessor/linear/w", "output_postprocessor.modalities.label.classifier.weight"
-        )
-        name = name.replace("audio_postprocessor/linear/b", "output_postprocessor.modalities.audio.classifier.bias")
-        name = name.replace("audio_postprocessor/linear/w", "output_postprocessor.modalities.audio.classifier.weight")
-
-        # PERCEIVER MODEL
-
-        # rename latent embeddings
-        name = name.replace("perceiver_encoder/~/trainable_position_encoding/pos_embs", "embeddings.latents")
-        # rename latent embeddings (for multimodal model)
-        name = name.replace("encoder/~/trainable_position_encoding/pos_embs", "embeddings.latents")
-
-        # rename prefixes
-        if name.startswith("perceiver_encoder/~/"):
-            if "self_attention" in name:
-                suffix = "self_attends."
-            else:
-                suffix = ""
-            name = name.replace("perceiver_encoder/~/", "encoder." + suffix)
-        if name.startswith("encoder/~/"):
-            if "self_attention" in name:
-                suffix = "self_attends."
-            else:
-                suffix = ""
-            name = name.replace("encoder/~/", "encoder." + suffix)
-        # rename layernorm parameters
-        if "offset" in name:
-            name = name.replace("offset", "bias")
-        if "scale" in name:
-            name = name.replace("scale", "weight")
-        # in HuggingFace, the layernorm in between attention + MLP is just called "layernorm"
-        # rename layernorm in between attention + MLP of cross-attention
-        if "cross_attention" in name and "layer_norm_2" in name:
-            name = name.replace("layer_norm_2", "layernorm")
-        # rename layernorm in between attention + MLP of self-attention
-        if "self_attention" in name and "layer_norm_1" in name:
-            name = name.replace("layer_norm_1", "layernorm")
-
-        # in HuggingFace, the layernorms for queries + keys are called "layernorm1" and "layernorm2"
-        if "cross_attention" in name and "layer_norm_1" in name:
-            name = name.replace("layer_norm_1", "attention.self.layernorm2")
-        if "cross_attention" in name and "layer_norm" in name:
-            name = name.replace("layer_norm", "attention.self.layernorm1")
-        if "self_attention" in name and "layer_norm" in name:
-            name = name.replace("layer_norm", "attention.self.layernorm1")
-
-        # rename special characters by dots
-        name = name.replace("-", ".")
-        name = name.replace("/", ".")
-        # rename keys, queries, values and output of attention layers
-        if ("cross_attention" in name or "self_attention" in name) and "mlp" not in name:
-            if "linear.b" in name:
-                name = name.replace("linear.b", "self.query.bias")
-            if "linear.w" in name:
-                name = name.replace("linear.w", "self.query.weight")
-            if "linear_1.b" in name:
-                name = name.replace("linear_1.b", "self.key.bias")
-            if "linear_1.w" in name:
-                name = name.replace("linear_1.w", "self.key.weight")
-            if "linear_2.b" in name:
-                name = name.replace("linear_2.b", "self.value.bias")
-            if "linear_2.w" in name:
-                name = name.replace("linear_2.w", "self.value.weight")
-            if "linear_3.b" in name:
-                name = name.replace("linear_3.b", "output.dense.bias")
-            if "linear_3.w" in name:
-                name = name.replace("linear_3.w", "output.dense.weight")
-        if "self_attention_" in name:
-            name = name.replace("self_attention_", "")
-        if "self_attention" in name:
-            name = name.replace("self_attention", "0")
-        # rename dense layers of 2-layer MLP
-        if "mlp" in name:
-            if "linear.b" in name:
-                name = name.replace("linear.b", "dense1.bias")
-            if "linear.w" in name:
-                name = name.replace("linear.w", "dense1.weight")
-            if "linear_1.b" in name:
-                name = name.replace("linear_1.b", "dense2.bias")
-            if "linear_1.w" in name:
-                name = name.replace("linear_1.w", "dense2.weight")
-
-        # finally, TRANSPOSE if kernel and not embedding layer, and set value
-        if name[-6:] == "weight" and "embeddings" not in name:
-            param = np.transpose(param)
-
-        # if batchnorm, we need to squeeze it
-        if "batchnorm" in name:
-            param = np.squeeze(param)
-
-        if "embedding_decoder" not in name:
-            state_dict["perceiver." + name] = torch.from_numpy(param)
-        else:
-            state_dict[name] = torch.from_numpy(param)
-
-
-@torch.no_grad()
-def convert_perceiver_checkpoint(pickle_file, pytorch_dump_folder_path, architecture="MLM"):
-    """
-    Copy/paste/tweak model's weights to our Perceiver structure.
-    """
-
-    # load parameters as FlatMapping data structure
-    with open(pickle_file, "rb") as f:
-        checkpoint = pickle.loads(f.read())
-
-    state = None
-    if isinstance(checkpoint, dict) and architecture in [
-        "image_classification",
-        "image_classification_fourier",
-        "image_classification_conv",
-    ]:
-        # the image classification_conv checkpoint also has batchnorm states (running_mean and running_var)
-        params = checkpoint["params"]
-        state = checkpoint["state"]
-    else:
-        params = checkpoint
-
-    # turn into initial state dict
-    state_dict = {}
-    for scope_name, parameters in hk.data_structures.to_mutable_dict(params).items():
-        for param_name, param in parameters.items():
-            state_dict[scope_name + "/" + param_name] = param
-
-    if state is not None:
-        # add state variables
-        for scope_name, parameters in hk.data_structures.to_mutable_dict(state).items():
-            for param_name, param in parameters.items():
-                state_dict[scope_name + "/" + param_name] = param
-
-    # rename keys
-    rename_keys(state_dict, architecture=architecture)
-
-    # load HuggingFace model
-    config = PerceiverConfig()
-    subsampling = None
-    repo_id = "huggingface/label-files"
-    if architecture == "MLM":
-        config.qk_channels = 8 * 32
-        config.v_channels = 1280
-        model = PerceiverForMaskedLM(config)
-    elif "image_classification" in architecture:
-        config.num_latents = 512
-        config.d_latents = 1024
-        config.d_model = 512
-        config.num_blocks = 8
-        config.num_self_attends_per_block = 6
-        config.num_cross_attention_heads = 1
-        config.num_self_attention_heads = 8
-        config.qk_channels = None
-        config.v_channels = None
-        # set labels
-        config.num_labels = 1000
-        filename = "imagenet-1k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-        if architecture == "image_classification":
-            config.image_size = 224
-            model = PerceiverForImageClassificationLearned(config)
-        elif architecture == "image_classification_fourier":
-            config.d_model = 261
-            model = PerceiverForImageClassificationFourier(config)
-        elif architecture == "image_classification_conv":
-            config.d_model = 322
-            model = PerceiverForImageClassificationConvProcessing(config)
-        else:
-            raise ValueError(f"Architecture {architecture} not supported")
-    elif architecture == "optical_flow":
-        config.num_latents = 2048
-        config.d_latents = 512
-        config.d_model = 322
-        config.num_blocks = 1
-        config.num_self_attends_per_block = 24
-        config.num_self_attention_heads = 16
-        config.num_cross_attention_heads = 1
-        model = PerceiverForOpticalFlow(config)
-    elif architecture == "multimodal_autoencoding":
-        config.num_latents = 28 * 28 * 1
-        config.d_latents = 512
-        config.d_model = 704
-        config.num_blocks = 1
-        config.num_self_attends_per_block = 8
-        config.num_self_attention_heads = 8
-        config.num_cross_attention_heads = 1
-        config.num_labels = 700
-        # define dummy inputs + subsampling (as each forward pass is only on a chunk of image + audio data)
-        images = torch.randn((1, 16, 3, 224, 224))
-        audio = torch.randn((1, 30720, 1))
-        nchunks = 128
-        image_chunk_size = np.prod((16, 224, 224)) // nchunks
-        audio_chunk_size = audio.shape[1] // config.samples_per_patch // nchunks
-        # process the first chunk
-        chunk_idx = 0
-        subsampling = {
-            "image": torch.arange(image_chunk_size * chunk_idx, image_chunk_size * (chunk_idx + 1)),
-            "audio": torch.arange(audio_chunk_size * chunk_idx, audio_chunk_size * (chunk_idx + 1)),
-            "label": None,
-        }
-        model = PerceiverForMultimodalAutoencoding(config)
-        # set labels
-        filename = "kinetics700-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-    else:
-        raise ValueError(f"Architecture {architecture} not supported")
-    model.eval()
-
-    # load weights
-    model.load_state_dict(state_dict)
-
-    # prepare dummy input
-    input_mask = None
-    if architecture == "MLM":
-        tokenizer = PerceiverTokenizer.from_pretrained("/Users/NielsRogge/Documents/Perceiver/Tokenizer files")
-        text = "This is an incomplete sentence where some words are missing."
-        encoding = tokenizer(text, padding="max_length", return_tensors="pt")
-        # mask " missing.". Note that the model performs much better if the masked chunk starts with a space.
-        encoding.input_ids[0, 51:60] = tokenizer.mask_token_id
-        inputs = encoding.input_ids
-        input_mask = encoding.attention_mask
-    elif architecture in ["image_classification", "image_classification_fourier", "image_classification_conv"]:
-        image_processor = PerceiverImageProcessor()
-        image = prepare_img()
-        encoding = image_processor(image, return_tensors="pt")
-        inputs = encoding.pixel_values
-    elif architecture == "optical_flow":
-        inputs = torch.randn(1, 2, 27, 368, 496)
-    elif architecture == "multimodal_autoencoding":
-        images = torch.randn((1, 16, 3, 224, 224))
-        audio = torch.randn((1, 30720, 1))
-        inputs = {"image": images, "audio": audio, "label": torch.zeros((images.shape[0], 700))}
-
-    # forward pass
-    if architecture == "multimodal_autoencoding":
-        outputs = model(inputs=inputs, attention_mask=input_mask, subsampled_output_points=subsampling)
-    else:
-        outputs = model(inputs=inputs, attention_mask=input_mask)
-    logits = outputs.logits
-
-    # verify logits
-    if not isinstance(logits, dict):
-        print("Shape of logits:", logits.shape)
-    else:
-        for k, v in logits.items():
-            print(f"Shape of logits of modality {k}", v.shape)
-
-    if architecture == "MLM":
-        expected_slice = torch.tensor(
-            [[-11.8336, -11.6850, -11.8483], [-12.8149, -12.5863, -12.7904], [-12.8440, -12.6410, -12.8646]]
-        )
-        assert torch.allclose(logits[0, :3, :3], expected_slice)
-        masked_tokens_predictions = logits[0, 51:60].argmax(dim=-1).tolist()
-        expected_list = [38, 115, 111, 121, 121, 111, 116, 109, 52]
-        assert masked_tokens_predictions == expected_list
-        print("Greedy predictions:")
-        print(masked_tokens_predictions)
-        print()
-        print("Predicted string:")
-        print(tokenizer.decode(masked_tokens_predictions))
-
-    elif architecture in ["image_classification", "image_classification_fourier", "image_classification_conv"]:
-        print("Predicted class:", model.config.id2label[logits.argmax(-1).item()])
-
-    # Finally, save files
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--pickle_file",
-        type=str,
-        default=None,
-        required=True,
-        help="Path to local pickle file of a Perceiver checkpoint you'd like to convert.\n"
-        "Given the files are in the pickle format, please be wary of passing it files you trust.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the output PyTorch model directory, provided as a string.",
-    )
-    parser.add_argument(
-        "--architecture",
-        default="MLM",
-        type=str,
-        help="""
-        Architecture, provided as a string. One of 'MLM', 'image_classification', image_classification_fourier',
-        image_classification_fourier', 'optical_flow' or 'multimodal_autoencoding'.
-        """,
-    )
-
-    args = parser.parse_args()
-    convert_perceiver_checkpoint(args.pickle_file, args.pytorch_dump_folder_path, args.architecture)
diff --git a/src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py b/src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py
deleted file mode 100644
index 6cd61b9f71c8..000000000000
--- a/src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py
+++ /dev/null
@@ -1,129 +0,0 @@
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import os
-import warnings
-
-import flatdict
-import torch
-
-from transformers import LlamaTokenizer, PersimmonConfig, PersimmonForCausalLM
-
-
-try:
-    from transformers import LlamaTokenizerFast
-
-    tokenizer_class = LlamaTokenizerFast
-except ImportError as e:
-    warnings.warn(e)
-    warnings.warn(
-        "The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion"
-    )
-    tokenizer_class = LlamaTokenizer
-
-"""
-Sample usage:
-
-```
-git clone https://github.com/persimmon-ai-labs/adept-inference
-wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_base_model_release.tar
-wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_chat_model_release.tar
-python src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py  --input_dir /path/to/downloaded/persimmon/weights/ --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import PersimmonForCausalLM, PersimmonTokenizer
-
-model = PersimmonForCausalLM.from_pretrained("/output/path")
-tokenizer = PersimmonTokenizer.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "self_attention": "self_attn",
-    "language_model.encoder": "model",
-    "word_embeddings_for_head": "lm_head",
-    "language_model.embedding.word_embeddings": "model.embed_tokens",
-}
-
-KEYS_TO_REMOVE = "rotary_emb.inv_freq"
-
-
-def rename_state_dict(state_dict):
-    model_state_dict = {}
-    for key, value in state_dict.items():
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-        if KEYS_TO_REMOVE in key:
-            continue
-        model_state_dict[key] = value
-    return model_state_dict
-
-
-def convert_persimmon_checkpoint(pytorch_dump_folder_path, ada_lib_path, pt_model_path, safe_serialization=False):
-    import sys
-
-    sys.path.insert(0, ada_lib_path)
-    model_state_dict_base = torch.load(pt_model_path, map_location="cpu")
-    state_dict = flatdict.FlatDict(model_state_dict_base["model"], ".")
-    state_dict = rename_state_dict(state_dict)
-
-    transformers_config = PersimmonConfig()
-    model = PersimmonForCausalLM(transformers_config, eos_token_id=71013, bos_token_id=71013).to(torch.bfloat16)
-    model.load_state_dict(state_dict)
-    model.save_pretrained(pytorch_dump_folder_path, safe_serialization=safe_serialization)
-    transformers_config.save_pretrained(pytorch_dump_folder_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        help="Location of Persimmon weights, which contains tokenizer.model and model folders",
-    )
-    parser.add_argument(
-        "--pt_model_path",
-        help="Location of Persimmon `model_optim_rng.pt`",
-    )
-    parser.add_argument(
-        "--output_dir",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--ada_lib_path",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument("--safe_serialization", type=bool, help="Whether or not to save using `safetensors`.")
-    args = parser.parse_args()
-    spm_path = os.path.join(args.input_dir, "adept_vocab.model")
-
-    convert_persimmon_checkpoint(
-        pytorch_dump_folder_path=args.output_dir,
-        pt_model_path=args.pt_model_path,
-        safe_serialization=args.safe_serialization,
-        ada_lib_path=args.ada_lib_path,
-    )
-    tokenizer = tokenizer_class(spm_path, bos_token="|ENDOFTEXT|", eos_token="|ENDOFTEXT|")
-    tokenizer.save_pretrained(args.output_dir)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/phi/convert_phi_weights_to_hf.py b/src/transformers/models/phi/convert_phi_weights_to_hf.py
deleted file mode 100644
index 097423366115..000000000000
--- a/src/transformers/models/phi/convert_phi_weights_to_hf.py
+++ /dev/null
@@ -1,207 +0,0 @@
-# coding=utf-8
-# Copyright 2023 Microsoft and the HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Weights conversion script for Phi
-
-This script downloads both Phi-1 and Phi-1.5 checkpoints to "checkpoint_path" and then converts the weights to
-HugfgingFace model's format and saves them in "pytorch_dump_folder_path".
-
-Example : $python ./convert_phi_weights_to_hf.py --model_name "microsoft/phi-2" --pytorch_dump_folder ./dump_folder/ --checkpoint_path ./ckpt_path/
-"""
-
-import argparse
-import gc
-import os
-
-import safetensors
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import PhiConfig, PhiForCausalLM
-
-
-_MODELS = {
-    "microsoft/phi-1": ["https://huggingface.co/microsoft/phi-1/blob/main/pytorch_model.bin"],
-    "microsoft/phi-1_5": ["https://huggingface.co/microsoft/phi-1_5/blob/main/pytorch_model.bin"],
-    "microsoft/phi-2": [
-        "https://huggingface.co/microsoft/phi-2/blob/main/model-00001-of-00002.safetensors",
-        "https://huggingface.co/microsoft/phi-2/blob/main/model-00002-of-00002.safetensors",
-    ],
-}
-
-PHI_MAPPING = {
-    "transformer.embd.wte.weight": "model.embed_tokens.weight",
-    "lm_head.linear": "lm_head",
-    "lm_head.ln": "model.final_layernorm",
-    "layers": "model.layers",
-    "transformer": "model",
-    ".h.": ".layers.",
-    "ln": "input_layernorm",
-    "mixer": "self_attn",
-    "Wqkv": "query_key_value",
-    "out_proj": "dense",
-}
-
-
-def convert_weights(original_weights, mapping, config):
-    converted_weights = {}
-    original_weights_keys = sorted(original_weights.keys())
-
-    for original_weights_key in original_weights_keys:
-        new_key = original_weights_key
-
-        if "rotary_emb" in new_key:
-            continue
-
-        if "Wqkv" in new_key:
-            if "weight" in new_key:
-                weight = original_weights[new_key]
-                weights_shape = weight.shape
-                weight = (
-                    weight.view(3, config.num_attention_heads, -1, config.hidden_size)
-                    .transpose(0, 1)
-                    .reshape(*weights_shape)
-                )
-                original_weights[new_key] = weight
-            elif "bias" in new_key:
-                bias = original_weights[new_key]
-                bias_shape = bias.shape
-                bias = bias.view(3, config.num_attention_heads, -1).transpose(0, 1).reshape(*bias_shape)
-                original_weights[new_key] = bias
-
-        for k, v in mapping.items():
-            if k in new_key:
-                new_key = new_key.replace(k, v)
-
-        converted_weights[new_key] = original_weights.pop(original_weights_key)
-
-    return converted_weights
-
-
-def _download(url: str, root: str):
-    repo_id = f"{url.split('/')[3]}/{url.split('/')[4]}"
-    filename = f"{url.split('/')[-1]}"
-    hf_hub_download(
-        repo_id=repo_id,
-        filename=filename,
-        force_filename=root,
-        local_dir_use_symlinks=False,
-    )
-
-
-def convert_phi_weights(
-    model_name, checkpoint_path, pytorch_dump_folder_path, use_cuda, save_weights_directly, _MODELS
-):
-    _MODELS = _MODELS if model_name not in _MODELS.keys() else {model_name: _MODELS.get(model_name)}
-    device = "cuda" if torch.cuda.is_available() and use_cuda else "cpu"
-    for model_name, model_url in _MODELS.items():
-        converted_checkpoint = {}
-        model_checkpoint = {}
-
-        # for phi-2 the weights are stored in 2 different safetensors file so we need to iterate over that list and download one at a time
-        for model_each_url in model_url:
-            model_path = os.path.join(checkpoint_path, model_name + "_" + model_each_url.split("/")[-1])
-            if not os.path.exists(model_path):
-                print(f"\n{model_name} was not found! Downloading it to {model_path}")
-                _download(url=model_each_url, root=model_path)
-
-            if model_path.endswith("safetensors"):
-                loaded_weights = safetensors.torch.load_file(model_path, device=device)
-            else:
-                loaded_weights = torch.load(model_path, map_location=device, weights_only=True)
-            model_checkpoint.update(**loaded_weights)
-
-        model_type = model_name.split("/")[1]  # phi-1 or phi-1_5 or phi-2
-
-        # init the config for phi-1 and phi-1.5
-        config = PhiConfig()
-        # if we are dealing with phi-2 then update the config
-        if model_type == "phi-2":
-            config.hidden_size = 2560
-            config.intermediate_size = 10240
-            config.num_hidden_layers = 32
-            config.resid_pdrop = 0.1
-            config.partial_rotary_factor = 0.4
-            config.num_hidden_layers = 32
-            config.torch_dtype = "float16"
-
-        # Converting the weights
-        converted_checkpoint.update(**convert_weights(model_checkpoint, PHI_MAPPING, config))
-
-        # Save either the whole model or the converted weights
-        if save_weights_directly:
-            save_weights_path = os.path.join(pytorch_dump_folder_path, model_type + "_pytorch_model.bin")
-            torch.save(converted_checkpoint, save_weights_path)
-            print(f"Model weights saved at {save_weights_path}!")
-
-        else:
-            model = PhiForCausalLM(config).to(device)
-            model.load_state_dict(converted_checkpoint, strict=True)
-            save_model_path = os.path.join(pytorch_dump_folder_path, model_type)
-            model.save_pretrained(save_model_path)
-            print(f"Model saved at {save_model_path}!")
-
-            # release GPU memory for the 2nd model if cuda was used.
-            del config, model
-
-        # release GPU memory for the 2nd model if cuda was used.
-        del model_checkpoint, converted_checkpoint
-        if use_cuda:
-            torch.cuda.empty_cache()
-        gc.collect()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # # Required parameters
-    parser.add_argument(
-        "--model_name",
-        type=str,
-        help="Name of the model to convert. (Please enter one of the following: phi-1, phi-1_5, phi-2). If nothing is provided, all models will be converted.",
-        default=None,
-    )
-    parser.add_argument(
-        "--checkpoint_path", type=str, help="Path to the folder of downloaded checkpoints. (Please enter full path)"
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model. (Please enter full path)",
-    )
-    parser.add_argument(
-        "--use_cuda",
-        default=False,
-        type=bool,
-        help="Whether to load the weights on GPU during conversion or not, False by default",
-    )
-    parser.add_argument(
-        "--save_weights_directly",
-        default=True,
-        type=bool,
-        help="Whether to save the weights directly after conversion or load the weight to the Phi model and then save "
-        "the Phi model along with weights. True by default",
-    )
-
-    args = parser.parse_args()
-    convert_phi_weights(
-        args.model_name,
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.use_cuda,
-        args.save_weights_directly,
-        _MODELS,
-    )
diff --git a/src/transformers/models/phi4_multimodal/convert_phi4_multimodal_weights_to_hf.py b/src/transformers/models/phi4_multimodal/convert_phi4_multimodal_weights_to_hf.py
deleted file mode 100644
index c7cae2ab007c..000000000000
--- a/src/transformers/models/phi4_multimodal/convert_phi4_multimodal_weights_to_hf.py
+++ /dev/null
@@ -1,229 +0,0 @@
-# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import json
-import os
-import re
-
-import torch
-from peft import LoraConfig
-from safetensors.torch import load_file, save_file
-
-from transformers import (
-    Phi4MultimodalAudioConfig,
-    Phi4MultimodalConfig,
-    Phi4MultimodalForCausalLM,
-    Phi4MultimodalProcessor,
-    Phi4MultimodalVisionConfig,
-)
-
-
-# fmt: off
-STATE_DICT_MAPPING = {
-    r"^model.embed_tokens_extend.audio_embed.encoder.encoders.(\d+).feed_forward_(in|out).net.0.linear": r"model.embed_tokens_extend.audio_embed.encoder.encoders.\1.feed_forward_\2.gate_up_proj",
-    r"^model.embed_tokens_extend.audio_embed.encoder.encoders.(\d+).feed_forward_(in|out).net.2": r"model.embed_tokens_extend.audio_embed.encoder.encoders.\1.feed_forward_\2.down_proj",
-
-    r"^model.embed_tokens_extend.audio_embed.encoder.encoders.(\d+).self_attn.linear_(q|k|v)": r"model.embed_tokens_extend.audio_embed.encoder.encoders.\1.self_attn.\2_proj",
-    r"^model.embed_tokens_extend.audio_embed.encoder.encoders.(\d+).self_attn.linear_out": r"model.embed_tokens_extend.audio_embed.encoder.encoders.\1.self_attn.o_proj",
-
-    r"^model.embed_tokens_extend.image_embed.img_projection.0": r"model.embed_tokens_extend.image_embed.img_projection_up",
-    r"^model.embed_tokens_extend.image_embed.img_projection.2": r"model.embed_tokens_extend.image_embed.img_projection_down",
-
-    r"^model.embed_tokens_extend.image_embed.glb_GN": r"model.embed_tokens_extend.image_embed.global_img_feature_extensor",
-    r"^model.embed_tokens_extend.image_embed.sub_GN": r"model.embed_tokens_extend.image_embed.sub_img_feature_extensor",
-
-    r"^model.embed_tokens_extend.audio_embed.audio_projection.speech.0": r"model.embed_tokens_extend.audio_embed.up_proj_for_speech",
-    r"^model.embed_tokens_extend.audio_embed.audio_projection.speech.2": r"model.embed_tokens_extend.audio_embed.down_proj_for_speech",
-    r"^model.embed_tokens_extend.audio_embed.audio_projection.vision.0": r"model.embed_tokens_extend.audio_embed.up_proj_for_vision_speech",
-    r"^model.embed_tokens_extend.audio_embed.audio_projection.vision.2": r"model.embed_tokens_extend.audio_embed.down_proj_for_vision_speech",
-}
-# fmt: on
-
-
-def map_old_key_to_new(old_key):
-    """Map of a key of the original state dict to the equivalent key in HF format"""
-    for pattern, replacement in STATE_DICT_MAPPING.items():
-        new_key, n_replace = re.subn(pattern, replacement, old_key)
-        # Early exit of the loop
-        if n_replace > 0:
-            return new_key
-
-    # The state dict contains lora keys....
-    if "lora" in old_key:
-        return None
-    # This extracts the original weight before adding the lora adapter
-    if "base_layer." in old_key:
-        return old_key.replace("base_layer.", "")
-
-    # not part of the key mapping, we keep the original name
-    return old_key
-
-
-def convert_state_dict(original_state_dict: dict):
-    """Convert a state dict file."""
-    new_dict = {}
-    for old_key, tensor in original_state_dict.items():
-        new_key = map_old_key_to_new(old_key)
-        if new_key is not None:
-            new_dict[new_key] = tensor
-    return new_dict
-
-
-def convert_config(original_config: dict):
-    # Remove unused args
-    original_config.pop("_name_or_path", None)
-    original_config.pop("architectures", None)
-    original_config.pop("auto_map", None)
-    original_config.pop("vision_lora", None)
-    original_config.pop("speech_lora", None)
-    original_config.pop("transformers_version", None)
-    original_config.pop("_attn_implementation", None)
-
-    embd_layer = original_config.pop("embd_layer")
-    audio_embd_layer = embd_layer["audio_embd_layer"]
-    vision_embd_layer = embd_layer["image_embd_layer"]
-
-    # Keep only some of the subdict
-    keep_audio_embd_layer = ["downsample_rate"]
-    keep_vision_embd_layer = ["crop_size"]
-    audio_embd_layer = {k: v for k, v in audio_embd_layer.items() if k in keep_audio_embd_layer}
-    vision_embd_layer = {k: v for k, v in vision_embd_layer.items() if k in keep_vision_embd_layer}
-
-    audio_config = original_config.pop("audio_processor")["config"]
-    # remove
-    audio_config.pop("activation_checkpointing", None)
-    audio_config.pop("cnn_layer_norm", None)
-    audio_config.pop("input_layer", None)
-    audio_config.pop("batch_norm", None)
-    audio_config.pop("encoder_embedding_config", None)
-    audio_config.pop("ext_pw_kernel_size", None)
-    audio_config.pop("bias_in_glu", None)
-    audio_config.pop("causal", None)
-    # rename
-    audio_config["hidden_size"] = audio_config.pop("attention_dim")
-    audio_config["num_attention_heads"] = audio_config.pop("attention_heads")
-    audio_config["intermediate_size"] = audio_config.pop("linear_units")
-    audio_config["nemo_conv_channels"] = audio_config.pop("nemo_conv_settings")["conv_channels"]
-    audio_config["bias_max_distance"] = audio_config.pop("relative_attention_bias_args")["t5_bias_max_distance"]
-    # add
-    audio_config = {**audio_config, **audio_embd_layer}
-
-    # Create transformers config objects
-    audio_config = Phi4MultimodalAudioConfig(**audio_config)
-    vision_config = Phi4MultimodalVisionConfig(**vision_embd_layer)
-
-    # Add 2nd eos to config
-    original_config["eos_token_id"] = [199999, 200020]
-
-    new_config = Phi4MultimodalConfig(**original_config, vision_config=vision_config, audio_config=audio_config)
-    return new_config
-
-
-def read_json(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-def convert_and_write_model(input_dir: str, output_dir: str):
-    """Convert the model and save it (this implicitly save the config as well)."""
-    original_config = read_json(os.path.join(input_dir, "config.json"))
-    config = convert_config(original_config)
-
-    full_state_dict = {}
-    shards = [file for file in os.listdir(input_dir) if file.endswith(".safetensors")]
-    for shard_file in shards:
-        original_state_dict = load_file(os.path.join(input_dir, shard_file))
-        new_dict = convert_state_dict(original_state_dict)
-        full_state_dict.update(new_dict)
-
-    # Load weights into model and resave them
-    with torch.device("meta"):
-        model = Phi4MultimodalForCausalLM(config)
-    missing, unexpected = model.load_state_dict(full_state_dict, strict=False, assign=True)
-    # The lm_head is missing because it's tied
-    if missing != ["lm_head.weight"]:
-        raise ValueError("Missing keys:\n{missing}")
-    if len(unexpected) > 0:
-        raise ValueError(f"Unexpected keys:\n{unexpected}")
-
-    model.tie_weights()
-    model.save_pretrained(output_dir)
-
-
-def convert_and_save_processor(input_dir: str, output_dir: str):
-    """Convert the processor."""
-    processor = Phi4MultimodalProcessor.from_pretrained(input_dir)
-    del processor.image_processor.auto_map
-    del processor.audio_processor.auto_map
-    processor.chat_template = processor.tokenizer.chat_template
-    processor.tokenizer.extra_special_tokens = {"image_token": "<|endoftext10|>", "audio_token": "<|endoftext11|>"}
-    processor.save_pretrained(output_dir)
-
-
-def extract_adapters_data(input_dir: str, output_dir: str):
-    """Extract adapters data from the state dict and save weights and configs."""
-    speech_lora = {}
-    vision_lora = {}
-    shards = [file for file in os.listdir(input_dir) if file.endswith(".safetensors")]
-    for shard_file in shards:
-        original_state_dict = load_file(os.path.join(input_dir, shard_file))
-        for k, v in original_state_dict.items():
-            if "lora" in k:
-                if "speech" in k:
-                    speech_lora[k.replace("speech.", "")] = v
-                elif "vision" in k:
-                    vision_lora[k.replace("vision.", "")] = v
-
-    # Create and save the lora configs
-    speech_lora_config = LoraConfig(
-        r=320,
-        lora_alpha=640,
-        target_modules=r"model.layers.\d+.((self_attn.(qkv|o)_proj)|(mlp.(gate_up|down)_proj))",
-        lora_dropout=0.01,
-        task_type="CAUSAL_LM",
-    )
-    speech_lora_config.save_pretrained(os.path.join(output_dir, "speech-lora"))
-    vision_lora_config = LoraConfig(
-        r=256,
-        lora_alpha=512,
-        target_modules=r"model.layers.\d+.((self_attn.(qkv|o)_proj)|(mlp.(gate_up|down)_proj))",
-        lora_dropout=0.0,
-        task_type="CAUSAL_LM",
-    )
-    vision_lora_config.save_pretrained(os.path.join(output_dir, "vision-lora"))
-
-    save_file(speech_lora, os.path.join(output_dir, "speech-lora", "adapter_model.safetensors"))
-    save_file(vision_lora, os.path.join(output_dir, "vision-lora", "adapter_model.safetensors"))
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "input_dir",
-        help="Location of the model folder containing the weights and configs.",
-    )
-    parser.add_argument(
-        "output_dir",
-        help="Location to write HF model.",
-    )
-    args = parser.parse_args()
-
-    # Convert
-    convert_and_write_model(args.input_dir, args.output_dir)
-    convert_and_save_processor(args.input_dir, args.output_dir)
-    extract_adapters_data(args.input_dir, args.output_dir)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/pix2struct/convert_pix2struct_original_pytorch_to_hf.py b/src/transformers/models/pix2struct/convert_pix2struct_original_pytorch_to_hf.py
deleted file mode 100644
index 457c2236694a..000000000000
--- a/src/transformers/models/pix2struct/convert_pix2struct_original_pytorch_to_hf.py
+++ /dev/null
@@ -1,155 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import os
-import re
-
-import torch
-from flax.traverse_util import flatten_dict
-from t5x import checkpoints
-
-from transformers import (
-    AutoTokenizer,
-    Pix2StructConfig,
-    Pix2StructForConditionalGeneration,
-    Pix2StructImageProcessor,
-    Pix2StructProcessor,
-    Pix2StructTextConfig,
-    Pix2StructVisionConfig,
-)
-
-
-def get_flax_param(t5x_checkpoint_path):
-    flax_params = checkpoints.load_t5x_checkpoint(t5x_checkpoint_path)
-    flax_params = flatten_dict(flax_params)
-    return flax_params
-
-
-def rename_and_convert_flax_params(flax_dict):
-    converted_dict = {}
-
-    CONVERSION_MAPPING = {
-        "token_embedder": "embeddings",
-        "encoder_norm": "layernorm",
-        "kernel": "weight",
-        ".out": ".output",
-        "scale": "weight",
-        "embedders_0.pos_embedding": "row_embedder.weight",
-        "embedders_1.pos_embedding": "column_embedder.weight",
-    }
-
-    DECODER_CONVERSION_MAPPING = {
-        "query": "attention.query",
-        "key": "attention.key",
-        "value": "attention.value",
-        "output.dense": "output",
-        "encoder_decoder_attention.o": "encoder_decoder_attention.attention.o",
-        "pre_self_attention_layer_norm": "self_attention.layer_norm",
-        "pre_cross_attention_layer_norm": "encoder_decoder_attention.layer_norm",
-        "mlp.": "mlp.DenseReluDense.",
-        "pre_mlp_layer_norm": "mlp.layer_norm",
-        "self_attention.o": "self_attention.attention.o",
-        "decoder.embeddings.embedding": "decoder.embed_tokens.weight",
-        "decoder.relpos_bias.rel_embedding": "decoder.layer.0.self_attention.attention.relative_attention_bias.weight",
-        "decoder.decoder_norm.weight": "decoder.final_layer_norm.weight",
-        "decoder.logits_dense.weight": "decoder.lm_head.weight",
-    }
-
-    for key in flax_dict.keys():
-        if "target" in key:
-            # remove the first prefix from the key
-            new_key = ".".join(key[1:])
-
-            # rename the key
-            for old, new in CONVERSION_MAPPING.items():
-                new_key = new_key.replace(old, new)
-
-            if "decoder" in new_key:
-                for old, new in DECODER_CONVERSION_MAPPING.items():
-                    new_key = new_key.replace(old, new)
-
-            if "layers" in new_key and "decoder" not in new_key:
-                # use regex to replace the layer number
-                new_key = re.sub(r"layers_(\d+)", r"layer.\1", new_key)
-                new_key = new_key.replace("encoder", "encoder.encoder")
-
-            elif "layers" in new_key and "decoder" in new_key:
-                # use regex to replace the layer number
-                new_key = re.sub(r"layers_(\d+)", r"layer.\1", new_key)
-
-            converted_dict[new_key] = flax_dict[key]
-
-    converted_torch_dict = {}
-    # convert converted_dict into torch format
-    for key in converted_dict.keys():
-        if ("embed_tokens" not in key) and ("embedder" not in key):
-            converted_torch_dict[key] = torch.from_numpy(converted_dict[key].T)
-        else:
-            converted_torch_dict[key] = torch.from_numpy(converted_dict[key])
-
-    return converted_torch_dict
-
-
-def convert_pix2struct_original_pytorch_checkpoint_to_hf(
-    t5x_checkpoint_path, pytorch_dump_folder_path, use_large=False, is_vqa=False
-):
-    flax_params = get_flax_param(t5x_checkpoint_path)
-
-    if not use_large:
-        encoder_config = Pix2StructVisionConfig()
-        decoder_config = Pix2StructTextConfig()
-    else:
-        encoder_config = Pix2StructVisionConfig(
-            hidden_size=1536, d_ff=3968, num_attention_heads=24, num_hidden_layers=18
-        )
-        decoder_config = Pix2StructTextConfig(hidden_size=1536, d_ff=3968, num_heads=24, num_layers=18)
-    config = Pix2StructConfig(
-        vision_config=encoder_config.to_dict(), text_config=decoder_config.to_dict(), is_vqa=is_vqa
-    )
-
-    model = Pix2StructForConditionalGeneration(config)
-
-    torch_params = rename_and_convert_flax_params(flax_params)
-    model.load_state_dict(torch_params)
-
-    tok = AutoTokenizer.from_pretrained("ybelkada/test-pix2struct-tokenizer")
-    image_processor = Pix2StructImageProcessor()
-    processor = Pix2StructProcessor(image_processor=image_processor, tokenizer=tok)
-
-    if use_large:
-        processor.image_processor.max_patches = 4096
-
-    processor.image_processor.is_vqa = True
-
-    # mkdir if needed
-    os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-
-    model.save_pretrained(pytorch_dump_folder_path)
-    processor.save_pretrained(pytorch_dump_folder_path)
-
-    print("Model saved in {}".format(pytorch_dump_folder_path))
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--t5x_checkpoint_path", default=None, type=str, help="Path to the original T5x checkpoint.")
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--use_large", action="store_true", help="Use large model.")
-    parser.add_argument("--is_vqa", action="store_true", help="Use large model.")
-    args = parser.parse_args()
-
-    convert_pix2struct_original_pytorch_checkpoint_to_hf(
-        args.t5x_checkpoint_path, args.pytorch_dump_folder_path, args.use_large
-    )
diff --git a/src/transformers/models/pixtral/convert_pixtral_weights_to_hf.py b/src/transformers/models/pixtral/convert_pixtral_weights_to_hf.py
deleted file mode 100644
index ee1f1e9eb5ed..000000000000
--- a/src/transformers/models/pixtral/convert_pixtral_weights_to_hf.py
+++ /dev/null
@@ -1,246 +0,0 @@
-# coding=utf-8
-# Copyright 2024 HuggingFace Inc. team. All rights reserved.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import json
-import os
-
-import regex as re
-import torch
-from mistral_common.tokens.tokenizers.mistral import MistralTokenizer
-from safetensors.torch import load_file as safe_load_file
-
-from transformers import (
-    LlavaConfig,
-    LlavaForConditionalGeneration,
-    MistralConfig,
-    PixtralImageProcessor,
-    PixtralProcessor,
-    PixtralVisionConfig,
-)
-
-
-"""
-# Here is how to get the original tokens!
-model_name = "mistralai/Pixtral-12B-2409"
-tok = MistralTokenizer.from_model(model_name)
-
-from mistral_common.protocol.instruct.request import ChatCompletionRequest, UserMessage, ImageChunk, TextChunk
-
-EXPECTED_TOKENS = tok.encode_chat_completion(
-    ChatCompletionRequest(
-        messages=[
-            UserMessage(
-                content=[
-                    TextChunk(text="Describe the images"),
-                ] + [ImageChunk(image=img) for img in IMG_URLS]
-            )
-        ],
-        model="pixtral",
-    )
-)
-assert tokenizer.decode(inputs["input_ids"][0]) == EXPECTED_TOKENS
-"""
-
-OLD_KEY_TO_NEW_KEY_MAPPING = {
-    # Layer Normalization Weights
-    r"vision_encoder.transformer.layers.(\d+).input_layernorm.weight": r"vision_tower.transformer.layers.\1.attention_norm.weight",
-    r"vision_encoder.transformer.layers.(\d+).ffn_norm.weight": r"vision_tower.transformer.layers.\1.ffn_norm.weight",
-    # Self Attention Projections
-    r"vision_encoder.transformer.layers.(\d+).attention.wq.weight": r"vision_tower.transformer.layers.\1.attention.q_proj.weight",
-    r"vision_encoder.transformer.layers.(\d+).attention.wk.weight": r"vision_tower.transformer.layers.\1.attention.k_proj.weight",
-    r"vision_encoder.transformer.layers.(\d+).attention.wv.weight": r"vision_tower.transformer.layers.\1.attention.v_proj.weight",
-    r"vision_encoder.transformer.layers.(\d+).attention.wo.weight": r"vision_tower.transformer.layers.\1.attention.o_proj.weight",
-    # MLP Projections
-    r"vision_encoder.transformer.layers.(\d+).feed_forward.w1.weight": r"vision_tower.transformer.layers.\1.feed_forward.gate_proj.weight",
-    r"vision_encoder.transformer.layers.(\d+).feed_forward.w2.weight": r"vision_tower.transformer.layers.\1.feed_forward.down_proj.weight",
-    r"vision_encoder.transformer.layers.(\d+).feed_forward.w3.weight": r"vision_tower.transformer.layers.\1.feed_forward.up_proj.weight",
-    # Additional mappings
-    r"vision_encoder": r"vision_tower",
-    r"vision_language_adapter.w_in": r"multi_modal_projector.linear_1",
-    r"vision_language_adapter.w_out": r"multi_modal_projector.linear_2",
-    r"layers.(\d+).attention.wq.weight": r"language_model.model.layers.\1.self_attn.q_proj.weight",
-    r"layers.(\d+).attention.wk.weight": r"language_model.model.layers.\1.self_attn.k_proj.weight",
-    r"layers.(\d+).attention.wv.weight": r"language_model.model.layers.\1.self_attn.v_proj.weight",
-    r"layers.(\d+).attention.wo.weight": r"language_model.model.layers.\1.self_attn.o_proj.weight",
-    r"layers.(\d+).feed_forward.w1.weight": r"language_model.model.layers.\1.mlp.gate_proj.weight",
-    r"layers.(\d+).feed_forward.w2.weight": r"language_model.model.layers.\1.mlp.down_proj.weight",
-    r"layers.(\d+).feed_forward.w3.weight": r"language_model.model.layers.\1.mlp.up_proj.weight",
-    r"layers.(\d+).ffn_norm.weight": r"language_model.model.layers.\1.post_attention_layernorm.weight",
-    r"layers.(\d+).attention_norm.weight": r"language_model.model.layers.\1.input_layernorm.weight",
-    r"tok_embeddings.weight": r"language_model.model.embed_tokens.weight",
-    r"output.weight": r"language_model.lm_head.weight",
-    r"norm.weight": r"language_model.model.norm.weight",
-}
-
-
-def convert_mistral_tokenizer(model_file):
-    from transformers import LlamaTokenizer
-
-    mistral_tokenizer = MistralTokenizer.from_file(model_file)
-    vocab = mistral_tokenizer.instruct_tokenizer.tokenizer.vocab()
-    control_token_ids = mistral_tokenizer.instruct_tokenizer.tokenizer._control_tokens
-    all_special = [vocab[id] for id in control_token_ids]
-    hf_tokenizer = LlamaTokenizer(model_file)
-    # Do I need to exclude tokens that are already special?
-    hf_tokenizer.add_special_tokens({"additional_special_tokens": all_special})
-    hf_tokenizer.model_input_names = ["input_ids", "attention_mask"]
-    return hf_tokenizer
-
-
-def permute_for_rope(value, n_heads, config):
-    dim1 = value.shape[0]
-    dim2 = config.hidden_size
-    return value.view(n_heads, dim1 // n_heads // 2, 2, dim2).transpose(1, 2).reshape(dim1, dim2)
-
-
-def convert_dictionary(original_state_dict, vision_config, text_config):
-    new_dict = {}
-
-    all_keys = "\n" + "\n".join(original_state_dict.keys())
-    old_keys = all_keys
-    for old, new in OLD_KEY_TO_NEW_KEY_MAPPING.items():
-        all_keys = re.sub(r"\n" + old, r"\n" + new, all_keys)
-
-    OLD_TO_NEW = dict(zip(old_keys.split("\n"), all_keys.split("\n")))
-
-    for key, value in original_state_dict.items():
-        new_key = OLD_TO_NEW[key]
-        if "vision_encoder" in key:
-            _config = vision_config
-            num_attention_heads = _config.num_attention_heads
-        else:
-            _config = text_config
-            if "q_proj" in new_key:
-                num_attention_heads = _config.num_attention_heads
-            if "k_proj" in new_key:
-                num_attention_heads = _config.num_key_value_heads
-
-        if "q_proj" in new_key or "k_proj" in new_key:
-            value = permute_for_rope(value, num_attention_heads, _config)
-
-        new_dict[new_key] = value
-    return new_dict
-
-
-MISTRAL_CONFIG_MAPPING = {
-    "dim": "hidden_size",
-    "hidden_dim": "intermediate_size",
-    "n_kv_heads": "num_key_value_heads",
-    "n_heads": "num_attention_heads",
-    "n_layers": "num_hidden_layers",
-}
-
-
-def convert_mistral_model(input_dir, output_dir):
-    vision_config = {}
-    if os.path.isfile(f"{input_dir}/params.json"):
-        with open(f"{input_dir}/params.json") as f:
-            param_json = json.load(f)
-        vision_config = param_json.pop("vision_encoder")
-        for k, v in MISTRAL_CONFIG_MAPPING.items():
-            value = param_json.pop(k)
-            param_json[v] = value
-        if "hidden_act" not in vision_config:
-            vision_config["hidden_act"] = "silu"
-        text_config = MistralConfig(
-            **param_json,
-            hidden_act="silu",
-            sliding_window=None,
-            tie_word_embeddings=False,
-            is_composition=True,
-            rms_norm_eps=1e-5,
-        )
-    else:
-        text_config = MistralConfig(
-            attention_dropout=0.0,
-            bos_token_id=1,
-            eos_token_id=2,
-            head_dim=128,
-            hidden_act="silu",
-            hidden_size=5120,
-            initializer_range=0.02,
-            intermediate_size=14336,
-            max_position_embeddings=1024000,
-            model_type="mistral",
-            num_attention_heads=32,
-            num_hidden_layers=40,
-            num_key_value_heads=8,
-            rms_norm_eps=1e-05,
-            rope_theta=1000000000.0,
-            sliding_window=None,
-            tie_word_embeddings=False,
-            vocab_size=131072,
-        )
-    adapter_bias = vision_config.pop("adapter_bias", True)
-    vision_config = PixtralVisionConfig(**vision_config)
-    config = LlavaConfig(
-        vision_config,
-        text_config,
-        vision_feature_layer=-1,
-        image_token_index=10,
-        vision_feature_select_strategy="full",
-        image_seq_length=1,
-        multimodal_projector_bias=adapter_bias,
-    )
-    config.architectures = ["LlavaForConditionalGeneration"]
-    config.save_pretrained(output_dir)
-    full_original_state_dict = {}
-    safetensors_files = sorted([file for file in os.listdir(input_dir) if file.endswith(".safetensors")])
-    if len(safetensors_files) == 1:
-        full_original_state_dict = safe_load_file(f"{input_dir}/consolidated.safetensors")
-    else:
-        for file in safetensors_files:
-            loaded_dict = safe_load_file(f"{input_dir}/{file}")
-            full_original_state_dict.update(loaded_dict)
-
-    new_dict = convert_dictionary(full_original_state_dict, vision_config, text_config)
-    with torch.device("meta"):
-        model = LlavaForConditionalGeneration(config)
-    model.load_state_dict(new_dict, strict=True, assign=True)
-    model.save_pretrained(output_dir)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_dir",
-        help="Location of LLaMA weights, which contains tokenizer.model and model folders",
-        required=True,
-    )
-    parser.add_argument(
-        "--output_dir",
-        help="Location to write HF model and tokenizer",
-        required=True,
-    )
-    parser.add_argument(
-        "--tokenizer_file", help="Location of the specific tokenizer model file to use.", required=True
-    )
-    parser.add_argument(
-        "--chat_template_file",
-        help="Optional file containing a raw chat template. Will be set as the processor's chat template.",
-        required=False,
-    )
-
-    args = parser.parse_args()
-    convert_mistral_model(args.input_dir, args.output_dir)
-    tokenizer = convert_mistral_tokenizer(args.tokenizer_file)
-    image_processor = PixtralImageProcessor()
-    processor = PixtralProcessor(tokenizer=tokenizer, image_processor=image_processor, image_token="[IMG]")
-    if args.chat_template_file:
-        processor.chat_template = open(args.chat_template_file).read()
-    processor.save_pretrained(args.output_dir)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/plbart/convert_plbart_original_checkpoint_to_torch.py b/src/transformers/models/plbart/convert_plbart_original_checkpoint_to_torch.py
deleted file mode 100644
index eac4a27d11c5..000000000000
--- a/src/transformers/models/plbart/convert_plbart_original_checkpoint_to_torch.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import torch
-from torch import nn
-
-from transformers import PLBartConfig, PLBartForConditionalGeneration, PLBartForSequenceClassification
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = [
-        "encoder.version",
-        "decoder.version",
-        "model.encoder.version",
-        "model.decoder.version",
-        "_float_tensor",
-        "decoder.output_projection.weight",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-def convert_fairseq_plbart_checkpoint_from_disk(
-    checkpoint_path, hf_config_path="uclanlp/plbart-base", finetuned=False, classification=False
-):
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-    remove_ignore_keys_(state_dict)
-    vocab_size = state_dict["encoder.embed_tokens.weight"].shape[0]
-
-    plbart_config = PLBartConfig.from_pretrained(hf_config_path, vocab_size=vocab_size)
-
-    state_dict["shared.weight"] = state_dict["decoder.embed_tokens.weight"]
-    if not classification:
-        model = PLBartForConditionalGeneration(plbart_config)
-        model.model.load_state_dict(state_dict)
-        if finetuned:
-            model.lm_head = make_linear_from_emb(model.model.shared)
-
-    else:
-        classification_head = {}
-        for key, value in state_dict.copy().items():
-            if key.startswith("classification_heads.sentence_classification_head"):
-                classification_head[key.replace("classification_heads.sentence_classification_head.", "")] = value
-                state_dict.pop(key)
-        model = PLBartForSequenceClassification(plbart_config)
-        model.model.load_state_dict(state_dict)
-        model.classification_head.load_state_dict(classification_head)
-
-    return model
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("fairseq_path", type=str, help="model.pt on local filesystem.")
-    parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument(
-        "--hf_config",
-        default="uclanlp/plbart-base",
-        type=str,
-        help="Which huggingface architecture to use: plbart-base",
-    )
-    parser.add_argument("--finetuned", action="store_true", help="whether the model is a fine-tuned checkpoint")
-    parser.add_argument(
-        "--classification", action="store_true", help="whether the model is a classification checkpoint"
-    )
-    args = parser.parse_args()
-    model = convert_fairseq_plbart_checkpoint_from_disk(
-        args.fairseq_path,
-        hf_config_path=args.hf_config,
-        finetuned=args.finetuned,
-        classification=args.classification,
-    )
-    model.save_pretrained(args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/poolformer/convert_poolformer_original_to_pytorch.py b/src/transformers/models/poolformer/convert_poolformer_original_to_pytorch.py
deleted file mode 100644
index e5fad6da1a3f..000000000000
--- a/src/transformers/models/poolformer/convert_poolformer_original_to_pytorch.py
+++ /dev/null
@@ -1,214 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert PoolFormer checkpoints from the original repository. URL: https://github.com/sail-sg/poolformer"""
-
-import argparse
-import json
-from collections import OrderedDict
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import PoolFormerConfig, PoolFormerForImageClassification, PoolFormerImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def replace_key_with_offset(key, offset, original_name, new_name):
-    """
-    Replaces the key by subtracting the offset from the original layer number
-    """
-    to_find = original_name.split(".")[0]
-    key_list = key.split(".")
-    orig_block_num = int(key_list[key_list.index(to_find) - 2])
-    layer_num = int(key_list[key_list.index(to_find) - 1])
-    new_block_num = orig_block_num - offset
-
-    key = key.replace(f"{orig_block_num}.{layer_num}.{original_name}", f"block.{new_block_num}.{layer_num}.{new_name}")
-    return key
-
-
-def rename_keys(state_dict):
-    new_state_dict = OrderedDict()
-    total_embed_found, patch_emb_offset = 0, 0
-    for key, value in state_dict.items():
-        if key.startswith("network"):
-            key = key.replace("network", "poolformer.encoder")
-        if "proj" in key:
-            # Works for the first embedding as well as the internal embedding layers
-            if key.endswith("bias") and "patch_embed" not in key:
-                patch_emb_offset += 1
-            to_replace = key[: key.find("proj")]
-            key = key.replace(to_replace, f"patch_embeddings.{total_embed_found}.")
-            key = key.replace("proj", "projection")
-            if key.endswith("bias"):
-                total_embed_found += 1
-        if "patch_embeddings" in key:
-            key = "poolformer.encoder." + key
-        if "mlp.fc1" in key:
-            key = replace_key_with_offset(key, patch_emb_offset, "mlp.fc1", "output.conv1")
-        if "mlp.fc2" in key:
-            key = replace_key_with_offset(key, patch_emb_offset, "mlp.fc2", "output.conv2")
-        if "norm1" in key:
-            key = replace_key_with_offset(key, patch_emb_offset, "norm1", "before_norm")
-        if "norm2" in key:
-            key = replace_key_with_offset(key, patch_emb_offset, "norm2", "after_norm")
-        if "layer_scale_1" in key:
-            key = replace_key_with_offset(key, patch_emb_offset, "layer_scale_1", "layer_scale_1")
-        if "layer_scale_2" in key:
-            key = replace_key_with_offset(key, patch_emb_offset, "layer_scale_2", "layer_scale_2")
-        if "head" in key:
-            key = key.replace("head", "classifier")
-        new_state_dict[key] = value
-    return new_state_dict
-
-
-# We will verify our results on a COCO image
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-
-    return image
-
-
-@torch.no_grad()
-def convert_poolformer_checkpoint(model_name, checkpoint_path, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our PoolFormer structure.
-    """
-
-    # load default PoolFormer configuration
-    config = PoolFormerConfig()
-
-    # set attributes based on model_name
-    repo_id = "huggingface/label-files"
-    size = model_name[-3:]
-    config.num_labels = 1000
-    filename = "imagenet-1k-id2label.json"
-    expected_shape = (1, 1000)
-
-    # set config attributes
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-    if size == "s12":
-        config.depths = [2, 2, 6, 2]
-        config.hidden_sizes = [64, 128, 320, 512]
-        config.mlp_ratio = 4.0
-        crop_pct = 0.9
-    elif size == "s24":
-        config.depths = [4, 4, 12, 4]
-        config.hidden_sizes = [64, 128, 320, 512]
-        config.mlp_ratio = 4.0
-        crop_pct = 0.9
-    elif size == "s36":
-        config.depths = [6, 6, 18, 6]
-        config.hidden_sizes = [64, 128, 320, 512]
-        config.mlp_ratio = 4.0
-        config.layer_scale_init_value = 1e-6
-        crop_pct = 0.9
-    elif size == "m36":
-        config.depths = [6, 6, 18, 6]
-        config.hidden_sizes = [96, 192, 384, 768]
-        config.mlp_ratio = 4.0
-        config.layer_scale_init_value = 1e-6
-        crop_pct = 0.95
-    elif size == "m48":
-        config.depths = [8, 8, 24, 8]
-        config.hidden_sizes = [96, 192, 384, 768]
-        config.mlp_ratio = 4.0
-        config.layer_scale_init_value = 1e-6
-        crop_pct = 0.95
-    else:
-        raise ValueError(f"Size {size} not supported")
-
-    # load image processor
-    image_processor = PoolFormerImageProcessor(crop_pct=crop_pct)
-
-    # Prepare image
-    image = prepare_img()
-    pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
-
-    logger.info(f"Converting model {model_name}...")
-
-    # load original state dict
-    state_dict = torch.load(checkpoint_path, map_location=torch.device("cpu"))
-
-    # rename keys
-    state_dict = rename_keys(state_dict)
-
-    # create HuggingFace model and load state dict
-    model = PoolFormerForImageClassification(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # Define image processor
-    image_processor = PoolFormerImageProcessor(crop_pct=crop_pct)
-    pixel_values = image_processor(images=prepare_img(), return_tensors="pt").pixel_values
-
-    # forward pass
-    outputs = model(pixel_values)
-    logits = outputs.logits
-
-    # define expected logit slices for different models
-    if size == "s12":
-        expected_slice = torch.tensor([-0.3045, -0.6758, -0.4869])
-    elif size == "s24":
-        expected_slice = torch.tensor([0.4402, -0.1374, -0.8045])
-    elif size == "s36":
-        expected_slice = torch.tensor([-0.6080, -0.5133, -0.5898])
-    elif size == "m36":
-        expected_slice = torch.tensor([0.3952, 0.2263, -1.2668])
-    elif size == "m48":
-        expected_slice = torch.tensor([0.1167, -0.0656, -0.3423])
-    else:
-        raise ValueError(f"Size {size} not supported")
-
-    # verify logits
-    assert logits.shape == expected_shape
-    assert torch.allclose(logits[0, :3], expected_slice, atol=1e-2)
-
-    # finally, save model and image processor
-    logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--model_name",
-        default="poolformer_s12",
-        type=str,
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--checkpoint_path", default=None, type=str, help="Path to the original PyTorch checkpoint (.pth file)."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_poolformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/pop2piano/convert_pop2piano_weights_to_hf.py b/src/transformers/models/pop2piano/convert_pop2piano_weights_to_hf.py
deleted file mode 100644
index 54b8bb67e60a..000000000000
--- a/src/transformers/models/pop2piano/convert_pop2piano_weights_to_hf.py
+++ /dev/null
@@ -1,190 +0,0 @@
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""File for loading the Pop2Piano model weights from the official repository and to show how tokenizer vocab was
-constructed"""
-
-import json
-
-import torch
-
-from transformers import Pop2PianoConfig, Pop2PianoForConditionalGeneration
-
-
-########################## MODEL WEIGHTS ##########################
-
-# This weights were downloaded from the official pop2piano repository
-# https://huggingface.co/sweetcocoa/pop2piano/blob/main/model-1999-val_0.67311615.ckpt
-official_weights = torch.load("./model-1999-val_0.67311615.ckpt")
-state_dict = {}
-
-
-# load the config and init the model
-cfg = Pop2PianoConfig.from_pretrained("sweetcocoa/pop2piano")
-model = Pop2PianoForConditionalGeneration(cfg)
-
-
-# load relative attention bias
-state_dict["encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight"] = official_weights["state_dict"][
-    "transformer.encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight"
-]
-state_dict["decoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight"] = official_weights["state_dict"][
-    "transformer.decoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight"
-]
-
-# load embed tokens and final layer norm for both encoder and decoder
-state_dict["encoder.embed_tokens.weight"] = official_weights["state_dict"]["transformer.encoder.embed_tokens.weight"]
-state_dict["decoder.embed_tokens.weight"] = official_weights["state_dict"]["transformer.decoder.embed_tokens.weight"]
-
-state_dict["encoder.final_layer_norm.weight"] = official_weights["state_dict"][
-    "transformer.encoder.final_layer_norm.weight"
-]
-state_dict["decoder.final_layer_norm.weight"] = official_weights["state_dict"][
-    "transformer.decoder.final_layer_norm.weight"
-]
-
-# load lm_head, mel_conditioner.emb and shared
-state_dict["lm_head.weight"] = official_weights["state_dict"]["transformer.lm_head.weight"]
-state_dict["mel_conditioner.embedding.weight"] = official_weights["state_dict"]["mel_conditioner.embedding.weight"]
-state_dict["shared.weight"] = official_weights["state_dict"]["transformer.shared.weight"]
-
-# load each encoder blocks
-for i in range(cfg.num_layers):
-    # layer 0
-    state_dict[f"encoder.block.{i}.layer.0.SelfAttention.q.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.0.SelfAttention.q.weight"
-    ]
-    state_dict[f"encoder.block.{i}.layer.0.SelfAttention.k.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.0.SelfAttention.k.weight"
-    ]
-    state_dict[f"encoder.block.{i}.layer.0.SelfAttention.v.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.0.SelfAttention.v.weight"
-    ]
-    state_dict[f"encoder.block.{i}.layer.0.SelfAttention.o.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.0.SelfAttention.o.weight"
-    ]
-    state_dict[f"encoder.block.{i}.layer.0.layer_norm.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.0.layer_norm.weight"
-    ]
-
-    # layer 1
-    state_dict[f"encoder.block.{i}.layer.1.DenseReluDense.wi_0.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.1.DenseReluDense.wi_0.weight"
-    ]
-    state_dict[f"encoder.block.{i}.layer.1.DenseReluDense.wi_1.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.1.DenseReluDense.wi_1.weight"
-    ]
-    state_dict[f"encoder.block.{i}.layer.1.DenseReluDense.wo.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.1.DenseReluDense.wo.weight"
-    ]
-    state_dict[f"encoder.block.{i}.layer.1.layer_norm.weight"] = official_weights["state_dict"][
-        f"transformer.encoder.block.{i}.layer.1.layer_norm.weight"
-    ]
-
-# load each decoder blocks
-for i in range(6):
-    # layer 0
-    state_dict[f"decoder.block.{i}.layer.0.SelfAttention.q.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.0.SelfAttention.q.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.0.SelfAttention.k.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.0.SelfAttention.k.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.0.SelfAttention.v.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.0.SelfAttention.v.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.0.SelfAttention.o.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.0.SelfAttention.o.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.0.layer_norm.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.0.layer_norm.weight"
-    ]
-
-    # layer 1
-    state_dict[f"decoder.block.{i}.layer.1.EncDecAttention.q.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.1.EncDecAttention.q.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.1.EncDecAttention.k.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.1.EncDecAttention.k.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.1.EncDecAttention.v.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.1.EncDecAttention.v.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.1.EncDecAttention.o.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.1.EncDecAttention.o.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.1.layer_norm.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.1.layer_norm.weight"
-    ]
-
-    # layer 2
-    state_dict[f"decoder.block.{i}.layer.2.DenseReluDense.wi_0.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.2.DenseReluDense.wi_0.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.2.DenseReluDense.wi_1.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.2.DenseReluDense.wi_1.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.2.DenseReluDense.wo.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.2.DenseReluDense.wo.weight"
-    ]
-    state_dict[f"decoder.block.{i}.layer.2.layer_norm.weight"] = official_weights["state_dict"][
-        f"transformer.decoder.block.{i}.layer.2.layer_norm.weight"
-    ]
-
-model.load_state_dict(state_dict, strict=True)
-
-# save the weights
-torch.save(state_dict, "./pytorch_model.bin")
-
-########################## TOKENIZER ##########################
-
-# the tokenize and detokenize methods are taken from the official implementation
-
-
-# link : https://github.com/sweetcocoa/pop2piano/blob/fac11e8dcfc73487513f4588e8d0c22a22f2fdc5/midi_tokenizer.py#L34
-def tokenize(idx, token_type, n_special=4, n_note=128, n_velocity=2):
-    if token_type == "TOKEN_TIME":
-        return n_special + n_note + n_velocity + idx
-    elif token_type == "TOKEN_VELOCITY":
-        return n_special + n_note + idx
-    elif token_type == "TOKEN_NOTE":
-        return n_special + idx
-    elif token_type == "TOKEN_SPECIAL":
-        return idx
-    else:
-        return -1
-
-
-# link : https://github.com/sweetcocoa/pop2piano/blob/fac11e8dcfc73487513f4588e8d0c22a22f2fdc5/midi_tokenizer.py#L48
-def detokenize(idx, n_special=4, n_note=128, n_velocity=2, time_idx_offset=0):
-    if idx >= n_special + n_note + n_velocity:
-        return "TOKEN_TIME", (idx - (n_special + n_note + n_velocity)) + time_idx_offset
-    elif idx >= n_special + n_note:
-        return "TOKEN_VELOCITY", idx - (n_special + n_note)
-    elif idx >= n_special:
-        return "TOKEN_NOTE", idx - n_special
-    else:
-        return "TOKEN_SPECIAL", idx
-
-
-# crate the decoder and then the encoder of the tokenizer
-decoder = {}
-for i in range(cfg.vocab_size):
-    decoder.update({i: f"{detokenize(i)[1]}_{detokenize(i)[0]}"})
-
-encoder = {v: k for k, v in decoder.items()}
-
-# save the vocab
-with open("./vocab.json", "w") as file:
-    file.write(json.dumps(encoder))
diff --git a/src/transformers/models/prompt_depth_anything/convert_prompt_depth_anything_to_hf.py b/src/transformers/models/prompt_depth_anything/convert_prompt_depth_anything_to_hf.py
deleted file mode 100644
index 059a79337750..000000000000
--- a/src/transformers/models/prompt_depth_anything/convert_prompt_depth_anything_to_hf.py
+++ /dev/null
@@ -1,292 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Prompt Depth Anything checkpoints from the original repository. URL:
-https://github.com/DepthAnything/PromptDA"""
-
-import argparse
-import re
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    Dinov2Config,
-    PromptDepthAnythingConfig,
-    PromptDepthAnythingForDepthEstimation,
-    PromptDepthAnythingImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_dpt_config(model_name):
-    if "small" in model_name or "vits" in model_name:
-        out_indices = [3, 6, 9, 12]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-small", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 64
-        neck_hidden_sizes = [48, 96, 192, 384]
-    elif "base" in model_name or "vitb" in model_name:
-        out_indices = [3, 6, 9, 12]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-base", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 128
-        neck_hidden_sizes = [96, 192, 384, 768]
-    elif "large" in model_name or "vitl" in model_name:
-        out_indices = [5, 12, 18, 24]
-        backbone_config = Dinov2Config.from_pretrained(
-            "facebook/dinov2-large", out_indices=out_indices, apply_layernorm=True, reshape_hidden_states=False
-        )
-        fusion_hidden_size = 256
-        neck_hidden_sizes = [256, 512, 1024, 1024]
-    else:
-        raise NotImplementedError(f"Model not supported: {model_name}")
-
-    depth_estimation_type = "metric"
-    max_depth = None
-
-    config = PromptDepthAnythingConfig(
-        reassemble_hidden_size=backbone_config.hidden_size,
-        patch_size=backbone_config.patch_size,
-        backbone_config=backbone_config,
-        fusion_hidden_size=fusion_hidden_size,
-        neck_hidden_sizes=neck_hidden_sizes,
-        depth_estimation_type=depth_estimation_type,
-        max_depth=max_depth,
-    )
-
-    return config
-
-
-def transform_qkv_weights(key, value, config):
-    if not key.startswith("qkv_transform"):
-        return value
-
-    layer_idx = int(key.split("_")[-1])
-    hidden_size = config.backbone_config.hidden_size
-
-    suffix = "bias" if "bias" in key else "weight"
-    return {
-        f"backbone.encoder.layer.{layer_idx}.attention.attention.query.{suffix}": value[:hidden_size],
-        f"backbone.encoder.layer.{layer_idx}.attention.attention.key.{suffix}": value[hidden_size : hidden_size * 2],
-        f"backbone.encoder.layer.{layer_idx}.attention.attention.value.{suffix}": value[-hidden_size:],
-    }
-
-
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    # Stem
-    r"pretrained.cls_token": r"backbone.embeddings.cls_token",
-    r"pretrained.mask_token": r"backbone.embeddings.mask_token",
-    r"pretrained.pos_embed": r"backbone.embeddings.position_embeddings",
-    r"pretrained.patch_embed.proj.(weight|bias)": r"backbone.embeddings.patch_embeddings.projection.\1",
-    # Backbone
-    r"pretrained.norm.(weight|bias)": r"backbone.layernorm.\1",
-    # Transformer layers
-    r"pretrained.blocks.(\d+).ls1.gamma": r"backbone.encoder.layer.\1.layer_scale1.lambda1",
-    r"pretrained.blocks.(\d+).ls2.gamma": r"backbone.encoder.layer.\1.layer_scale2.lambda1",
-    r"pretrained.blocks.(\d+).norm1.(weight|bias)": r"backbone.encoder.layer.\1.norm1.\2",
-    r"pretrained.blocks.(\d+).norm2.(weight|bias)": r"backbone.encoder.layer.\1.norm2.\2",
-    r"pretrained.blocks.(\d+).mlp.fc1.(weight|bias)": r"backbone.encoder.layer.\1.mlp.fc1.\2",
-    r"pretrained.blocks.(\d+).mlp.fc2.(weight|bias)": r"backbone.encoder.layer.\1.mlp.fc2.\2",
-    r"pretrained.blocks.(\d+).attn.proj.(weight|bias)": r"backbone.encoder.layer.\1.attention.output.dense.\2",
-    r"pretrained.blocks.(\d+).attn.qkv.(weight|bias)": r"qkv_transform_\2_\1",
-    # Neck
-    r"depth_head.projects.(\d+).(weight|bias)": r"neck.reassemble_stage.layers.\1.projection.\2",
-    r"depth_head.scratch.layer(\d+)_rn.weight": lambda m: f"neck.convs.{int(m.group(1)) - 1}.weight",
-    r"depth_head.resize_layers.(\d+).(weight|bias)": r"neck.reassemble_stage.layers.\1.resize.\2",
-    # Refinenet (with reversed indices)
-    r"depth_head.scratch.refinenet(\d+).out_conv.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{4 - int(m.group(1))}.projection.{m.group(2)}",
-    r"depth_head.scratch.refinenet(\d+).resConfUnit1.conv1.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{4 - int(m.group(1))}.residual_layer1.convolution1.{m.group(2)}",
-    r"depth_head.scratch.refinenet(\d+).resConfUnit1.conv2.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{4 - int(m.group(1))}.residual_layer1.convolution2.{m.group(2)}",
-    r"depth_head.scratch.refinenet(\d+).resConfUnit2.conv1.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{4 - int(m.group(1))}.residual_layer2.convolution1.{m.group(2)}",
-    r"depth_head.scratch.refinenet(\d+).resConfUnit2.conv2.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{4 - int(m.group(1))}.residual_layer2.convolution2.{m.group(2)}",
-    r"depth_head.scratch.refinenet(\d+).resConfUnit_depth.0.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{4 - int(m.group(1))}.prompt_depth_layer.convolution1.{m.group(2)}",
-    r"depth_head.scratch.refinenet(\d+).resConfUnit_depth.2.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{4 - int(m.group(1))}.prompt_depth_layer.convolution2.{m.group(2)}",
-    r"depth_head.scratch.refinenet(\d+).resConfUnit_depth.4.(weight|bias)": lambda m: f"neck.fusion_stage.layers.{4 - int(m.group(1))}.prompt_depth_layer.convolution3.{m.group(2)}",
-    # Head
-    r"depth_head.scratch.output_conv1.(weight|bias)": r"head.conv1.\1",
-    r"depth_head.scratch.output_conv2.0.(weight|bias)": r"head.conv2.\1",
-    r"depth_head.scratch.output_conv2.2.(weight|bias)": r"head.conv3.\1",
-}
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    """
-    Convert old state dict keys to new keys using regex patterns.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        for old_key in state_dict_keys:
-            new_key = old_key
-            for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-                match = re.match(pattern, old_key)
-                if match:
-                    if callable(replacement):
-                        new_key = replacement(match)
-                    else:
-                        new_key = re.sub(pattern, replacement, old_key)
-                    break
-            output_dict[old_key] = new_key
-    return output_dict
-
-
-@torch.no_grad()
-def convert_dpt_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub, verify_logits):
-    """
-    Copy/paste/tweak model's weights to our DPT structure.
-    """
-
-    # define DPT configuration
-    config = get_dpt_config(model_name)
-
-    model_name_to_repo = {
-        "prompt-depth-anything-vits": "depth-anything/prompt-depth-anything-vits",
-        "prompt-depth-anything-vits-transparent": "depth-anything/prompt-depth-anything-vits-transparent",
-        "prompt-depth-anything-vitl": "depth-anything/prompt-depth-anything-vitl",
-    }
-
-    # load original state_dict
-    repo_id = model_name_to_repo[model_name]
-    filename = name_to_checkpoint[model_name]
-    filepath = hf_hub_download(
-        repo_id=repo_id,
-        filename=f"{filename}",
-    )
-
-    state_dict = torch.load(filepath, map_location="cpu")["state_dict"]
-    state_dict = {key[9:]: state_dict[key] for key in state_dict}
-
-    # Convert state dict using mappings
-    key_mapping = convert_old_keys_to_new_keys(state_dict.keys())
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        new_key = key_mapping[key]
-        transformed_value = transform_qkv_weights(new_key, value, config)
-        if isinstance(transformed_value, dict):
-            new_state_dict.update(transformed_value)
-        else:
-            new_state_dict[new_key] = transformed_value
-
-    # load HuggingFace model
-    model = PromptDepthAnythingForDepthEstimation(config)
-    model.load_state_dict(new_state_dict, strict=False)
-    model.eval()
-
-    processor = PromptDepthAnythingImageProcessor(
-        do_resize=True,
-        size=756,
-        ensure_multiple_of=14,
-        keep_aspect_ratio=True,
-        do_rescale=True,
-        do_normalize=True,
-        image_mean=[0.485, 0.456, 0.406],
-        image_std=[0.229, 0.224, 0.225],
-    )
-    url = "https://github.com/DepthAnything/PromptDA/blob/main/assets/example_images/image.jpg?raw=true"
-    image = Image.open(requests.get(url, stream=True).raw)
-
-    prompt_depth_url = (
-        "https://github.com/DepthAnything/PromptDA/blob/main/assets/example_images/arkit_depth.png?raw=true"
-    )
-    prompt_depth = Image.open(requests.get(prompt_depth_url, stream=True).raw)
-
-    inputs = processor(image, return_tensors="pt", prompt_depth=prompt_depth)
-
-    # Verify forward pass
-    with torch.no_grad():
-        outputs = model(**inputs)
-        predicted_depth = outputs.predicted_depth
-
-    print("Shape of predicted depth:", predicted_depth.shape)
-    print("First values:", predicted_depth[0, :3, :3])
-
-    # assert logits
-    if verify_logits:
-        expected_shape = torch.Size([1, 756, 1008])
-        if model_name == "prompt-depth-anything-vits":
-            expected_slice = torch.tensor(
-                [[3.0100, 3.0016, 3.0219], [3.0046, 3.0137, 3.0275], [3.0083, 3.0191, 3.0292]]
-            )
-        elif model_name == "prompt-depth-anything-vits-transparent":
-            expected_slice = torch.tensor(
-                [[3.0058, 3.0397, 3.0460], [3.0314, 3.0393, 3.0504], [3.0326, 3.0465, 3.0545]]
-            )
-        elif model_name == "prompt-depth-anything-vitl":
-            expected_slice = torch.tensor(
-                [[3.1336, 3.1358, 3.1363], [3.1368, 3.1267, 3.1414], [3.1397, 3.1385, 3.1448]]
-            )
-        else:
-            raise ValueError("Not supported")
-        assert predicted_depth.shape == torch.Size(expected_shape)
-        assert torch.allclose(predicted_depth[0, :3, :3], expected_slice, atol=5e-3)  # 5mm tolerance
-        print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model and processor to hub...")
-        model.push_to_hub(repo_id=f"{model_name.title()}-hf")
-        processor.push_to_hub(repo_id=f"{model_name.title()}-hf")
-
-
-name_to_checkpoint = {
-    "prompt-depth-anything-vits": "model.ckpt",
-    "prompt-depth-anything-vits-transparent": "model.ckpt",
-    "prompt-depth-anything-vitl": "model.ckpt",
-}
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="prompt_depth_anything_vits",
-        type=str,
-        choices=name_to_checkpoint.keys(),
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model to the hub after conversion.",
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_false",
-        required=False,
-        help="Whether to verify the logits after conversion.",
-    )
-
-    args = parser.parse_args()
-    convert_dpt_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.verify_logits)
diff --git a/src/transformers/models/prophetnet/convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/prophetnet/convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 805338511d8a..000000000000
--- a/src/transformers/models/prophetnet/convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,159 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ProphetNet checkpoint."""
-
-import argparse
-
-from torch import nn
-
-# transformers_old should correspond to branch `save_old_prophetnet_model_structure` here
-# original prophetnet_checkpoints are saved under `patrickvonplaten/..._old` respectively
-from transformers_old.modeling_prophetnet import (
-    ProphetNetForConditionalGeneration as ProphetNetForConditionalGenerationOld,
-)
-from transformers_old.modeling_xlm_prophetnet import (
-    XLMProphetNetForConditionalGeneration as XLMProphetNetForConditionalGenerationOld,
-)
-
-from transformers import ProphetNetForConditionalGeneration, XLMProphetNetForConditionalGeneration, logging
-
-
-logger = logging.get_logger(__name__)
-logging.set_verbosity_info()
-
-
-def convert_prophetnet_checkpoint_to_pytorch(prophetnet_checkpoint_path: str, pytorch_dump_folder_path: str):
-    """
-    Copy/paste/tweak prohpetnet's weights to our prophetnet structure.
-    """
-    if "xprophetnet" in prophetnet_checkpoint_path:
-        prophet_old = XLMProphetNetForConditionalGenerationOld.from_pretrained(prophetnet_checkpoint_path)
-        prophet, loading_info = XLMProphetNetForConditionalGeneration.from_pretrained(
-            prophetnet_checkpoint_path, output_loading_info=True
-        )
-    else:
-        prophet_old = ProphetNetForConditionalGenerationOld.from_pretrained(prophetnet_checkpoint_path)
-        prophet, loading_info = ProphetNetForConditionalGeneration.from_pretrained(
-            prophetnet_checkpoint_path, output_loading_info=True
-        )
-
-    special_keys = ["key_proj", "value_proj", "query_proj"]
-
-    mapping = {
-        "self_attn": "ngram_self_attn",
-        "cross_attn": "encoder_attn",
-        "cross_attn_layer_norm": "encoder_attn_layer_norm",
-        "feed_forward_layer_norm": "final_layer_norm",
-        "feed_forward": "",
-        "intermediate": "fc1",
-        "output": "fc2",
-        "key_proj": "k_proj",
-        "query_proj": "q_proj",
-        "value_proj": "v_proj",
-        "word_embeddings": "embed_tokens",
-        "embeddings_layer_norm": "emb_layer_norm",
-        "relative_pos_embeddings": "relative_linear",
-        "ngram_embeddings": "ngram_input_embed",
-        "position_embeddings": "embed_positions",
-    }
-
-    for key in loading_info["missing_keys"]:
-        attributes = key.split(".")
-
-        if attributes[0] == "lm_head":
-            model = prophet
-            old_model = prophet_old
-        else:
-            model = prophet.prophetnet
-            old_model = prophet_old.model
-
-        is_key_init = False
-        for attribute in attributes:
-            if attribute in mapping:
-                old_attribute = mapping[attribute]
-                if not hasattr(old_model, old_attribute) and len(old_attribute) > 0:
-                    old_attribute = attribute
-            elif hasattr(old_model, attribute):
-                old_attribute = attribute
-
-            if attribute == "weight":
-                assert old_model.weight.shape == model.weight.shape, "Shapes have to match!"
-                model.weight = old_model.weight
-                logger.info(f"{attribute} is initialized.")
-                is_key_init = True
-                break
-            elif attribute == "bias":
-                assert old_model.bias.shape == model.bias.shape, "Shapes have to match!"
-                model.bias = old_model.bias
-                logger.info(f"{attribute} is initialized")
-                is_key_init = True
-                break
-            elif attribute in special_keys and hasattr(old_model, "in_proj_weight"):
-                embed_dim = old_model.in_proj_weight.shape[0] // 3
-                param = getattr(model, attribute)
-                param.weight.shape == old_model.in_proj_weight[:embed_dim, :].shape, "Shapes have to match"
-                param.bias.shape == old_model.in_proj_bias[:embed_dim].shape, "Shapes have to match"
-                if attribute == "query_proj":
-                    model.query_proj.weight = nn.Parameter(old_model.in_proj_weight[:embed_dim, :])
-                    model.query_proj.bias = nn.Parameter(old_model.in_proj_bias[:embed_dim])
-
-                elif attribute == "key_proj":
-                    model.key_proj.weight = nn.Parameter(old_model.in_proj_weight[embed_dim : 2 * embed_dim, :])
-                    model.key_proj.bias = nn.Parameter(old_model.in_proj_bias[embed_dim : 2 * embed_dim])
-                elif attribute == "value_proj":
-                    model.value_proj.weight = nn.Parameter(old_model.in_proj_weight[2 * embed_dim :, :])
-                    model.value_proj.bias = nn.Parameter(old_model.in_proj_bias[2 * embed_dim :])
-                is_key_init = True
-                break
-            elif attribute == "position_embeddings":
-                assert model.position_embeddings.weight.shape[-1] == old_model.embed_positions.weight.shape[-1], (
-                    "Hidden size has to match"
-                )
-                assert model.position_embeddings.weight.shape[0] == 512, "We want 512 position_embeddings."
-                model.position_embeddings.weight = nn.Parameter(old_model.embed_positions.weight[:512, :])
-                is_key_init = True
-                break
-
-            if attribute.isdigit():
-                model = model[int(attribute)]
-                old_model = old_model[int(old_attribute)]
-            else:
-                model = getattr(model, attribute)
-
-                if old_attribute == "":
-                    old_model = old_model
-                else:
-                    if not hasattr(old_model, old_attribute):
-                        raise ValueError(f"{old_model} does not have {old_attribute}")
-                    old_model = getattr(old_model, old_attribute)
-
-        if not is_key_init:
-            raise ValueError(f"{key} was not correctly initialized!")
-
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    prophet.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--prophetnet_checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_prophetnet_checkpoint_to_pytorch(args.prophetnet_checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/pvt/convert_pvt_to_pytorch.py b/src/transformers/models/pvt/convert_pvt_to_pytorch.py
deleted file mode 100644
index 99002e3d67ce..000000000000
--- a/src/transformers/models/pvt/convert_pvt_to_pytorch.py
+++ /dev/null
@@ -1,226 +0,0 @@
-# coding=utf-8
-# Copyright 2023 Authors: Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan,
-# Kaitao Song, Ding Liang, Tong Lu, Ping Luo, Ling Shao and The HuggingFace Inc. team.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Pvt checkpoints from the original library."""
-
-import argparse
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import PvtConfig, PvtForImageClassification, PvtImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-    for i in range(config.num_encoder_blocks):
-        # Remane embedings' paramters
-        rename_keys.append((f"pos_embed{i + 1}", f"pvt.encoder.patch_embeddings.{i}.position_embeddings"))
-
-        rename_keys.append((f"patch_embed{i + 1}.proj.weight", f"pvt.encoder.patch_embeddings.{i}.projection.weight"))
-        rename_keys.append((f"patch_embed{i + 1}.proj.bias", f"pvt.encoder.patch_embeddings.{i}.projection.bias"))
-        rename_keys.append((f"patch_embed{i + 1}.norm.weight", f"pvt.encoder.patch_embeddings.{i}.layer_norm.weight"))
-        rename_keys.append((f"patch_embed{i + 1}.norm.bias", f"pvt.encoder.patch_embeddings.{i}.layer_norm.bias"))
-
-        for j in range(config.depths[i]):
-            # Rename blocks' parameters
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.q.weight", f"pvt.encoder.block.{i}.{j}.attention.self.query.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.q.bias", f"pvt.encoder.block.{i}.{j}.attention.self.query.bias")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.kv.weight", f"pvt.encoder.block.{i}.{j}.attention.self.kv.weight")
-            )
-            rename_keys.append((f"block{i + 1}.{j}.attn.kv.bias", f"pvt.encoder.block.{i}.{j}.attention.self.kv.bias"))
-
-            if config.sequence_reduction_ratios[i] > 1:
-                rename_keys.append(
-                    (
-                        f"block{i + 1}.{j}.attn.norm.weight",
-                        f"pvt.encoder.block.{i}.{j}.attention.self.layer_norm.weight",
-                    )
-                )
-                rename_keys.append(
-                    (f"block{i + 1}.{j}.attn.norm.bias", f"pvt.encoder.block.{i}.{j}.attention.self.layer_norm.bias")
-                )
-                rename_keys.append(
-                    (
-                        f"block{i + 1}.{j}.attn.sr.weight",
-                        f"pvt.encoder.block.{i}.{j}.attention.self.sequence_reduction.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"block{i + 1}.{j}.attn.sr.bias",
-                        f"pvt.encoder.block.{i}.{j}.attention.self.sequence_reduction.bias",
-                    )
-                )
-
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.proj.weight", f"pvt.encoder.block.{i}.{j}.attention.output.dense.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.proj.bias", f"pvt.encoder.block.{i}.{j}.attention.output.dense.bias")
-            )
-
-            rename_keys.append((f"block{i + 1}.{j}.norm1.weight", f"pvt.encoder.block.{i}.{j}.layer_norm_1.weight"))
-            rename_keys.append((f"block{i + 1}.{j}.norm1.bias", f"pvt.encoder.block.{i}.{j}.layer_norm_1.bias"))
-
-            rename_keys.append((f"block{i + 1}.{j}.norm2.weight", f"pvt.encoder.block.{i}.{j}.layer_norm_2.weight"))
-            rename_keys.append((f"block{i + 1}.{j}.norm2.bias", f"pvt.encoder.block.{i}.{j}.layer_norm_2.bias"))
-
-            rename_keys.append((f"block{i + 1}.{j}.mlp.fc1.weight", f"pvt.encoder.block.{i}.{j}.mlp.dense1.weight"))
-            rename_keys.append((f"block{i + 1}.{j}.mlp.fc1.bias", f"pvt.encoder.block.{i}.{j}.mlp.dense1.bias"))
-            rename_keys.append((f"block{i + 1}.{j}.mlp.fc2.weight", f"pvt.encoder.block.{i}.{j}.mlp.dense2.weight"))
-            rename_keys.append((f"block{i + 1}.{j}.mlp.fc2.bias", f"pvt.encoder.block.{i}.{j}.mlp.dense2.bias"))
-
-    # Rename cls token
-    rename_keys.extend(
-        [
-            ("cls_token", "pvt.encoder.patch_embeddings.3.cls_token"),
-        ]
-    )
-    # Rename norm layer and classifier layer
-    rename_keys.extend(
-        [
-            ("norm.weight", "pvt.encoder.layer_norm.weight"),
-            ("norm.bias", "pvt.encoder.layer_norm.bias"),
-            ("head.weight", "classifier.weight"),
-            ("head.bias", "classifier.bias"),
-        ]
-    )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_k_v(state_dict, config):
-    # for each of the encoder blocks:
-    for i in range(config.num_encoder_blocks):
-        for j in range(config.depths[i]):
-            # read in weights + bias of keys and values (which is a single matrix in the original implementation)
-            kv_weight = state_dict.pop(f"pvt.encoder.block.{i}.{j}.attention.self.kv.weight")
-            kv_bias = state_dict.pop(f"pvt.encoder.block.{i}.{j}.attention.self.kv.bias")
-            # next, add keys and values (in that order) to the state dict
-            state_dict[f"pvt.encoder.block.{i}.{j}.attention.self.key.weight"] = kv_weight[: config.hidden_sizes[i], :]
-            state_dict[f"pvt.encoder.block.{i}.{j}.attention.self.key.bias"] = kv_bias[: config.hidden_sizes[i]]
-
-            state_dict[f"pvt.encoder.block.{i}.{j}.attention.self.value.weight"] = kv_weight[
-                config.hidden_sizes[i] :, :
-            ]
-            state_dict[f"pvt.encoder.block.{i}.{j}.attention.self.value.bias"] = kv_bias[config.hidden_sizes[i] :]
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_pvt_checkpoint(pvt_size, pvt_checkpoint, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our PVT structure.
-    """
-
-    # define default Pvt configuration
-    if pvt_size == "tiny":
-        config_path = "Zetatech/pvt-tiny-224"
-    elif pvt_size == "small":
-        config_path = "Zetatech/pvt-small-224"
-    elif pvt_size == "medium":
-        config_path = "Zetatech/pvt-medium-224"
-    elif pvt_size == "large":
-        config_path = "Zetatech/pvt-large-224"
-    else:
-        raise ValueError(f"Available model's size: 'tiny', 'small', 'medium', 'large', but '{pvt_size}' was given")
-    config = PvtConfig(name_or_path=config_path)
-    # load original model from https://github.com/whai362/PVT
-    state_dict = torch.load(pvt_checkpoint, map_location="cpu")
-
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_k_v(state_dict, config)
-
-    # load HuggingFace model
-    model = PvtForImageClassification(config).eval()
-    model.load_state_dict(state_dict)
-
-    # Check outputs on an image, prepared by PVTFeatureExtractor
-    image_processor = PvtImageProcessor(size=config.image_size)
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-    outputs = model(pixel_values)
-    logits = outputs.logits.detach().cpu()
-
-    if pvt_size == "tiny":
-        expected_slice_logits = torch.tensor([-1.4192, -1.9158, -0.9702])
-    elif pvt_size == "small":
-        expected_slice_logits = torch.tensor([0.4353, -0.1960, -0.2373])
-    elif pvt_size == "medium":
-        expected_slice_logits = torch.tensor([-0.2914, -0.2231, 0.0321])
-    elif pvt_size == "large":
-        expected_slice_logits = torch.tensor([0.3740, -0.7739, -0.4214])
-    else:
-        raise ValueError(f"Available model's size: 'tiny', 'small', 'medium', 'large', but '{pvt_size}' was given")
-
-    assert torch.allclose(logits[0, :3], expected_slice_logits, atol=1e-4)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model pytorch_model.bin to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--pvt_size",
-        default="tiny",
-        type=str,
-        help="Size of the PVT pretrained model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pvt_checkpoint",
-        default="pvt_tiny.pth",
-        type=str,
-        help="Checkpoint of the PVT pretrained model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_pvt_checkpoint(args.pvt_size, args.pvt_checkpoint, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/pvt_v2/convert_pvt_v2_to_pytorch.py b/src/transformers/models/pvt_v2/convert_pvt_v2_to_pytorch.py
deleted file mode 100644
index b5178cc2e995..000000000000
--- a/src/transformers/models/pvt_v2/convert_pvt_v2_to_pytorch.py
+++ /dev/null
@@ -1,294 +0,0 @@
-# coding=utf-8
-# Copyright 2023 Authors: Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan,
-# Kaitao Song, Ding Liang, Tong Lu, Ping Luo, Ling Shao and The HuggingFace Inc. team.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert PvtV2 checkpoints from the original library."""
-
-import argparse
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import PvtImageProcessor, PvtV2Config, PvtV2ForImageClassification
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-    for i in range(config.num_encoder_blocks):
-        # Remane embedings' paramters
-        rename_keys.append(
-            (f"patch_embed{i + 1}.proj.weight", f"pvt_v2.encoder.layers.{i}.patch_embedding.proj.weight")
-        )
-        rename_keys.append((f"patch_embed{i + 1}.proj.bias", f"pvt_v2.encoder.layers.{i}.patch_embedding.proj.bias"))
-        rename_keys.append(
-            (f"patch_embed{i + 1}.norm.weight", f"pvt_v2.encoder.layers.{i}.patch_embedding.layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"patch_embed{i + 1}.norm.bias", f"pvt_v2.encoder.layers.{i}.patch_embedding.layer_norm.bias")
-        )
-        rename_keys.append((f"norm{i + 1}.weight", f"pvt_v2.encoder.layers.{i}.layer_norm.weight"))
-        rename_keys.append((f"norm{i + 1}.bias", f"pvt_v2.encoder.layers.{i}.layer_norm.bias"))
-
-        for j in range(config.depths[i]):
-            # Rename blocks' parameters
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.q.weight", f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.query.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.q.bias", f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.query.bias")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.kv.weight", f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.kv.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.kv.bias", f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.kv.bias")
-            )
-
-            if config.linear_attention or config.sr_ratios[i] > 1:
-                rename_keys.append(
-                    (
-                        f"block{i + 1}.{j}.attn.norm.weight",
-                        f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.layer_norm.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"block{i + 1}.{j}.attn.norm.bias",
-                        f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.layer_norm.bias",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"block{i + 1}.{j}.attn.sr.weight",
-                        f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.spatial_reduction.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"block{i + 1}.{j}.attn.sr.bias",
-                        f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.spatial_reduction.bias",
-                    )
-                )
-
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.proj.weight", f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.proj.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.attn.proj.bias", f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.proj.bias")
-            )
-
-            rename_keys.append(
-                (f"block{i + 1}.{j}.norm1.weight", f"pvt_v2.encoder.layers.{i}.blocks.{j}.layer_norm_1.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.norm1.bias", f"pvt_v2.encoder.layers.{i}.blocks.{j}.layer_norm_1.bias")
-            )
-
-            rename_keys.append(
-                (f"block{i + 1}.{j}.norm2.weight", f"pvt_v2.encoder.layers.{i}.blocks.{j}.layer_norm_2.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.norm2.bias", f"pvt_v2.encoder.layers.{i}.blocks.{j}.layer_norm_2.bias")
-            )
-
-            rename_keys.append(
-                (f"block{i + 1}.{j}.mlp.fc1.weight", f"pvt_v2.encoder.layers.{i}.blocks.{j}.mlp.dense1.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.mlp.fc1.bias", f"pvt_v2.encoder.layers.{i}.blocks.{j}.mlp.dense1.bias")
-            )
-            rename_keys.append(
-                (
-                    f"block{i + 1}.{j}.mlp.dwconv.dwconv.weight",
-                    f"pvt_v2.encoder.layers.{i}.blocks.{j}.mlp.dwconv.dwconv.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"block{i + 1}.{j}.mlp.dwconv.dwconv.bias",
-                    f"pvt_v2.encoder.layers.{i}.blocks.{j}.mlp.dwconv.dwconv.bias",
-                )
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.mlp.fc2.weight", f"pvt_v2.encoder.layers.{i}.blocks.{j}.mlp.dense2.weight")
-            )
-            rename_keys.append(
-                (f"block{i + 1}.{j}.mlp.fc2.bias", f"pvt_v2.encoder.layers.{i}.blocks.{j}.mlp.dense2.bias")
-            )
-
-    rename_keys.extend(
-        [
-            ("head.weight", "classifier.weight"),
-            ("head.bias", "classifier.bias"),
-        ]
-    )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_k_v(state_dict, config):
-    # for each of the encoder blocks:
-    for i in range(config.num_encoder_blocks):
-        for j in range(config.depths[i]):
-            # read in weights + bias of keys and values (which is a single matrix in the original implementation)
-            kv_weight = state_dict.pop(f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.kv.weight")
-            kv_bias = state_dict.pop(f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.kv.bias")
-            # next, add keys and values (in that order) to the state dict
-            state_dict[f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.key.weight"] = kv_weight[
-                : config.hidden_sizes[i], :
-            ]
-            state_dict[f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.key.bias"] = kv_bias[: config.hidden_sizes[i]]
-
-            state_dict[f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.value.weight"] = kv_weight[
-                config.hidden_sizes[i] :, :
-            ]
-            state_dict[f"pvt_v2.encoder.layers.{i}.blocks.{j}.attention.value.bias"] = kv_bias[
-                config.hidden_sizes[i] :
-            ]
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_pvt_v2_checkpoint(pvt_v2_size, pvt_v2_checkpoint, pytorch_dump_folder_path, verify_imagenet_weights=False):
-    """
-    Copy/paste/tweak model's weights to our PVT structure.
-    """
-
-    # define default PvtV2 configuration
-    if pvt_v2_size == "b0":
-        config_path = "OpenGVLab/pvt_v2_b0"
-    elif pvt_v2_size == "b1":
-        config_path = "OpenGVLab/pvt_v2_b1"
-    elif pvt_v2_size == "b2":
-        config_path = "OpenGVLab/pvt_v2_b2"
-    elif pvt_v2_size == "b2-linear":
-        config_path = "OpenGVLab/pvt_v2_b2_linear"
-    elif pvt_v2_size == "b3":
-        config_path = "OpenGVLab/pvt_v2_b3"
-    elif pvt_v2_size == "b4":
-        config_path = "OpenGVLab/pvt_v2_b4"
-    elif pvt_v2_size == "b5":
-        config_path = "OpenGVLab/pvt_v2_b5"
-    else:
-        raise ValueError(
-            f"Available model sizes: 'b0', 'b1', 'b2', 'b2-linear', 'b3', 'b4', 'b5', but '{pvt_v2_size}' was given"
-        )
-    config = PvtV2Config.from_pretrained(config_path)
-    # load original model from https://github.com/whai362/PVT
-    state_dict = torch.load(pvt_v2_checkpoint, map_location="cpu")
-
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_k_v(state_dict, config)
-
-    # load HuggingFace model
-    model = PvtV2ForImageClassification(config).eval()
-    model.load_state_dict(state_dict)
-    image_processor = PvtImageProcessor(size=config.image_size)
-
-    if verify_imagenet_weights:
-        # Check outputs on an image, prepared by PvtImageProcessor
-        print("Verifying conversion of pretrained ImageNet weights...")
-        encoding = image_processor(images=prepare_img(), return_tensors="pt")
-        pixel_values = encoding["pixel_values"]
-        outputs = model(pixel_values)
-        logits = outputs.logits.detach().cpu()
-
-        if pvt_v2_size == "b0":
-            expected_slice_logits = torch.tensor([-1.1939, -1.4547, -0.1076])
-        elif pvt_v2_size == "b1":
-            expected_slice_logits = torch.tensor([-0.4716, -0.7335, -0.4600])
-        elif pvt_v2_size == "b2":
-            expected_slice_logits = torch.tensor([0.0795, -0.3170, 0.2247])
-        elif pvt_v2_size == "b2-linear":
-            expected_slice_logits = torch.tensor([0.0968, 0.3937, -0.4252])
-        elif pvt_v2_size == "b3":
-            expected_slice_logits = torch.tensor([-0.4595, -0.2870, 0.0940])
-        elif pvt_v2_size == "b4":
-            expected_slice_logits = torch.tensor([-0.1769, -0.1747, -0.0143])
-        elif pvt_v2_size == "b5":
-            expected_slice_logits = torch.tensor([-0.2943, -0.1008, 0.6812])
-        else:
-            raise ValueError(
-                f"Available model sizes: 'b0', 'b1', 'b2', 'b2-linear', 'b3', 'b4', 'b5', but "
-                f"'{pvt_v2_size}' was given"
-            )
-
-        assert torch.allclose(logits[0, :3], expected_slice_logits, atol=1e-4), (
-            "ImageNet weights not converted successfully."
-        )
-
-        print("ImageNet weights verified, conversion successful.")
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model pytorch_model.bin to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--pvt_v2_size",
-        default="b0",
-        type=str,
-        help="Size of the PVTv2 pretrained model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pvt_v2_checkpoint",
-        default="pvt_v2_b0.pth",
-        type=str,
-        help="Checkpoint of the PVTv2 pretrained model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--verify-imagenet-weights",
-        action="store_true",
-        default=False,
-        help="Verifies the correct conversion of author-published pretrained ImageNet weights.",
-    )
-
-    args = parser.parse_args()
-    convert_pvt_v2_checkpoint(
-        pvt_v2_size=args.pvt_v2_size,
-        pvt_v2_checkpoint=args.pvt_v2_checkpoint,
-        pytorch_dump_folder_path=args.pytorch_dump_folder_path,
-        verify_imagenet_weights=args.verify_imagenet_weights,
-    )
diff --git a/src/transformers/models/recurrent_gemma/convert_recurrent_gemma_to_hf.py b/src/transformers/models/recurrent_gemma/convert_recurrent_gemma_to_hf.py
deleted file mode 100644
index dc6619e217e4..000000000000
--- a/src/transformers/models/recurrent_gemma/convert_recurrent_gemma_to_hf.py
+++ /dev/null
@@ -1,222 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import os
-import warnings
-
-import torch
-from accelerate import init_empty_weights
-
-from transformers import GemmaTokenizer, RecurrentGemmaConfig, RecurrentGemmaForCausalLM
-
-
-try:
-    from transformers import GemmaTokenizerFast
-except ImportError as e:
-    warnings.warn(e)
-    warnings.warn(
-        "The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion"
-    )
-    GemmaTokenizerFast = None
-
-import regex as re
-
-
-"""
-Sample usage:
-
-```
-python src/transformers/models/gemma/convert_gemma_weights_to_hf.py \
-    --input_dir /path/to/downloaded/gemma/weights --model_size 7B --output_dir /output/path
-```
-
-Thereafter, models can be loaded via:
-
-```py
-from transformers import GemmaForCausalLM, GemmaTokenizerFast
-
-model = GemmaForCausalLM.from_pretrained("/output/path")
-tokenizer = GemmaTokenizerFast.from_pretrained("/output/path")
-```
-
-Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
-come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
-"""
-
-gemma_2b_config = RecurrentGemmaConfig(
-    num_attention_heads=10,
-    num_key_value_heads=1,
-    hidden_size=2560,
-    intermediate_size=15360,
-    vocab_size=256000,
-    num_hidden_layers=26,
-)
-
-gemma_7b_config = RecurrentGemmaConfig()
-
-CONFIG_MAPPING = {"2B": gemma_2b_config, "7B": gemma_7b_config}
-LAYER_NAME_MAPPING = {"embedder.weight": "model.embed_tokens.weight"}
-
-
-def write_model(save_path, input_base_path, config, safe_serialization=True, push_to_hub=False, dtype=torch.float32):
-    print(f"Fetching all parameters from the checkpoint at '{input_base_path}'")
-    model_state_dict = torch.load(input_base_path, map_location="cpu")
-
-    REPLACEMENT = {
-        "blocks.": "layers.",
-        ".ffw_down.b": ".down_proj.b",
-        ".ffw_down.w": ".down_proj.w",
-        ".ffw_up.b": ".up_proj.bias",
-        ".ffw_up.w": ".up_proj.weight",
-        "recurrent_block": "temporal_block",
-        "attention_block": "temporal_block",
-        "temporal_block.proj_final": "temporal_block.out_proj",
-        "norm.scale": "norm.weight",
-        ".proj_k": ".k_proj",
-        ".proj_q": ".q_proj",
-        ".proj_v": ".v_proj",
-        ".proj_final": ".o_proj",
-        "embedder.input_embedding": "embed_tokens.weight",
-        "conv_1d.w": "conv_1d.weight",
-        "conv_1d.b": "conv_1d.bias",
-        "input_gate.w": "input_gate.weight",
-        "input_gate.b": "input_gate.bias",
-        "a_param": "recurrent_param",
-        "a_gate.b": "recurrent_gate.bias",
-        "a_gate.w": "recurrent_gate.weight",
-    }
-
-    state_dict = {}
-    for k, v in model_state_dict.items():
-        k = "model." + k
-        pattern = re.compile("|".join(map(re.escape, REPLACEMENT.keys())))
-        key = pattern.sub(lambda match: REPLACEMENT[match.group(0)], k)
-        if "conv_1d.weight" in key:
-            v = v[:, None, :].transpose(0, 2)
-        if "up_proj.weight" in key:
-            state_dict[key.replace("up_proj", "gate_proj")] = v[0].T.contiguous()
-            v = v[1].T.contiguous()
-        if "up_proj.bias" in key:
-            state_dict[key.replace("up_proj", "gate_proj")] = v[0, 0, 0].clone()
-            v = v[1, 0, 0].contiguous()
-        if "recurrent_gate.bias" in key:
-            state_dict[key.replace("gate.", "gate_")] = v.contiguous().clone()
-        elif "recurrent_gate.weight" in key:
-            state_dict[key.replace("gate.", "gate_")] = v.contiguous().clone()
-        elif "input_gate.b" in key:
-            state_dict[key.replace("gate.", "gate_")] = v.contiguous().clone()
-        elif "input_gate.w" in key:
-            state_dict[key.replace("gate.", "gate_")] = v.contiguous().clone()
-        elif "embed_tokens" in key:
-            state_dict[key] = v[: config.vocab_size, :].contiguous().clone()
-            state_dict["lm_head.weight"] = v[: config.vocab_size, :].contiguous().clone()
-        else:
-            state_dict[key] = v.contiguous()
-
-    torch.set_default_dtype(dtype)
-
-    print("Loading the checkpoint in a Gemma model.")
-    with init_empty_weights():
-        model = RecurrentGemmaForCausalLM(config)
-    model.load_state_dict(state_dict, assign=True, strict=True)
-
-    model.config.torch_dtype = torch.float32
-    del model.config._name_or_path
-    print("Saving in the Transformers format.")
-
-    if push_to_hub:
-        print(f"pushing the model to {save_path}")
-    else:
-        model.save_pretrained(save_path, safe_serialization=safe_serialization)
-
-
-def write_tokenizer(input_tokenizer_path, save_path, push_to_hub=False):
-    # Initialize the tokenizer based on the `spm` model
-    tokenizer_class = GemmaTokenizer if GemmaTokenizerFast is None else GemmaTokenizerFast
-    print(f"Saving a {tokenizer_class.__name__} to {save_path}.")
-    tokenizer = tokenizer_class(input_tokenizer_path)
-    if push_to_hub:
-        tokenizer.push_to_hub(save_path)
-    else:
-        tokenizer.save_pretrained(save_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--input_checkpoint",
-        help="Absolute path to the target Gemma weights.",
-        default="/home/arthur/transformers_recurrentgemma/google/recurrent-gemma-2b-it/ToBeDeleted/2b-it.pt",
-    )
-    parser.add_argument(
-        "--tokenizer_checkpoint",
-        help="Location of Gemma tokenizer model",
-    )
-    parser.add_argument(
-        "--model_size",
-        default="2B",
-        choices=["2B", "7B", "tokenizer_only"],
-        help="'f' models correspond to the finetuned versions, and are specific to the Gemma2 official release. For more details on Gemma2, checkout the original repo: https://huggingface.co/google/gemma-7b",
-    )
-    parser.add_argument(
-        "--output_dir",
-        default="google/recurrent-gemma-2b-it-hf",
-        help="Location to write HF model and tokenizer",
-    )
-    parser.add_argument(
-        "--pickle_serialization",
-        help="Whether or not to save using `safetensors`.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--convert_tokenizer",
-        help="Whether or not to convert the tokenizer as well.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        help="Whether or not to push the model to the hub at `output_dir` instead of saving it locally.",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--dtype",
-        default="float32",
-        help="Target dtype of the converted model",
-    )
-    args = parser.parse_args()
-
-    if args.convert_tokenizer:
-        if args.tokenizer_checkpoint is None:
-            raise ValueError("Path to the tokenizer is required when passing --convert_tokenizer")
-
-        spm_path = os.path.join(args.tokenizer_checkpoint)
-        write_tokenizer(spm_path, args.output_dir, args.push_to_hub)
-
-    config = CONFIG_MAPPING[args.model_size]
-    dtype = getattr(torch, args.dtype)
-    write_model(
-        config=config,
-        input_base_path=args.input_checkpoint,
-        save_path=args.output_dir,
-        safe_serialization=not args.pickle_serialization,
-        push_to_hub=args.push_to_hub,
-        dtype=dtype,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/reformer/convert_reformer_trax_checkpoint_to_pytorch.py b/src/transformers/models/reformer/convert_reformer_trax_checkpoint_to_pytorch.py
deleted file mode 100755
index 55cad3c8bae1..000000000000
--- a/src/transformers/models/reformer/convert_reformer_trax_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,226 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Reformer checkpoint."""
-
-import argparse
-import pickle
-
-import numpy as np
-import torch
-from torch import nn
-
-from transformers import ReformerConfig, ReformerModelWithLMHead
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def set_param(torch_layer, weight, bias=None):
-    # set parameter of one layer
-    assert torch_layer.weight.shape == weight.shape, f"{torch_layer} layer.weight does not match"
-    torch_layer.weight = nn.Parameter(weight)
-    if bias is not None:
-        assert torch_layer.bias.shape == bias.shape, f"{torch_layer} layer.bias does not match"
-        torch_layer.bias = nn.Parameter(bias)
-
-
-def set_layer_weights_in_torch_lsh(weights, torch_layer, hidden_size):
-    # set torch weights for 1-to-1 comparison
-    np_query_key = np.asarray(weights[0])
-    np_value = np.asarray(weights[1])
-    np_dense = np.asarray(weights[2])
-
-    set_param(
-        torch_layer.self_attention.query_key,
-        torch.tensor(np_query_key).transpose(1, 2).contiguous().view(-1, hidden_size),
-    )
-    set_param(
-        torch_layer.self_attention.value,
-        torch.tensor(np_value).transpose(1, 2).contiguous().view(-1, hidden_size),
-    )
-    set_param(
-        torch_layer.output.dense,
-        torch.tensor(np_dense).view(-1, hidden_size).contiguous().transpose(0, 1),
-    )
-
-
-def set_layer_weights_in_torch_local(weights, torch_layer, hidden_size):
-    # set torch weights for 1-to-1 comparison
-    np_query = np.asarray(weights[0])
-    np_key = np.asarray(weights[1])
-    np_value = np.asarray(weights[2])
-    np_dense = np.asarray(weights[3])
-
-    set_param(
-        torch_layer.self_attention.query,
-        torch.tensor(np_query).transpose(1, 2).contiguous().view(-1, hidden_size),
-    )
-    set_param(
-        torch_layer.self_attention.key,
-        torch.tensor(np_key).transpose(1, 2).contiguous().view(-1, hidden_size),
-    )
-    set_param(
-        torch_layer.self_attention.value,
-        torch.tensor(np_value).transpose(1, 2).contiguous().view(-1, hidden_size),
-    )
-    set_param(
-        torch_layer.output.dense,
-        torch.tensor(np_dense).view(-1, hidden_size).contiguous().transpose(0, 1),
-    )
-
-
-def set_block_weights_in_torch(weights, torch_block, hidden_size):
-    # layernorm 1
-    layer_norm_1 = weights[0][0][0]
-    layer_norm_1_weight = np.asarray(layer_norm_1[0])
-    layer_norm_1_bias = np.asarray(layer_norm_1[1])
-    set_param(
-        torch_block.attention.layer_norm,
-        torch.tensor(layer_norm_1_weight),
-        torch.tensor(layer_norm_1_bias),
-    )
-
-    # lsh weights + output
-    attn_weights = weights[0][1]
-    if len(attn_weights) < 4:
-        set_layer_weights_in_torch_lsh(attn_weights, torch_block.attention, hidden_size)
-    else:
-        set_layer_weights_in_torch_local(attn_weights, torch_block.attention, hidden_size)
-
-    # intermediate weighs
-    intermediate_weights = weights[2][0][1][2]
-
-    # Chunked Feed Forward
-    if len(intermediate_weights) == 4:
-        intermediate_weights = intermediate_weights[2]
-
-    # layernorm 2
-    layer_norm_2_weight = np.asarray(intermediate_weights[0][0])
-    layer_norm_2_bias = np.asarray(intermediate_weights[0][1])
-    set_param(
-        torch_block.feed_forward.layer_norm,
-        torch.tensor(layer_norm_2_weight),
-        torch.tensor(layer_norm_2_bias),
-    )
-
-    # intermediate dense
-    inter_dense_weight = np.asarray(intermediate_weights[1][0])
-    inter_dense_bias = np.asarray(intermediate_weights[1][1])
-    set_param(
-        torch_block.feed_forward.dense.dense,
-        torch.tensor(inter_dense_weight).transpose(0, 1).contiguous(),
-        torch.tensor(inter_dense_bias),
-    )
-
-    # intermediate out
-    out_dense_weight = np.asarray(intermediate_weights[4][0])
-    out_dense_bias = np.asarray(intermediate_weights[4][1])
-    set_param(
-        torch_block.feed_forward.output.dense,
-        torch.tensor(out_dense_weight).transpose(0, 1).contiguous(),
-        torch.tensor(out_dense_bias),
-    )
-
-
-def set_model_weights_in_torch(weights, torch_model, hidden_size):
-    # reformer model
-    torch_model_reformer = torch_model.reformer
-
-    # word embeds
-    word_embeddings = np.asarray(weights[1])
-    set_param(
-        torch_model_reformer.embeddings.word_embeddings,
-        torch.tensor(word_embeddings),
-    )
-
-    if isinstance(weights[3], tuple):
-        position_embeddings = torch_model_reformer.embeddings.position_embeddings
-        for emb_idx in range(len(position_embeddings.weights)):
-            emb_weights = np.asarray(weights[3][emb_idx][0])
-            assert position_embeddings.weights[emb_idx].shape == emb_weights.shape, (
-                f"{position_embeddings[emb_idx]} emb does not match"
-            )
-            position_embeddings.weights[emb_idx] = nn.Parameter(torch.tensor(emb_weights))
-
-    trax_layer_weights = weights[5]
-    assert len(torch_model_reformer.encoder.layers) * 4 == len(trax_layer_weights), (
-        "HF and trax model do not have the same number of layers"
-    )
-    for layer_idx, layer in enumerate(torch_model_reformer.encoder.layers):
-        block_weights = trax_layer_weights[4 * layer_idx : 4 * (layer_idx + 1)]
-        set_block_weights_in_torch(block_weights, layer, hidden_size)
-
-    # output layer norm
-    layer_norm_out_weight = np.asarray(weights[7][0])
-    layer_norm_out_bias = np.asarray(weights[7][1])
-    set_param(
-        torch_model_reformer.encoder.layer_norm,
-        torch.tensor(layer_norm_out_weight),
-        torch.tensor(layer_norm_out_bias),
-    )
-
-    # output embeddings
-    output_embed_weights = np.asarray(weights[9][0])
-    output_embed_bias = np.asarray(weights[9][1])
-    set_param(
-        torch_model.lm_head.decoder,
-        torch.tensor(output_embed_weights).transpose(0, 1).contiguous(),
-        torch.tensor(output_embed_bias),
-    )
-
-
-def convert_trax_checkpoint_to_pytorch(trax_model_pkl_path, config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = ReformerConfig.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = ReformerModelWithLMHead(config)
-
-    with open(trax_model_pkl_path, "rb") as f:
-        model_weights = pickle.load(f)["weights"]
-
-    set_model_weights_in_torch(model_weights, model, config.hidden_size)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--trax_model_pkl_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the TensorFlow checkpoint path.\n"
-        "Given the files are in the pickle format, please be wary of passing it files you trust.",
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained Reformer model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_trax_checkpoint_to_pytorch(args.trax_model_pkl_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/regnet/convert_regnet_seer_10b_to_pytorch.py b/src/transformers/models/regnet/convert_regnet_seer_10b_to_pytorch.py
deleted file mode 100644
index 95bd5b854282..000000000000
--- a/src/transformers/models/regnet/convert_regnet_seer_10b_to_pytorch.py
+++ /dev/null
@@ -1,308 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RegNet 10B checkpoints vissl."""
-# You need to install a specific version of classy vision
-# pip install git+https://github.com/FrancescoSaverioZuppichini/ClassyVision.git@convert_weights
-
-import argparse
-import json
-import os
-import re
-from collections import OrderedDict
-from dataclasses import dataclass, field
-from functools import partial
-from pathlib import Path
-from pprint import pprint
-from typing import Dict, List, Optional, Tuple
-
-import torch
-import torch.nn as nn
-from classy_vision.models.regnet import RegNet, RegNetParams
-from huggingface_hub import hf_hub_download
-from torch import Tensor
-from vissl.models.model_helpers import get_trunk_forward_outputs
-
-from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
-from transformers.modeling_utils import _load_state_dict_into_meta_model, load_state_dict
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger()
-
-
-@dataclass
-class Tracker:
-    module: nn.Module
-    traced: List[nn.Module] = field(default_factory=list)
-    handles: list = field(default_factory=list)
-    name2module: Dict[str, nn.Module] = field(default_factory=OrderedDict)
-
-    def _forward_hook(self, m, inputs: Tensor, outputs: Tensor, name: str):
-        has_not_submodules = len(list(m.modules())) == 1 or isinstance(m, nn.Conv2d) or isinstance(m, nn.BatchNorm2d)
-        if has_not_submodules:
-            self.traced.append(m)
-            self.name2module[name] = m
-
-    def __call__(self, x: Tensor):
-        for name, m in self.module.named_modules():
-            self.handles.append(m.register_forward_hook(partial(self._forward_hook, name=name)))
-        self.module(x)
-        [x.remove() for x in self.handles]
-        return self
-
-    @property
-    def parametrized(self):
-        # check the len of the state_dict keys to see if we have learnable params
-        return {k: v for k, v in self.name2module.items() if len(list(v.state_dict().keys())) > 0}
-
-
-class FakeRegNetVisslWrapper(nn.Module):
-    """
-    Fake wrapper for RegNet that mimics what vissl does without the need to pass a config file.
-    """
-
-    def __init__(self, model: nn.Module):
-        super().__init__()
-
-        feature_blocks: List[Tuple[str, nn.Module]] = []
-        # - get the stem
-        feature_blocks.append(("conv1", model.stem))
-        # - get all the feature blocks
-        for k, v in model.trunk_output.named_children():
-            assert k.startswith("block"), f"Unexpected layer name {k}"
-            block_index = len(feature_blocks) + 1
-            feature_blocks.append((f"res{block_index}", v))
-
-        self._feature_blocks = nn.ModuleDict(feature_blocks)
-
-    def forward(self, x: Tensor):
-        return get_trunk_forward_outputs(
-            x,
-            out_feat_keys=None,
-            feature_blocks=self._feature_blocks,
-        )
-
-
-class FakeRegNetParams(RegNetParams):
-    """
-    Used to instantiace a RegNet model from classy vision with the same depth as the 10B one but with super small
-    parameters, so we can trace it in memory.
-    """
-
-    def get_expanded_params(self):
-        return [(8, 2, 2, 8, 1.0), (8, 2, 7, 8, 1.0), (8, 2, 17, 8, 1.0), (8, 2, 1, 8, 1.0)]
-
-
-def get_from_to_our_keys(model_name: str) -> Dict[str, str]:
-    """
-    Returns a dictionary that maps from original model's key -> our implementation's keys
-    """
-
-    # create our model (with small weights)
-    our_config = RegNetConfig(depths=[2, 7, 17, 1], hidden_sizes=[8, 8, 8, 8], groups_width=8)
-    if "in1k" in model_name:
-        our_model = RegNetForImageClassification(our_config)
-    else:
-        our_model = RegNetModel(our_config)
-    # create from model (with small weights)
-    from_model = FakeRegNetVisslWrapper(
-        RegNet(FakeRegNetParams(depth=27, group_width=1010, w_0=1744, w_a=620.83, w_m=2.52))
-    )
-
-    with torch.no_grad():
-        from_model = from_model.eval()
-        our_model = our_model.eval()
-
-        x = torch.randn((1, 3, 32, 32))
-        # trace both
-        dest_tracker = Tracker(our_model)
-        dest_traced = dest_tracker(x).parametrized
-
-        pprint(dest_tracker.name2module)
-        src_tracker = Tracker(from_model)
-        src_traced = src_tracker(x).parametrized
-
-    # convert the keys -> module dict to keys -> params
-    def to_params_dict(dict_with_modules):
-        params_dict = OrderedDict()
-        for name, module in dict_with_modules.items():
-            for param_name, param in module.state_dict().items():
-                params_dict[f"{name}.{param_name}"] = param
-        return params_dict
-
-    from_to_ours_keys = {}
-
-    src_state_dict = to_params_dict(src_traced)
-    dst_state_dict = to_params_dict(dest_traced)
-
-    for (src_key, src_param), (dest_key, dest_param) in zip(src_state_dict.items(), dst_state_dict.items()):
-        from_to_ours_keys[src_key] = dest_key
-        logger.info(f"{src_key} -> {dest_key}")
-    # if "in1k" was in the model_name it means it must have a classification head (was finetuned)
-    if "in1k" in model_name:
-        from_to_ours_keys["0.clf.0.weight"] = "classifier.1.weight"
-        from_to_ours_keys["0.clf.0.bias"] = "classifier.1.bias"
-
-    return from_to_ours_keys
-
-
-def convert_weights_and_push(save_directory: Path, model_name: Optional[str] = None, push_to_hub: bool = True):
-    filename = "imagenet-1k-id2label.json"
-    num_labels = 1000
-
-    repo_id = "huggingface/label-files"
-    num_labels = num_labels
-    id2label = json.loads(Path(hf_hub_download(repo_id, filename, repo_type="dataset")).read_text())
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    id2label = id2label
-    label2id = {v: k for k, v in id2label.items()}
-
-    ImageNetPreTrainedConfig = partial(RegNetConfig, num_labels=num_labels, id2label=id2label, label2id=label2id)
-
-    names_to_config = {
-        "regnet-y-10b-seer": ImageNetPreTrainedConfig(
-            depths=[2, 7, 17, 1], hidden_sizes=[2020, 4040, 11110, 28280], groups_width=1010
-        ),
-        # finetuned on imagenet
-        "regnet-y-10b-seer-in1k": ImageNetPreTrainedConfig(
-            depths=[2, 7, 17, 1], hidden_sizes=[2020, 4040, 11110, 28280], groups_width=1010
-        ),
-    }
-
-    # add seer weights logic
-    def load_using_classy_vision(checkpoint_url: str) -> Tuple[Dict, Dict]:
-        files = torch.hub.load_state_dict_from_url(checkpoint_url, model_dir=str(save_directory), map_location="cpu")
-        # check if we have a head, if yes add it
-        model_state_dict = files["classy_state_dict"]["base_model"]["model"]
-        return model_state_dict["trunk"], model_state_dict["heads"]
-
-    names_to_from_model = {
-        "regnet-y-10b-seer": partial(
-            load_using_classy_vision,
-            "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch",
-        ),
-        "regnet-y-10b-seer-in1k": partial(
-            load_using_classy_vision,
-            "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch",
-        ),
-    }
-
-    from_to_ours_keys = get_from_to_our_keys(model_name)
-
-    if not (save_directory / f"{model_name}.pth").exists():
-        logger.info("Loading original state_dict.")
-        from_state_dict_trunk, from_state_dict_head = names_to_from_model[model_name]()
-        from_state_dict = from_state_dict_trunk
-        if "in1k" in model_name:
-            # add the head
-            from_state_dict = {**from_state_dict_trunk, **from_state_dict_head}
-        logger.info("Done!")
-
-        converted_state_dict = {}
-
-        not_used_keys = list(from_state_dict.keys())
-        regex = r"\.block.-part."
-        # this is "interesting", so the original checkpoints have `block[0,1]-part` in each key name, we remove it
-        for key in from_state_dict.keys():
-            # remove the weird "block[0,1]-part" from the key
-            src_key = re.sub(regex, "", key)
-            # now src_key from the model checkpoints is the one we got from the original model after tracing, so use it to get the correct destination key
-            dest_key = from_to_ours_keys[src_key]
-            # store the parameter with our key
-            converted_state_dict[dest_key] = from_state_dict[key]
-            not_used_keys.remove(key)
-        # check that all keys have been updated
-        assert len(not_used_keys) == 0, f"Some keys where not used {','.join(not_used_keys)}"
-
-        logger.info(f"The following keys were not used: {','.join(not_used_keys)}")
-
-        # save our state dict to disk
-        torch.save(converted_state_dict, save_directory / f"{model_name}.pth")
-
-        del converted_state_dict
-    else:
-        logger.info("The state_dict was already stored on disk.")
-    if push_to_hub:
-        logger.info(f"Token is {os.environ['HF_TOKEN']}")
-        logger.info("Loading our model.")
-        # create our model
-        our_config = names_to_config[model_name]
-        our_model_func = RegNetModel
-        if "in1k" in model_name:
-            our_model_func = RegNetForImageClassification
-        with torch.device("meta"):
-            our_model = our_model_func(our_config)
-        logger.info("Loading state_dict in our model.")
-        # load state dict
-        state_dict_keys = our_model.state_dict().keys()
-        state_dict = load_state_dict(save_directory / f"{model_name}.pth", weights_only=True)
-        fixed_state_dict = state_dict = {our_model._fix_state_dict_key_on_load(k)[0]: v for k, v in state_dict.items()}
-        _load_state_dict_into_meta_model(
-            our_model,
-            fixed_state_dict,
-            start_prefix="",
-            expected_keys=state_dict_keys,
-        )
-        logger.info("Finally, pushing!")
-        # push it to hub
-        our_model.push_to_hub(
-            repo_path_or_name=save_directory / model_name,
-            commit_message="Add model",
-            output_dir=save_directory / model_name,
-        )
-        size = 384
-        # we can use the convnext one
-        image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k", size=size)
-        image_processor.push_to_hub(
-            repo_path_or_name=save_directory / model_name,
-            commit_message="Add image processor",
-            output_dir=save_directory / model_name,
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default=None,
-        type=str,
-        help=(
-            "The name of the model you wish to convert, it must be one of the supported regnet* architecture,"
-            " currently: regnetx-*, regnety-*. If `None`, all of them will the converted."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=Path,
-        required=True,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        default=True,
-        type=bool,
-        required=False,
-        help="If True, push model and image processor to the hub.",
-    )
-
-    args = parser.parse_args()
-
-    pytorch_dump_folder_path: Path = args.pytorch_dump_folder_path
-    pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
-    convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
diff --git a/src/transformers/models/regnet/convert_regnet_to_pytorch.py b/src/transformers/models/regnet/convert_regnet_to_pytorch.py
deleted file mode 100644
index 9544400416bd..000000000000
--- a/src/transformers/models/regnet/convert_regnet_to_pytorch.py
+++ /dev/null
@@ -1,458 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RegNet checkpoints from timm and vissl."""
-
-import argparse
-import json
-from dataclasses import dataclass, field
-from functools import partial
-from pathlib import Path
-from typing import Callable, Dict, List, Optional, Tuple
-
-import timm
-import torch
-import torch.nn as nn
-from classy_vision.models.regnet import RegNet, RegNetParams, RegNetY32gf, RegNetY64gf, RegNetY128gf
-from huggingface_hub import hf_hub_download
-from torch import Tensor
-from vissl.models.model_helpers import get_trunk_forward_outputs
-
-from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger()
-
-
-@dataclass
-class Tracker:
-    module: nn.Module
-    traced: List[nn.Module] = field(default_factory=list)
-    handles: list = field(default_factory=list)
-
-    def _forward_hook(self, m, inputs: Tensor, outputs: Tensor):
-        has_not_submodules = len(list(m.modules())) == 1 or isinstance(m, nn.Conv2d) or isinstance(m, nn.BatchNorm2d)
-        if has_not_submodules:
-            self.traced.append(m)
-
-    def __call__(self, x: Tensor):
-        for m in self.module.modules():
-            self.handles.append(m.register_forward_hook(self._forward_hook))
-        self.module(x)
-        [x.remove() for x in self.handles]
-        return self
-
-    @property
-    def parametrized(self):
-        # check the len of the state_dict keys to see if we have learnable params
-        return list(filter(lambda x: len(list(x.state_dict().keys())) > 0, self.traced))
-
-
-@dataclass
-class ModuleTransfer:
-    src: nn.Module
-    dest: nn.Module
-    verbose: int = 1
-    src_skip: List = field(default_factory=list)
-    dest_skip: List = field(default_factory=list)
-    raise_if_mismatch: bool = True
-
-    def __call__(self, x: Tensor):
-        """
-        Transfer the weights of `self.src` to `self.dest` by performing a forward pass using `x` as input. Under the
-        hood we tracked all the operations in both modules.
-        """
-        dest_traced = Tracker(self.dest)(x).parametrized
-        src_traced = Tracker(self.src)(x).parametrized
-
-        src_traced = list(filter(lambda x: type(x) not in self.src_skip, src_traced))
-        dest_traced = list(filter(lambda x: type(x) not in self.dest_skip, dest_traced))
-
-        if len(dest_traced) != len(src_traced) and self.raise_if_mismatch:
-            raise Exception(
-                f"Numbers of operations are different. Source module has {len(src_traced)} operations while"
-                f" destination module has {len(dest_traced)}."
-            )
-
-        for dest_m, src_m in zip(dest_traced, src_traced):
-            dest_m.load_state_dict(src_m.state_dict())
-            if self.verbose == 1:
-                print(f"Transfered from={src_m} to={dest_m}")
-
-
-class FakeRegNetVisslWrapper(nn.Module):
-    """
-    Fake wrapper for RegNet that mimics what vissl does without the need to pass a config file.
-    """
-
-    def __init__(self, model: nn.Module):
-        super().__init__()
-
-        feature_blocks: List[Tuple[str, nn.Module]] = []
-        # - get the stem
-        feature_blocks.append(("conv1", model.stem))
-        # - get all the feature blocks
-        for k, v in model.trunk_output.named_children():
-            assert k.startswith("block"), f"Unexpected layer name {k}"
-            block_index = len(feature_blocks) + 1
-            feature_blocks.append((f"res{block_index}", v))
-
-        self._feature_blocks = nn.ModuleDict(feature_blocks)
-
-    def forward(self, x: Tensor):
-        return get_trunk_forward_outputs(
-            x,
-            out_feat_keys=None,
-            feature_blocks=self._feature_blocks,
-        )
-
-
-class NameToFromModelFuncMap(dict):
-    """
-    A Dictionary with some additional logic to return a function that creates the correct original model.
-    """
-
-    def convert_name_to_timm(self, x: str) -> str:
-        x_split = x.split("-")
-        return x_split[0] + x_split[1] + "_" + "".join(x_split[2:])
-
-    def __getitem__(self, x: str) -> Callable[[], Tuple[nn.Module, Dict]]:
-        # default to timm!
-        if x not in self:
-            x = self.convert_name_to_timm(x)
-            val = partial(lambda: (timm.create_model(x, pretrained=True).eval(), None))
-
-        else:
-            val = super().__getitem__(x)
-
-        return val
-
-
-class NameToOurModelFuncMap(dict):
-    """
-    A Dictionary with some additional logic to return the correct hugging face RegNet class reference.
-    """
-
-    def __getitem__(self, x: str) -> Callable[[], nn.Module]:
-        if "seer" in x and "in1k" not in x:
-            val = RegNetModel
-        else:
-            val = RegNetForImageClassification
-        return val
-
-
-def manually_copy_vissl_head(from_state_dict, to_state_dict, keys: List[Tuple[str, str]]):
-    for from_key, to_key in keys:
-        to_state_dict[to_key] = from_state_dict[from_key].clone()
-        print(f"Copied key={from_key} to={to_key}")
-    return to_state_dict
-
-
-def convert_weight_and_push(
-    name: str,
-    from_model_func: Callable[[], nn.Module],
-    our_model_func: Callable[[], nn.Module],
-    config: RegNetConfig,
-    save_directory: Path,
-    push_to_hub: bool = True,
-):
-    print(f"Converting {name}...")
-    with torch.no_grad():
-        from_model, from_state_dict = from_model_func()
-        our_model = our_model_func(config).eval()
-        module_transfer = ModuleTransfer(src=from_model, dest=our_model, raise_if_mismatch=False)
-        x = torch.randn((1, 3, 224, 224))
-        module_transfer(x)
-
-    if from_state_dict is not None:
-        keys = []
-        # for seer - in1k finetuned we have to manually copy the head
-        if "seer" in name and "in1k" in name:
-            keys = [("0.clf.0.weight", "classifier.1.weight"), ("0.clf.0.bias", "classifier.1.bias")]
-        to_state_dict = manually_copy_vissl_head(from_state_dict, our_model.state_dict(), keys)
-        our_model.load_state_dict(to_state_dict)
-
-    our_outputs = our_model(x, output_hidden_states=True)
-    our_output = (
-        our_outputs.logits if isinstance(our_model, RegNetForImageClassification) else our_outputs.last_hidden_state
-    )
-
-    from_output = from_model(x)
-    from_output = from_output[-1] if isinstance(from_output, list) else from_output
-
-    # now since I don't want to use any config files, vissl seer model doesn't actually have an head, so let's just check the last hidden state
-    if "seer" in name and "in1k" in name:
-        our_output = our_outputs.hidden_states[-1]
-
-    assert torch.allclose(from_output, our_output), "The model logits don't match the original one."
-
-    if push_to_hub:
-        our_model.push_to_hub(
-            repo_path_or_name=save_directory / name,
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
-
-        size = 224 if "seer" not in name else 384
-        # we can use the convnext one
-        image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k", size=size)
-        image_processor.push_to_hub(
-            repo_path_or_name=save_directory / name,
-            commit_message="Add image processor",
-            use_temp_dir=True,
-        )
-
-        print(f"Pushed {name}")
-
-
-def convert_weights_and_push(save_directory: Path, model_name: Optional[str] = None, push_to_hub: bool = True):
-    filename = "imagenet-1k-id2label.json"
-    num_labels = 1000
-    expected_shape = (1, num_labels)
-
-    repo_id = "huggingface/label-files"
-    num_labels = num_labels
-    id2label = json.loads(Path(hf_hub_download(repo_id, filename, repo_type="dataset")).read_text())
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    id2label = id2label
-    label2id = {v: k for k, v in id2label.items()}
-
-    ImageNetPreTrainedConfig = partial(RegNetConfig, num_labels=num_labels, id2label=id2label, label2id=label2id)
-
-    names_to_config = {
-        "regnet-x-002": ImageNetPreTrainedConfig(
-            depths=[1, 1, 4, 7], hidden_sizes=[24, 56, 152, 368], groups_width=8, layer_type="x"
-        ),
-        "regnet-x-004": ImageNetPreTrainedConfig(
-            depths=[1, 2, 7, 12], hidden_sizes=[32, 64, 160, 384], groups_width=16, layer_type="x"
-        ),
-        "regnet-x-006": ImageNetPreTrainedConfig(
-            depths=[1, 3, 5, 7], hidden_sizes=[48, 96, 240, 528], groups_width=24, layer_type="x"
-        ),
-        "regnet-x-008": ImageNetPreTrainedConfig(
-            depths=[1, 3, 7, 5], hidden_sizes=[64, 128, 288, 672], groups_width=16, layer_type="x"
-        ),
-        "regnet-x-016": ImageNetPreTrainedConfig(
-            depths=[2, 4, 10, 2], hidden_sizes=[72, 168, 408, 912], groups_width=24, layer_type="x"
-        ),
-        "regnet-x-032": ImageNetPreTrainedConfig(
-            depths=[2, 6, 15, 2], hidden_sizes=[96, 192, 432, 1008], groups_width=48, layer_type="x"
-        ),
-        "regnet-x-040": ImageNetPreTrainedConfig(
-            depths=[2, 5, 14, 2], hidden_sizes=[80, 240, 560, 1360], groups_width=40, layer_type="x"
-        ),
-        "regnet-x-064": ImageNetPreTrainedConfig(
-            depths=[2, 4, 10, 1], hidden_sizes=[168, 392, 784, 1624], groups_width=56, layer_type="x"
-        ),
-        "regnet-x-080": ImageNetPreTrainedConfig(
-            depths=[2, 5, 15, 1], hidden_sizes=[80, 240, 720, 1920], groups_width=120, layer_type="x"
-        ),
-        "regnet-x-120": ImageNetPreTrainedConfig(
-            depths=[2, 5, 11, 1], hidden_sizes=[224, 448, 896, 2240], groups_width=112, layer_type="x"
-        ),
-        "regnet-x-160": ImageNetPreTrainedConfig(
-            depths=[2, 6, 13, 1], hidden_sizes=[256, 512, 896, 2048], groups_width=128, layer_type="x"
-        ),
-        "regnet-x-320": ImageNetPreTrainedConfig(
-            depths=[2, 7, 13, 1], hidden_sizes=[336, 672, 1344, 2520], groups_width=168, layer_type="x"
-        ),
-        # y variant
-        "regnet-y-002": ImageNetPreTrainedConfig(depths=[1, 1, 4, 7], hidden_sizes=[24, 56, 152, 368], groups_width=8),
-        "regnet-y-004": ImageNetPreTrainedConfig(
-            depths=[1, 3, 6, 6], hidden_sizes=[48, 104, 208, 440], groups_width=8
-        ),
-        "regnet-y-006": ImageNetPreTrainedConfig(
-            depths=[1, 3, 7, 4], hidden_sizes=[48, 112, 256, 608], groups_width=16
-        ),
-        "regnet-y-008": ImageNetPreTrainedConfig(
-            depths=[1, 3, 8, 2], hidden_sizes=[64, 128, 320, 768], groups_width=16
-        ),
-        "regnet-y-016": ImageNetPreTrainedConfig(
-            depths=[2, 6, 17, 2], hidden_sizes=[48, 120, 336, 888], groups_width=24
-        ),
-        "regnet-y-032": ImageNetPreTrainedConfig(
-            depths=[2, 5, 13, 1], hidden_sizes=[72, 216, 576, 1512], groups_width=24
-        ),
-        "regnet-y-040": ImageNetPreTrainedConfig(
-            depths=[2, 6, 12, 2], hidden_sizes=[128, 192, 512, 1088], groups_width=64
-        ),
-        "regnet-y-064": ImageNetPreTrainedConfig(
-            depths=[2, 7, 14, 2], hidden_sizes=[144, 288, 576, 1296], groups_width=72
-        ),
-        "regnet-y-080": ImageNetPreTrainedConfig(
-            depths=[2, 4, 10, 1], hidden_sizes=[168, 448, 896, 2016], groups_width=56
-        ),
-        "regnet-y-120": ImageNetPreTrainedConfig(
-            depths=[2, 5, 11, 1], hidden_sizes=[224, 448, 896, 2240], groups_width=112
-        ),
-        "regnet-y-160": ImageNetPreTrainedConfig(
-            depths=[2, 4, 11, 1], hidden_sizes=[224, 448, 1232, 3024], groups_width=112
-        ),
-        "regnet-y-320": ImageNetPreTrainedConfig(
-            depths=[2, 5, 12, 1], hidden_sizes=[232, 696, 1392, 3712], groups_width=232
-        ),
-        # models created by SEER -> https://arxiv.org/abs/2202.08360
-        "regnet-y-320-seer": RegNetConfig(depths=[2, 5, 12, 1], hidden_sizes=[232, 696, 1392, 3712], groups_width=232),
-        "regnet-y-640-seer": RegNetConfig(depths=[2, 5, 12, 1], hidden_sizes=[328, 984, 1968, 4920], groups_width=328),
-        "regnet-y-1280-seer": RegNetConfig(
-            depths=[2, 7, 17, 1], hidden_sizes=[528, 1056, 2904, 7392], groups_width=264
-        ),
-        "regnet-y-2560-seer": RegNetConfig(
-            depths=[3, 7, 16, 1], hidden_sizes=[640, 1696, 2544, 5088], groups_width=640
-        ),
-        "regnet-y-10b-seer": ImageNetPreTrainedConfig(
-            depths=[2, 7, 17, 1], hidden_sizes=[2020, 4040, 11110, 28280], groups_width=1010
-        ),
-        # finetuned on imagenet
-        "regnet-y-320-seer-in1k": ImageNetPreTrainedConfig(
-            depths=[2, 5, 12, 1], hidden_sizes=[232, 696, 1392, 3712], groups_width=232
-        ),
-        "regnet-y-640-seer-in1k": ImageNetPreTrainedConfig(
-            depths=[2, 5, 12, 1], hidden_sizes=[328, 984, 1968, 4920], groups_width=328
-        ),
-        "regnet-y-1280-seer-in1k": ImageNetPreTrainedConfig(
-            depths=[2, 7, 17, 1], hidden_sizes=[528, 1056, 2904, 7392], groups_width=264
-        ),
-        "regnet-y-2560-seer-in1k": ImageNetPreTrainedConfig(
-            depths=[3, 7, 16, 1], hidden_sizes=[640, 1696, 2544, 5088], groups_width=640
-        ),
-        "regnet-y-10b-seer-in1k": ImageNetPreTrainedConfig(
-            depths=[2, 7, 17, 1], hidden_sizes=[2020, 4040, 11110, 28280], groups_width=1010
-        ),
-    }
-
-    names_to_ours_model_map = NameToOurModelFuncMap()
-    names_to_from_model_map = NameToFromModelFuncMap()
-    # add seer weights logic
-
-    def load_using_classy_vision(checkpoint_url: str, model_func: Callable[[], nn.Module]) -> Tuple[nn.Module, Dict]:
-        files = torch.hub.load_state_dict_from_url(checkpoint_url, model_dir=str(save_directory), map_location="cpu")
-        model = model_func()
-        # check if we have a head, if yes add it
-        model_state_dict = files["classy_state_dict"]["base_model"]["model"]
-        state_dict = model_state_dict["trunk"]
-        model.load_state_dict(state_dict)
-        return model.eval(), model_state_dict["heads"]
-
-    # pretrained
-    names_to_from_model_map["regnet-y-320-seer"] = partial(
-        load_using_classy_vision,
-        "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet32d/seer_regnet32gf_model_iteration244000.torch",
-        lambda: FakeRegNetVisslWrapper(RegNetY32gf()),
-    )
-
-    names_to_from_model_map["regnet-y-640-seer"] = partial(
-        load_using_classy_vision,
-        "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet64/seer_regnet64gf_model_final_checkpoint_phase0.torch",
-        lambda: FakeRegNetVisslWrapper(RegNetY64gf()),
-    )
-
-    names_to_from_model_map["regnet-y-1280-seer"] = partial(
-        load_using_classy_vision,
-        "https://dl.fbaipublicfiles.com/vissl/model_zoo/swav_ig1b_regnet128Gf_cnstant_bs32_node16_sinkhorn10_proto16k_syncBN64_warmup8k/model_final_checkpoint_phase0.torch",
-        lambda: FakeRegNetVisslWrapper(RegNetY128gf()),
-    )
-
-    names_to_from_model_map["regnet-y-10b-seer"] = partial(
-        load_using_classy_vision,
-        "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch",
-        lambda: FakeRegNetVisslWrapper(
-            RegNet(RegNetParams(depth=27, group_width=1010, w_0=1744, w_a=620.83, w_m=2.52))
-        ),
-    )
-
-    # IN1K finetuned
-    names_to_from_model_map["regnet-y-320-seer-in1k"] = partial(
-        load_using_classy_vision,
-        "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet32_finetuned_in1k_model_final_checkpoint_phase78.torch",
-        lambda: FakeRegNetVisslWrapper(RegNetY32gf()),
-    )
-
-    names_to_from_model_map["regnet-y-640-seer-in1k"] = partial(
-        load_using_classy_vision,
-        "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet64_finetuned_in1k_model_final_checkpoint_phase78.torch",
-        lambda: FakeRegNetVisslWrapper(RegNetY64gf()),
-    )
-
-    names_to_from_model_map["regnet-y-1280-seer-in1k"] = partial(
-        load_using_classy_vision,
-        "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet128_finetuned_in1k_model_final_checkpoint_phase78.torch",
-        lambda: FakeRegNetVisslWrapper(RegNetY128gf()),
-    )
-
-    names_to_from_model_map["regnet-y-10b-seer-in1k"] = partial(
-        load_using_classy_vision,
-        "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch",
-        lambda: FakeRegNetVisslWrapper(
-            RegNet(RegNetParams(depth=27, group_width=1010, w_0=1744, w_a=620.83, w_m=2.52))
-        ),
-    )
-
-    if model_name:
-        convert_weight_and_push(
-            model_name,
-            names_to_from_model_map[model_name],
-            names_to_ours_model_map[model_name],
-            names_to_config[model_name],
-            save_directory,
-            push_to_hub,
-        )
-    else:
-        for model_name, config in names_to_config.items():
-            convert_weight_and_push(
-                model_name,
-                names_to_from_model_map[model_name],
-                names_to_ours_model_map[model_name],
-                config,
-                save_directory,
-                push_to_hub,
-            )
-    return config, expected_shape
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default=None,
-        type=str,
-        help=(
-            "The name of the model you wish to convert, it must be one of the supported regnet* architecture,"
-            " currently: regnetx-*, regnety-*. If `None`, all of them will the converted."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=Path,
-        required=True,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        default=True,
-        type=bool,
-        required=False,
-        help="If True, push model and image processor to the hub.",
-    )
-
-    args = parser.parse_args()
-
-    pytorch_dump_folder_path: Path = args.pytorch_dump_folder_path
-    pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
-    convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
diff --git a/src/transformers/models/rembert/convert_rembert_tf_checkpoint_to_pytorch.py b/src/transformers/models/rembert/convert_rembert_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index 622d507080e4..000000000000
--- a/src/transformers/models/rembert/convert_rembert_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RemBERT checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_rembert_tf_checkpoint_to_pytorch(tf_checkpoint_path, bert_config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = RemBertConfig.from_json_file(bert_config_file)
-    print("Building PyTorch model from configuration: {}".format(str(config)))
-    model = RemBertModel(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_rembert(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print("Save PyTorch model to {}".format(pytorch_dump_path))
-    torch.save(model.state_dict(), pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--rembert_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained RemBERT model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/resnet/convert_resnet_to_pytorch.py b/src/transformers/models/resnet/convert_resnet_to_pytorch.py
deleted file mode 100644
index 4909f1dc6703..000000000000
--- a/src/transformers/models/resnet/convert_resnet_to_pytorch.py
+++ /dev/null
@@ -1,199 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ResNet checkpoints from timm."""
-
-import argparse
-import json
-from dataclasses import dataclass, field
-from functools import partial
-from pathlib import Path
-from typing import List, Optional
-
-import timm
-import torch
-import torch.nn as nn
-from huggingface_hub import hf_hub_download
-from torch import Tensor
-
-from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger()
-
-
-@dataclass
-class Tracker:
-    module: nn.Module
-    traced: List[nn.Module] = field(default_factory=list)
-    handles: list = field(default_factory=list)
-
-    def _forward_hook(self, m, inputs: Tensor, outputs: Tensor):
-        has_not_submodules = len(list(m.modules())) == 1 or isinstance(m, nn.Conv2d) or isinstance(m, nn.BatchNorm2d)
-        if has_not_submodules:
-            self.traced.append(m)
-
-    def __call__(self, x: Tensor):
-        for m in self.module.modules():
-            self.handles.append(m.register_forward_hook(self._forward_hook))
-        self.module(x)
-        [x.remove() for x in self.handles]
-        return self
-
-    @property
-    def parametrized(self):
-        # check the len of the state_dict keys to see if we have learnable params
-        return list(filter(lambda x: len(list(x.state_dict().keys())) > 0, self.traced))
-
-
-@dataclass
-class ModuleTransfer:
-    src: nn.Module
-    dest: nn.Module
-    verbose: int = 0
-    src_skip: List = field(default_factory=list)
-    dest_skip: List = field(default_factory=list)
-
-    def __call__(self, x: Tensor):
-        """
-        Transfer the weights of `self.src` to `self.dest` by performing a forward pass using `x` as input. Under the
-        hood we tracked all the operations in both modules.
-        """
-        dest_traced = Tracker(self.dest)(x).parametrized
-        src_traced = Tracker(self.src)(x).parametrized
-
-        src_traced = list(filter(lambda x: type(x) not in self.src_skip, src_traced))
-        dest_traced = list(filter(lambda x: type(x) not in self.dest_skip, dest_traced))
-
-        if len(dest_traced) != len(src_traced):
-            raise Exception(
-                f"Numbers of operations are different. Source module has {len(src_traced)} operations while"
-                f" destination module has {len(dest_traced)}."
-            )
-
-        for dest_m, src_m in zip(dest_traced, src_traced):
-            dest_m.load_state_dict(src_m.state_dict())
-            if self.verbose == 1:
-                print(f"Transfered from={src_m} to={dest_m}")
-
-
-def convert_weight_and_push(name: str, config: ResNetConfig, save_directory: Path, push_to_hub: bool = True):
-    print(f"Converting {name}...")
-    with torch.no_grad():
-        from_model = timm.create_model(name, pretrained=True).eval()
-        our_model = ResNetForImageClassification(config).eval()
-        module_transfer = ModuleTransfer(src=from_model, dest=our_model)
-        x = torch.randn((1, 3, 224, 224))
-        module_transfer(x)
-
-    assert torch.allclose(from_model(x), our_model(x).logits), "The model logits don't match the original one."
-
-    checkpoint_name = f"resnet{'-'.join(name.split('resnet'))}"
-    print(checkpoint_name)
-
-    if push_to_hub:
-        our_model.push_to_hub(
-            repo_path_or_name=save_directory / checkpoint_name,
-            commit_message="Add model",
-            use_temp_dir=True,
-        )
-
-        # we can use the convnext one
-        image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k")
-        image_processor.push_to_hub(
-            repo_path_or_name=save_directory / checkpoint_name,
-            commit_message="Add image processor",
-            use_temp_dir=True,
-        )
-
-        print(f"Pushed {checkpoint_name}")
-
-
-def convert_weights_and_push(save_directory: Path, model_name: Optional[str] = None, push_to_hub: bool = True):
-    filename = "imagenet-1k-id2label.json"
-    num_labels = 1000
-    expected_shape = (1, num_labels)
-
-    repo_id = "huggingface/label-files"
-    num_labels = num_labels
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-
-    id2label = id2label
-    label2id = {v: k for k, v in id2label.items()}
-
-    ImageNetPreTrainedConfig = partial(ResNetConfig, num_labels=num_labels, id2label=id2label, label2id=label2id)
-
-    names_to_config = {
-        "resnet18": ImageNetPreTrainedConfig(
-            depths=[2, 2, 2, 2], hidden_sizes=[64, 128, 256, 512], layer_type="basic"
-        ),
-        "resnet26": ImageNetPreTrainedConfig(
-            depths=[2, 2, 2, 2], hidden_sizes=[256, 512, 1024, 2048], layer_type="bottleneck"
-        ),
-        "resnet34": ImageNetPreTrainedConfig(
-            depths=[3, 4, 6, 3], hidden_sizes=[64, 128, 256, 512], layer_type="basic"
-        ),
-        "resnet50": ImageNetPreTrainedConfig(
-            depths=[3, 4, 6, 3], hidden_sizes=[256, 512, 1024, 2048], layer_type="bottleneck"
-        ),
-        "resnet101": ImageNetPreTrainedConfig(
-            depths=[3, 4, 23, 3], hidden_sizes=[256, 512, 1024, 2048], layer_type="bottleneck"
-        ),
-        "resnet152": ImageNetPreTrainedConfig(
-            depths=[3, 8, 36, 3], hidden_sizes=[256, 512, 1024, 2048], layer_type="bottleneck"
-        ),
-    }
-
-    if model_name:
-        convert_weight_and_push(model_name, names_to_config[model_name], save_directory, push_to_hub)
-    else:
-        for model_name, config in names_to_config.items():
-            convert_weight_and_push(model_name, config, save_directory, push_to_hub)
-    return config, expected_shape
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default=None,
-        type=str,
-        help=(
-            "The name of the model you wish to convert, it must be one of the supported resnet* architecture,"
-            " currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=Path,
-        required=True,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        default=True,
-        type=bool,
-        required=False,
-        help="If True, push model and image processor to the hub.",
-    )
-
-    args = parser.parse_args()
-    pytorch_dump_folder_path: Path = args.pytorch_dump_folder_path
-    pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
-    convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
diff --git a/src/transformers/models/roberta/convert_roberta_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/roberta/convert_roberta_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index c0e6bf94d2eb..000000000000
--- a/src/transformers/models/roberta/convert_roberta_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,177 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RoBERTa checkpoint."""
-
-import argparse
-import pathlib
-
-import fairseq
-import torch
-from fairseq.models.roberta import RobertaModel as FairseqRobertaModel
-from fairseq.modules import TransformerSentenceEncoderLayer
-from packaging import version
-
-from transformers import RobertaConfig, RobertaForMaskedLM, RobertaForSequenceClassification
-from transformers.models.bert.modeling_bert import (
-    BertIntermediate,
-    BertLayer,
-    BertOutput,
-    BertSelfAttention,
-    BertSelfOutput,
-)
-from transformers.utils import logging
-
-
-if version.parse(fairseq.__version__) < version.parse("0.9.0"):
-    raise Exception("requires fairseq >= 0.9.0")
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-SAMPLE_TEXT = "Hello world! cécé herlolip"
-
-
-def convert_roberta_checkpoint_to_pytorch(
-    roberta_checkpoint_path: str, pytorch_dump_folder_path: str, classification_head: bool
-):
-    """
-    Copy/paste/tweak roberta's weights to our BERT structure.
-    """
-    roberta = FairseqRobertaModel.from_pretrained(roberta_checkpoint_path)
-    roberta.eval()  # disable dropout
-    roberta_sent_encoder = roberta.model.encoder.sentence_encoder
-    config = RobertaConfig(
-        vocab_size=roberta_sent_encoder.embed_tokens.num_embeddings,
-        hidden_size=roberta.args.encoder_embed_dim,
-        num_hidden_layers=roberta.args.encoder_layers,
-        num_attention_heads=roberta.args.encoder_attention_heads,
-        intermediate_size=roberta.args.encoder_ffn_embed_dim,
-        max_position_embeddings=514,
-        type_vocab_size=1,
-        layer_norm_eps=1e-5,  # PyTorch default used in fairseq
-    )
-    if classification_head:
-        config.num_labels = roberta.model.classification_heads["mnli"].out_proj.weight.shape[0]
-    print("Our BERT config:", config)
-
-    model = RobertaForSequenceClassification(config) if classification_head else RobertaForMaskedLM(config)
-    model.eval()
-
-    # Now let's copy all the weights.
-    # Embeddings
-    model.roberta.embeddings.word_embeddings.weight = roberta_sent_encoder.embed_tokens.weight
-    model.roberta.embeddings.position_embeddings.weight = roberta_sent_encoder.embed_positions.weight
-    model.roberta.embeddings.token_type_embeddings.weight.data = torch.zeros_like(
-        model.roberta.embeddings.token_type_embeddings.weight
-    )  # just zero them out b/c RoBERTa doesn't use them.
-    model.roberta.embeddings.LayerNorm.weight = roberta_sent_encoder.emb_layer_norm.weight
-    model.roberta.embeddings.LayerNorm.bias = roberta_sent_encoder.emb_layer_norm.bias
-
-    for i in range(config.num_hidden_layers):
-        # Encoder: start of layer
-        layer: BertLayer = model.roberta.encoder.layer[i]
-        roberta_layer: TransformerSentenceEncoderLayer = roberta_sent_encoder.layers[i]
-
-        # self attention
-        self_attn: BertSelfAttention = layer.attention.self
-        assert (
-            roberta_layer.self_attn.k_proj.weight.data.shape
-            == roberta_layer.self_attn.q_proj.weight.data.shape
-            == roberta_layer.self_attn.v_proj.weight.data.shape
-            == torch.Size((config.hidden_size, config.hidden_size))
-        )
-
-        self_attn.query.weight.data = roberta_layer.self_attn.q_proj.weight
-        self_attn.query.bias.data = roberta_layer.self_attn.q_proj.bias
-        self_attn.key.weight.data = roberta_layer.self_attn.k_proj.weight
-        self_attn.key.bias.data = roberta_layer.self_attn.k_proj.bias
-        self_attn.value.weight.data = roberta_layer.self_attn.v_proj.weight
-        self_attn.value.bias.data = roberta_layer.self_attn.v_proj.bias
-
-        # self-attention output
-        self_output: BertSelfOutput = layer.attention.output
-        assert self_output.dense.weight.shape == roberta_layer.self_attn.out_proj.weight.shape
-        self_output.dense.weight = roberta_layer.self_attn.out_proj.weight
-        self_output.dense.bias = roberta_layer.self_attn.out_proj.bias
-        self_output.LayerNorm.weight = roberta_layer.self_attn_layer_norm.weight
-        self_output.LayerNorm.bias = roberta_layer.self_attn_layer_norm.bias
-
-        # intermediate
-        intermediate: BertIntermediate = layer.intermediate
-        assert intermediate.dense.weight.shape == roberta_layer.fc1.weight.shape
-        intermediate.dense.weight = roberta_layer.fc1.weight
-        intermediate.dense.bias = roberta_layer.fc1.bias
-
-        # output
-        bert_output: BertOutput = layer.output
-        assert bert_output.dense.weight.shape == roberta_layer.fc2.weight.shape
-        bert_output.dense.weight = roberta_layer.fc2.weight
-        bert_output.dense.bias = roberta_layer.fc2.bias
-        bert_output.LayerNorm.weight = roberta_layer.final_layer_norm.weight
-        bert_output.LayerNorm.bias = roberta_layer.final_layer_norm.bias
-        # end of layer
-
-    if classification_head:
-        model.classifier.dense.weight = roberta.model.classification_heads["mnli"].dense.weight
-        model.classifier.dense.bias = roberta.model.classification_heads["mnli"].dense.bias
-        model.classifier.out_proj.weight = roberta.model.classification_heads["mnli"].out_proj.weight
-        model.classifier.out_proj.bias = roberta.model.classification_heads["mnli"].out_proj.bias
-    else:
-        # LM Head
-        model.lm_head.dense.weight = roberta.model.encoder.lm_head.dense.weight
-        model.lm_head.dense.bias = roberta.model.encoder.lm_head.dense.bias
-        model.lm_head.layer_norm.weight = roberta.model.encoder.lm_head.layer_norm.weight
-        model.lm_head.layer_norm.bias = roberta.model.encoder.lm_head.layer_norm.bias
-        model.lm_head.decoder.weight = roberta.model.encoder.lm_head.weight
-        model.lm_head.decoder.bias = roberta.model.encoder.lm_head.bias
-
-    # Let's check that we get the same results.
-    input_ids: torch.Tensor = roberta.encode(SAMPLE_TEXT).unsqueeze(0)  # batch of size 1
-
-    our_output = model(input_ids)[0]
-    if classification_head:
-        their_output = roberta.model.classification_heads["mnli"](roberta.extract_features(input_ids))
-    else:
-        their_output = roberta.model(input_ids)[0]
-    print(our_output.shape, their_output.shape)
-    max_absolute_diff = torch.max(torch.abs(our_output - their_output)).item()
-    print(f"max_absolute_diff = {max_absolute_diff}")  # ~ 1e-7
-    success = torch.allclose(our_output, their_output, atol=1e-3)
-    print("Do both models output the same tensors?", "🔥" if success else "💩")
-    if not success:
-        raise Exception("Something went wRoNg")
-
-    pathlib.Path(pytorch_dump_folder_path).mkdir(parents=True, exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--roberta_checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--classification_head", action="store_true", help="Whether to convert a final classification head."
-    )
-    args = parser.parse_args()
-    convert_roberta_checkpoint_to_pytorch(
-        args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
-    )
diff --git a/src/transformers/models/roberta_prelayernorm/convert_roberta_prelayernorm_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/roberta_prelayernorm/convert_roberta_prelayernorm_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index b8491db08b18..000000000000
--- a/src/transformers/models/roberta_prelayernorm/convert_roberta_prelayernorm_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RoBERTa-PreLayerNorm checkpoint."""
-
-import argparse
-
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import AutoTokenizer, RobertaPreLayerNormConfig, RobertaPreLayerNormForMaskedLM
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def convert_roberta_prelayernorm_checkpoint_to_pytorch(checkpoint_repo: str, pytorch_dump_folder_path: str):
-    """
-    Copy/paste/tweak roberta_prelayernorm's weights to our BERT structure.
-    """
-    # convert configuration
-    config = RobertaPreLayerNormConfig.from_pretrained(
-        checkpoint_repo, architectures=["RobertaPreLayerNormForMaskedLM"]
-    )
-
-    # convert state_dict
-    original_state_dict = torch.load(hf_hub_download(repo_id=checkpoint_repo, filename="pytorch_model.bin"))
-    state_dict = {}
-    for tensor_key, tensor_value in original_state_dict.items():
-        # The transformer implementation gives the model a unique name, rather than overwiriting 'roberta'
-        if tensor_key.startswith("roberta."):
-            tensor_key = "roberta_prelayernorm." + tensor_key[len("roberta.") :]
-
-        # The original implementation contains weights which are not used, remove them from the state_dict
-        if tensor_key.endswith(".self.LayerNorm.weight") or tensor_key.endswith(".self.LayerNorm.bias"):
-            continue
-
-        state_dict[tensor_key] = tensor_value
-
-    model = RobertaPreLayerNormForMaskedLM.from_pretrained(
-        pretrained_model_name_or_path=None, config=config, state_dict=state_dict
-    )
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    # convert tokenizer
-    tokenizer = AutoTokenizer.from_pretrained(checkpoint_repo)
-    tokenizer.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint-repo",
-        default=None,
-        type=str,
-        required=True,
-        help="Path the official PyTorch dump, e.g. 'andreasmadsen/efficient_mlm_m0.40'.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_roberta_prelayernorm_checkpoint_to_pytorch(args.checkpoint_repo, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/roformer/convert_roformer_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/roformer/convert_roformer_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index d227948e0ee3..000000000000
--- a/src/transformers/models/roformer/convert_roformer_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RoFormer checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import RoFormerConfig, RoFormerForMaskedLM, load_tf_weights_in_roformer
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, bert_config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = RoFormerConfig.from_json_file(bert_config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = RoFormerForMaskedLM(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_roformer(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    torch.save(model.state_dict(), pytorch_dump_path, _use_new_zipfile_serialization=False)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--bert_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained BERT model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/rt_detr/convert_rt_detr_original_pytorch_checkpoint_to_hf.py b/src/transformers/models/rt_detr/convert_rt_detr_original_pytorch_checkpoint_to_hf.py
deleted file mode 100644
index 9f2271930e13..000000000000
--- a/src/transformers/models/rt_detr/convert_rt_detr_original_pytorch_checkpoint_to_hf.py
+++ /dev/null
@@ -1,782 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RT Detr checkpoints with Timm backbone"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision import transforms
-
-from transformers import RTDetrConfig, RTDetrForObjectDetection, RTDetrImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_rt_detr_config(model_name: str) -> RTDetrConfig:
-    config = RTDetrConfig()
-
-    config.num_labels = 80
-    repo_id = "huggingface/label-files"
-    filename = "coco-detection-mmdet-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    if model_name == "rtdetr_r18vd":
-        config.backbone_config.hidden_sizes = [64, 128, 256, 512]
-        config.backbone_config.depths = [2, 2, 2, 2]
-        config.backbone_config.layer_type = "basic"
-        config.encoder_in_channels = [128, 256, 512]
-        config.hidden_expansion = 0.5
-        config.decoder_layers = 3
-    elif model_name == "rtdetr_r34vd":
-        config.backbone_config.hidden_sizes = [64, 128, 256, 512]
-        config.backbone_config.depths = [3, 4, 6, 3]
-        config.backbone_config.layer_type = "basic"
-        config.encoder_in_channels = [128, 256, 512]
-        config.hidden_expansion = 0.5
-        config.decoder_layers = 4
-    elif model_name == "rtdetr_r50vd_m":
-        pass
-    elif model_name == "rtdetr_r50vd":
-        pass
-    elif model_name == "rtdetr_r101vd":
-        config.backbone_config.depths = [3, 4, 23, 3]
-        config.encoder_ffn_dim = 2048
-        config.encoder_hidden_dim = 384
-        config.decoder_in_channels = [384, 384, 384]
-    elif model_name == "rtdetr_r18vd_coco_o365":
-        config.backbone_config.hidden_sizes = [64, 128, 256, 512]
-        config.backbone_config.depths = [2, 2, 2, 2]
-        config.backbone_config.layer_type = "basic"
-        config.encoder_in_channels = [128, 256, 512]
-        config.hidden_expansion = 0.5
-        config.decoder_layers = 3
-    elif model_name == "rtdetr_r50vd_coco_o365":
-        pass
-    elif model_name == "rtdetr_r101vd_coco_o365":
-        config.backbone_config.depths = [3, 4, 23, 3]
-        config.encoder_ffn_dim = 2048
-        config.encoder_hidden_dim = 384
-        config.decoder_in_channels = [384, 384, 384]
-
-    return config
-
-
-def create_rename_keys(config):
-    # here we list all keys to be renamed (original name on the left, our name on the right)
-    rename_keys = []
-
-    # stem
-    # fmt: off
-    last_key = ["weight", "bias", "running_mean", "running_var"]
-
-    for level in range(3):
-        rename_keys.append((f"backbone.conv1.conv1_{level+1}.conv.weight", f"model.backbone.model.embedder.embedder.{level}.convolution.weight"))
-        for last in last_key:
-            rename_keys.append((f"backbone.conv1.conv1_{level+1}.norm.{last}", f"model.backbone.model.embedder.embedder.{level}.normalization.{last}"))
-
-    for stage_idx in range(len(config.backbone_config.depths)):
-        for layer_idx in range(config.backbone_config.depths[stage_idx]):
-            # shortcut
-            if layer_idx == 0:
-                if stage_idx == 0:
-                    rename_keys.append(
-                        (
-                            f"backbone.res_layers.{stage_idx}.blocks.0.short.conv.weight",
-                            f"model.backbone.model.encoder.stages.{stage_idx}.layers.0.shortcut.convolution.weight",
-                        )
-                    )
-                    for last in last_key:
-                        rename_keys.append(
-                            (
-                                f"backbone.res_layers.{stage_idx}.blocks.0.short.norm.{last}",
-                                f"model.backbone.model.encoder.stages.{stage_idx}.layers.0.shortcut.normalization.{last}",
-                            )
-                        )
-                else:
-                    rename_keys.append(
-                        (
-                            f"backbone.res_layers.{stage_idx}.blocks.0.short.conv.conv.weight",
-                            f"model.backbone.model.encoder.stages.{stage_idx}.layers.0.shortcut.1.convolution.weight",
-                        )
-                    )
-                    for last in last_key:
-                        rename_keys.append(
-                            (
-                                f"backbone.res_layers.{stage_idx}.blocks.0.short.conv.norm.{last}",
-                                f"model.backbone.model.encoder.stages.{stage_idx}.layers.0.shortcut.1.normalization.{last}",
-                            )
-                        )
-
-            rename_keys.append(
-                (
-                    f"backbone.res_layers.{stage_idx}.blocks.{layer_idx}.branch2a.conv.weight",
-                    f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.0.convolution.weight",
-                )
-            )
-            for last in last_key:
-                rename_keys.append((
-                    f"backbone.res_layers.{stage_idx}.blocks.{layer_idx}.branch2a.norm.{last}",
-                    f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.0.normalization.{last}",
-                    ))
-
-            rename_keys.append(
-                (
-                    f"backbone.res_layers.{stage_idx}.blocks.{layer_idx}.branch2b.conv.weight",
-                    f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.1.convolution.weight",
-                )
-            )
-            for last in last_key:
-                rename_keys.append((
-                    f"backbone.res_layers.{stage_idx}.blocks.{layer_idx}.branch2b.norm.{last}",
-                    f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.1.normalization.{last}",
-                    ))
-
-            # https://github.com/lyuwenyu/RT-DETR/blob/94f5e16708329d2f2716426868ec89aa774af016/rtdetr_pytorch/src/nn/backbone/presnet.py#L171
-            if config.backbone_config.layer_type != "basic":
-                rename_keys.append(
-                    (
-                        f"backbone.res_layers.{stage_idx}.blocks.{layer_idx}.branch2c.conv.weight",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.2.convolution.weight",
-                    )
-                )
-                for last in last_key:
-                    rename_keys.append((
-                        f"backbone.res_layers.{stage_idx}.blocks.{layer_idx}.branch2c.norm.{last}",
-                        f"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.2.normalization.{last}",
-                        ))
-    # fmt: on
-
-    for i in range(config.encoder_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.self_attn.out_proj.weight",
-                f"model.encoder.encoder.{i}.layers.0.self_attn.out_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.self_attn.out_proj.bias",
-                f"model.encoder.encoder.{i}.layers.0.self_attn.out_proj.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.linear1.weight",
-                f"model.encoder.encoder.{i}.layers.0.fc1.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.linear1.bias",
-                f"model.encoder.encoder.{i}.layers.0.fc1.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.linear2.weight",
-                f"model.encoder.encoder.{i}.layers.0.fc2.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.linear2.bias",
-                f"model.encoder.encoder.{i}.layers.0.fc2.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.norm1.weight",
-                f"model.encoder.encoder.{i}.layers.0.self_attn_layer_norm.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.norm1.bias",
-                f"model.encoder.encoder.{i}.layers.0.self_attn_layer_norm.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.norm2.weight",
-                f"model.encoder.encoder.{i}.layers.0.final_layer_norm.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"encoder.encoder.{i}.layers.0.norm2.bias",
-                f"model.encoder.encoder.{i}.layers.0.final_layer_norm.bias",
-            )
-        )
-
-    for j in range(0, 3):
-        rename_keys.append((f"encoder.input_proj.{j}.0.weight", f"model.encoder_input_proj.{j}.0.weight"))
-        for last in last_key:
-            rename_keys.append((f"encoder.input_proj.{j}.1.{last}", f"model.encoder_input_proj.{j}.1.{last}"))
-
-    block_levels = 3 if config.backbone_config.layer_type != "basic" else 4
-
-    for i in range(len(config.encoder_in_channels) - 1):
-        # encoder layers: hybridencoder parts
-        for j in range(1, block_levels):
-            rename_keys.append(
-                (f"encoder.fpn_blocks.{i}.conv{j}.conv.weight", f"model.encoder.fpn_blocks.{i}.conv{j}.conv.weight")
-            )
-            for last in last_key:
-                rename_keys.append(
-                    (
-                        f"encoder.fpn_blocks.{i}.conv{j}.norm.{last}",
-                        f"model.encoder.fpn_blocks.{i}.conv{j}.norm.{last}",
-                    )
-                )
-
-        rename_keys.append((f"encoder.lateral_convs.{i}.conv.weight", f"model.encoder.lateral_convs.{i}.conv.weight"))
-        for last in last_key:
-            rename_keys.append(
-                (f"encoder.lateral_convs.{i}.norm.{last}", f"model.encoder.lateral_convs.{i}.norm.{last}")
-            )
-
-        for j in range(3):
-            for k in range(1, 3):
-                rename_keys.append(
-                    (
-                        f"encoder.fpn_blocks.{i}.bottlenecks.{j}.conv{k}.conv.weight",
-                        f"model.encoder.fpn_blocks.{i}.bottlenecks.{j}.conv{k}.conv.weight",
-                    )
-                )
-                for last in last_key:
-                    rename_keys.append(
-                        (
-                            f"encoder.fpn_blocks.{i}.bottlenecks.{j}.conv{k}.norm.{last}",
-                            f"model.encoder.fpn_blocks.{i}.bottlenecks.{j}.conv{k}.norm.{last}",
-                        )
-                    )
-
-        for j in range(1, block_levels):
-            rename_keys.append(
-                (f"encoder.pan_blocks.{i}.conv{j}.conv.weight", f"model.encoder.pan_blocks.{i}.conv{j}.conv.weight")
-            )
-            for last in last_key:
-                rename_keys.append(
-                    (
-                        f"encoder.pan_blocks.{i}.conv{j}.norm.{last}",
-                        f"model.encoder.pan_blocks.{i}.conv{j}.norm.{last}",
-                    )
-                )
-
-        for j in range(3):
-            for k in range(1, 3):
-                rename_keys.append(
-                    (
-                        f"encoder.pan_blocks.{i}.bottlenecks.{j}.conv{k}.conv.weight",
-                        f"model.encoder.pan_blocks.{i}.bottlenecks.{j}.conv{k}.conv.weight",
-                    )
-                )
-                for last in last_key:
-                    rename_keys.append(
-                        (
-                            f"encoder.pan_blocks.{i}.bottlenecks.{j}.conv{k}.norm.{last}",
-                            f"model.encoder.pan_blocks.{i}.bottlenecks.{j}.conv{k}.norm.{last}",
-                        )
-                    )
-
-        rename_keys.append(
-            (f"encoder.downsample_convs.{i}.conv.weight", f"model.encoder.downsample_convs.{i}.conv.weight")
-        )
-        for last in last_key:
-            rename_keys.append(
-                (f"encoder.downsample_convs.{i}.norm.{last}", f"model.encoder.downsample_convs.{i}.norm.{last}")
-            )
-
-    for i in range(config.decoder_layers):
-        # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.self_attn.out_proj.weight",
-                f"model.decoder.layers.{i}.self_attn.out_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.self_attn.out_proj.bias",
-                f"model.decoder.layers.{i}.self_attn.out_proj.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.cross_attn.sampling_offsets.weight",
-                f"model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.cross_attn.sampling_offsets.bias",
-                f"model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.cross_attn.attention_weights.weight",
-                f"model.decoder.layers.{i}.encoder_attn.attention_weights.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.cross_attn.attention_weights.bias",
-                f"model.decoder.layers.{i}.encoder_attn.attention_weights.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.cross_attn.value_proj.weight",
-                f"model.decoder.layers.{i}.encoder_attn.value_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.cross_attn.value_proj.bias",
-                f"model.decoder.layers.{i}.encoder_attn.value_proj.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.cross_attn.output_proj.weight",
-                f"model.decoder.layers.{i}.encoder_attn.output_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.decoder.layers.{i}.cross_attn.output_proj.bias",
-                f"model.decoder.layers.{i}.encoder_attn.output_proj.bias",
-            )
-        )
-        rename_keys.append(
-            (f"decoder.decoder.layers.{i}.norm1.weight", f"model.decoder.layers.{i}.self_attn_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"decoder.decoder.layers.{i}.norm1.bias", f"model.decoder.layers.{i}.self_attn_layer_norm.bias")
-        )
-        rename_keys.append(
-            (f"decoder.decoder.layers.{i}.norm2.weight", f"model.decoder.layers.{i}.encoder_attn_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"decoder.decoder.layers.{i}.norm2.bias", f"model.decoder.layers.{i}.encoder_attn_layer_norm.bias")
-        )
-        rename_keys.append((f"decoder.decoder.layers.{i}.linear1.weight", f"model.decoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"decoder.decoder.layers.{i}.linear1.bias", f"model.decoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"decoder.decoder.layers.{i}.linear2.weight", f"model.decoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"decoder.decoder.layers.{i}.linear2.bias", f"model.decoder.layers.{i}.fc2.bias"))
-        rename_keys.append(
-            (f"decoder.decoder.layers.{i}.norm3.weight", f"model.decoder.layers.{i}.final_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"decoder.decoder.layers.{i}.norm3.bias", f"model.decoder.layers.{i}.final_layer_norm.bias")
-        )
-
-    for i in range(config.decoder_layers):
-        # decoder + class and bounding box heads
-        rename_keys.append(
-            (
-                f"decoder.dec_score_head.{i}.weight",
-                f"model.decoder.class_embed.{i}.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.dec_score_head.{i}.bias",
-                f"model.decoder.class_embed.{i}.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.dec_bbox_head.{i}.layers.0.weight",
-                f"model.decoder.bbox_embed.{i}.layers.0.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.dec_bbox_head.{i}.layers.0.bias",
-                f"model.decoder.bbox_embed.{i}.layers.0.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.dec_bbox_head.{i}.layers.1.weight",
-                f"model.decoder.bbox_embed.{i}.layers.1.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.dec_bbox_head.{i}.layers.1.bias",
-                f"model.decoder.bbox_embed.{i}.layers.1.bias",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.dec_bbox_head.{i}.layers.2.weight",
-                f"model.decoder.bbox_embed.{i}.layers.2.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"decoder.dec_bbox_head.{i}.layers.2.bias",
-                f"model.decoder.bbox_embed.{i}.layers.2.bias",
-            )
-        )
-
-    # decoder projection
-    for i in range(len(config.decoder_in_channels)):
-        rename_keys.append(
-            (
-                f"decoder.input_proj.{i}.conv.weight",
-                f"model.decoder_input_proj.{i}.0.weight",
-            )
-        )
-        for last in last_key:
-            rename_keys.append(
-                (
-                    f"decoder.input_proj.{i}.norm.{last}",
-                    f"model.decoder_input_proj.{i}.1.{last}",
-                )
-            )
-
-    # convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
-    rename_keys.extend(
-        [
-            ("decoder.denoising_class_embed.weight", "model.denoising_class_embed.weight"),
-            ("decoder.query_pos_head.layers.0.weight", "model.decoder.query_pos_head.layers.0.weight"),
-            ("decoder.query_pos_head.layers.0.bias", "model.decoder.query_pos_head.layers.0.bias"),
-            ("decoder.query_pos_head.layers.1.weight", "model.decoder.query_pos_head.layers.1.weight"),
-            ("decoder.query_pos_head.layers.1.bias", "model.decoder.query_pos_head.layers.1.bias"),
-            ("decoder.enc_output.0.weight", "model.enc_output.0.weight"),
-            ("decoder.enc_output.0.bias", "model.enc_output.0.bias"),
-            ("decoder.enc_output.1.weight", "model.enc_output.1.weight"),
-            ("decoder.enc_output.1.bias", "model.enc_output.1.bias"),
-            ("decoder.enc_score_head.weight", "model.enc_score_head.weight"),
-            ("decoder.enc_score_head.bias", "model.enc_score_head.bias"),
-            ("decoder.enc_bbox_head.layers.0.weight", "model.enc_bbox_head.layers.0.weight"),
-            ("decoder.enc_bbox_head.layers.0.bias", "model.enc_bbox_head.layers.0.bias"),
-            ("decoder.enc_bbox_head.layers.1.weight", "model.enc_bbox_head.layers.1.weight"),
-            ("decoder.enc_bbox_head.layers.1.bias", "model.enc_bbox_head.layers.1.bias"),
-            ("decoder.enc_bbox_head.layers.2.weight", "model.enc_bbox_head.layers.2.weight"),
-            ("decoder.enc_bbox_head.layers.2.bias", "model.enc_bbox_head.layers.2.bias"),
-        ]
-    )
-
-    return rename_keys
-
-
-def rename_key(state_dict, old, new):
-    try:
-        val = state_dict.pop(old)
-        state_dict[new] = val
-    except Exception:
-        pass
-
-
-def read_in_q_k_v(state_dict, config):
-    prefix = ""
-    encoder_hidden_dim = config.encoder_hidden_dim
-
-    # first: transformer encoder
-    for i in range(config.encoder_layers):
-        # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"{prefix}encoder.encoder.{i}.layers.0.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}encoder.encoder.{i}.layers.0.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.q_proj.weight"] = in_proj_weight[
-            :encoder_hidden_dim, :
-        ]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.q_proj.bias"] = in_proj_bias[:encoder_hidden_dim]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.k_proj.weight"] = in_proj_weight[
-            encoder_hidden_dim : 2 * encoder_hidden_dim, :
-        ]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.k_proj.bias"] = in_proj_bias[
-            encoder_hidden_dim : 2 * encoder_hidden_dim
-        ]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.v_proj.weight"] = in_proj_weight[
-            -encoder_hidden_dim:, :
-        ]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.v_proj.bias"] = in_proj_bias[-encoder_hidden_dim:]
-    # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
-    for i in range(config.decoder_layers):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"{prefix}decoder.decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}decoder.decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-
-    return im
-
-
-@torch.no_grad()
-def convert_rt_detr_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub, repo_id):
-    """
-    Copy/paste/tweak model's weights to our RTDETR structure.
-    """
-
-    # load default config
-    config = get_rt_detr_config(model_name)
-
-    # load original model from torch hub
-    model_name_to_checkpoint_url = {
-        "rtdetr_r18vd": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetr_r18vd_dec3_6x_coco_from_paddle.pth",
-        "rtdetr_r34vd": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetr_r34vd_dec4_6x_coco_from_paddle.pth",
-        "rtdetr_r50vd_m": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetr_r50vd_m_6x_coco_from_paddle.pth",
-        "rtdetr_r50vd": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetr_r50vd_6x_coco_from_paddle.pth",
-        "rtdetr_r101vd": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetr_r101vd_6x_coco_from_paddle.pth",
-        "rtdetr_r18vd_coco_o365": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetr_r18vd_5x_coco_objects365_from_paddle.pth",
-        "rtdetr_r50vd_coco_o365": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetr_r50vd_2x_coco_objects365_from_paddle.pth",
-        "rtdetr_r101vd_coco_o365": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetr_r101vd_2x_coco_objects365_from_paddle.pth",
-    }
-    logger.info(f"Converting model {model_name}...")
-    state_dict = torch.hub.load_state_dict_from_url(model_name_to_checkpoint_url[model_name], map_location="cpu")[
-        "ema"
-    ]["module"]
-
-    # rename keys
-    for src, dest in create_rename_keys(config):
-        rename_key(state_dict, src, dest)
-    # query, key and value matrices need special treatment
-    read_in_q_k_v(state_dict, config)
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    for key in state_dict.copy().keys():
-        if key.endswith("num_batches_tracked"):
-            del state_dict[key]
-        # for two_stage
-        if "bbox_embed" in key or ("class_embed" in key and "denoising_" not in key):
-            state_dict[key.split("model.decoder.")[-1]] = state_dict[key]
-
-    # finally, create HuggingFace model and load state dict
-    model = RTDetrForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # load image processor
-    image_processor = RTDetrImageProcessor()
-
-    # prepare image
-    img = prepare_img()
-
-    # preprocess image
-    transformations = transforms.Compose(
-        [
-            transforms.Resize([640, 640], interpolation=transforms.InterpolationMode.BILINEAR),
-            transforms.ToTensor(),
-        ]
-    )
-    original_pixel_values = transformations(img).unsqueeze(0)  # insert batch dimension
-
-    encoding = image_processor(images=img, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    assert torch.allclose(original_pixel_values, pixel_values)
-
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-    pixel_values = pixel_values.to(device)
-
-    # Pass image by the model
-    outputs = model(pixel_values)
-
-    if model_name == "rtdetr_r18vd":
-        expected_slice_logits = torch.tensor(
-            [
-                [-4.3364253, -6.465683, -3.6130402],
-                [-4.083815, -6.4039373, -6.97881],
-                [-4.192215, -7.3410473, -6.9027247],
-            ]
-        )
-        expected_slice_boxes = torch.tensor(
-            [
-                [0.16868353, 0.19833282, 0.21182671],
-                [0.25559652, 0.55121744, 0.47988364],
-                [0.7698693, 0.4124569, 0.46036878],
-            ]
-        )
-    elif model_name == "rtdetr_r34vd":
-        expected_slice_logits = torch.tensor(
-            [
-                [-4.3727384, -4.7921476, -5.7299604],
-                [-4.840536, -8.455345, -4.1745796],
-                [-4.1277084, -5.2154565, -5.7852697],
-            ]
-        )
-        expected_slice_boxes = torch.tensor(
-            [
-                [0.258278, 0.5497808, 0.4732004],
-                [0.16889669, 0.19890057, 0.21138911],
-                [0.76632994, 0.4147879, 0.46851268],
-            ]
-        )
-    elif model_name == "rtdetr_r50vd_m":
-        expected_slice_logits = torch.tensor(
-            [
-                [-4.319764, -6.1349025, -6.094794],
-                [-5.1056995, -7.744766, -4.803956],
-                [-4.7685347, -7.9278393, -4.5751696],
-            ]
-        )
-        expected_slice_boxes = torch.tensor(
-            [
-                [0.2582739, 0.55071366, 0.47660282],
-                [0.16811174, 0.19954777, 0.21292639],
-                [0.54986024, 0.2752091, 0.0561416],
-            ]
-        )
-    elif model_name == "rtdetr_r50vd":
-        expected_slice_logits = torch.tensor(
-            [
-                [-4.6476398, -5.001154, -4.9785104],
-                [-4.1593494, -4.7038546, -5.946485],
-                [-4.4374595, -4.658361, -6.2352347],
-            ]
-        )
-        expected_slice_boxes = torch.tensor(
-            [
-                [0.16880608, 0.19992264, 0.21225442],
-                [0.76837635, 0.4122631, 0.46368608],
-                [0.2595386, 0.5483334, 0.4777486],
-            ]
-        )
-    elif model_name == "rtdetr_r101vd":
-        expected_slice_logits = torch.tensor(
-            [
-                [-4.6162, -4.9189, -4.6656],
-                [-4.4701, -4.4997, -4.9659],
-                [-5.6641, -7.9000, -5.0725],
-            ]
-        )
-        expected_slice_boxes = torch.tensor(
-            [
-                [0.7707, 0.4124, 0.4585],
-                [0.2589, 0.5492, 0.4735],
-                [0.1688, 0.1993, 0.2108],
-            ]
-        )
-    elif model_name == "rtdetr_r18vd_coco_o365":
-        expected_slice_logits = torch.tensor(
-            [
-                [-4.8726, -5.9066, -5.2450],
-                [-4.8157, -6.8764, -5.1656],
-                [-4.7492, -5.7006, -5.1333],
-            ]
-        )
-        expected_slice_boxes = torch.tensor(
-            [
-                [0.2552, 0.5501, 0.4773],
-                [0.1685, 0.1986, 0.2104],
-                [0.7692, 0.4141, 0.4620],
-            ]
-        )
-    elif model_name == "rtdetr_r50vd_coco_o365":
-        expected_slice_logits = torch.tensor(
-            [
-                [-4.6491, -3.9252, -5.3163],
-                [-4.1386, -5.0348, -3.9016],
-                [-4.4778, -4.5423, -5.7356],
-            ]
-        )
-        expected_slice_boxes = torch.tensor(
-            [
-                [0.2583, 0.5492, 0.4747],
-                [0.5501, 0.2754, 0.0574],
-                [0.7693, 0.4137, 0.4613],
-            ]
-        )
-    elif model_name == "rtdetr_r101vd_coco_o365":
-        expected_slice_logits = torch.tensor(
-            [
-                [-4.5152, -5.6811, -5.7311],
-                [-4.5358, -7.2422, -5.0941],
-                [-4.6919, -5.5834, -6.0145],
-            ]
-        )
-        expected_slice_boxes = torch.tensor(
-            [
-                [0.7703, 0.4140, 0.4583],
-                [0.1686, 0.1991, 0.2107],
-                [0.2570, 0.5496, 0.4750],
-            ]
-        )
-    else:
-        raise ValueError(f"Unknown rt_detr_name: {model_name}")
-
-    assert torch.allclose(outputs.logits[0, :3, :3], expected_slice_logits.to(outputs.logits.device), atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes[0, :3, :3], expected_slice_boxes.to(outputs.pred_boxes.device), atol=1e-3)
-
-    if pytorch_dump_folder_path is not None:
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving image processor to {pytorch_dump_folder_path}")
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        # Upload model, image processor and config to the hub
-        logger.info("Uploading PyTorch model and image processor to the hub...")
-        config.push_to_hub(
-            repo_id=repo_id, commit_message="Add config from convert_rt_detr_original_pytorch_checkpoint_to_pytorch.py"
-        )
-        model.push_to_hub(
-            repo_id=repo_id, commit_message="Add model from convert_rt_detr_original_pytorch_checkpoint_to_pytorch.py"
-        )
-        image_processor.push_to_hub(
-            repo_id=repo_id,
-            commit_message="Add image processor from convert_rt_detr_original_pytorch_checkpoint_to_pytorch.py",
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model_name",
-        default="rtdetr_r50vd",
-        type=str,
-        help="model_name of the checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to the hub or not.")
-    parser.add_argument(
-        "--repo_id",
-        type=str,
-        help="repo_id where the model will be pushed to.",
-    )
-    args = parser.parse_args()
-    convert_rt_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.repo_id)
diff --git a/src/transformers/models/rt_detr_v2/convert_rt_detr_v2_weights_to_hf.py b/src/transformers/models/rt_detr_v2/convert_rt_detr_v2_weights_to_hf.py
deleted file mode 100644
index 51372b74e426..000000000000
--- a/src/transformers/models/rt_detr_v2/convert_rt_detr_v2_weights_to_hf.py
+++ /dev/null
@@ -1,363 +0,0 @@
-# coding=utf-8
-# Copyright 2025 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RT Detr V2 checkpoints with Timm backbone"""
-
-import argparse
-import json
-import re
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision import transforms
-
-from transformers import RTDetrImageProcessor, RTDetrV2Config, RTDetrV2ForObjectDetection
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_rt_detr_v2_config(model_name: str) -> RTDetrV2Config:
-    config = RTDetrV2Config()
-
-    config.num_labels = 80
-    repo_id = "huggingface/label-files"
-    filename = "coco-detection-mmdet-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    if model_name == "rtdetr_v2_r18vd":
-        config.backbone_config.hidden_sizes = [64, 128, 256, 512]
-        config.backbone_config.depths = [2, 2, 2, 2]
-        config.backbone_config.layer_type = "basic"
-        config.encoder_in_channels = [128, 256, 512]
-        config.hidden_expansion = 0.5
-        config.decoder_layers = 3
-    elif model_name == "rtdetr_v2_r34vd":
-        config.backbone_config.hidden_sizes = [64, 128, 256, 512]
-        config.backbone_config.depths = [3, 4, 6, 3]
-        config.backbone_config.layer_type = "basic"
-        config.encoder_in_channels = [128, 256, 512]
-        config.hidden_expansion = 0.5
-        config.decoder_layers = 4
-    # TODO: check this not working
-    elif model_name == "rtdetr_v2_r50vd_m":
-        config.hidden_expansion = 0.5
-    elif model_name == "rtdetr_v2_r50vd":
-        pass
-    elif model_name == "rtdetr_v2_r101vd":
-        config.backbone_config.depths = [3, 4, 23, 3]
-        config.encoder_ffn_dim = 2048
-        config.encoder_hidden_dim = 384
-        config.decoder_in_channels = [384, 384, 384]
-
-    return config
-
-
-# Define a mapping from original keys to converted keys using regex
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    r"backbone.conv1.conv1_1.conv.weight": r"model.backbone.model.embedder.embedder.0.convolution.weight",
-    r"backbone.conv1.conv1_1.norm.(weight|bias|running_mean|running_var)": r"model.backbone.model.embedder.embedder.0.normalization.\1",
-    r"backbone.conv1.conv1_2.conv.weight": r"model.backbone.model.embedder.embedder.1.convolution.weight",
-    r"backbone.conv1.conv1_2.norm.(weight|bias|running_mean|running_var)": r"model.backbone.model.embedder.embedder.1.normalization.\1",
-    r"backbone.conv1.conv1_3.conv.weight": r"model.backbone.model.embedder.embedder.2.convolution.weight",
-    r"backbone.conv1.conv1_3.norm.(weight|bias|running_mean|running_var)": r"model.backbone.model.embedder.embedder.2.normalization.\1",
-    r"backbone.res_layers.(\d+).blocks.(\d+).branch2a.conv.weight": r"model.backbone.model.encoder.stages.\1.layers.\2.layer.0.convolution.weight",
-    r"backbone.res_layers.(\d+).blocks.(\d+).branch2a.norm.(weight|bias|running_mean|running_var)": r"model.backbone.model.encoder.stages.\1.layers.\2.layer.0.normalization.\3",
-    r"backbone.res_layers.(\d+).blocks.(\d+).branch2b.conv.weight": r"model.backbone.model.encoder.stages.\1.layers.\2.layer.1.convolution.weight",
-    r"backbone.res_layers.(\d+).blocks.(\d+).branch2b.norm.(weight|bias|running_mean|running_var)": r"model.backbone.model.encoder.stages.\1.layers.\2.layer.1.normalization.\3",
-    r"backbone.res_layers.(\d+).blocks.(\d+).branch2c.conv.weight": r"model.backbone.model.encoder.stages.\1.layers.\2.layer.2.convolution.weight",
-    r"backbone.res_layers.(\d+).blocks.(\d+).branch2c.norm.(weight|bias|running_mean|running_var)": r"model.backbone.model.encoder.stages.\1.layers.\2.layer.2.normalization.\3",
-    r"encoder.encoder.(\d+).layers.0.self_attn.out_proj.weight": r"model.encoder.encoder.\1.layers.0.self_attn.out_proj.weight",
-    r"encoder.encoder.(\d+).layers.0.self_attn.out_proj.bias": r"model.encoder.encoder.\1.layers.0.self_attn.out_proj.bias",
-    r"encoder.encoder.(\d+).layers.0.linear1.weight": r"model.encoder.encoder.\1.layers.0.fc1.weight",
-    r"encoder.encoder.(\d+).layers.0.linear1.bias": r"model.encoder.encoder.\1.layers.0.fc1.bias",
-    r"encoder.encoder.(\d+).layers.0.linear2.weight": r"model.encoder.encoder.\1.layers.0.fc2.weight",
-    r"encoder.encoder.(\d+).layers.0.linear2.bias": r"model.encoder.encoder.\1.layers.0.fc2.bias",
-    r"encoder.encoder.(\d+).layers.0.norm1.weight": r"model.encoder.encoder.\1.layers.0.self_attn_layer_norm.weight",
-    r"encoder.encoder.(\d+).layers.0.norm1.bias": r"model.encoder.encoder.\1.layers.0.self_attn_layer_norm.bias",
-    r"encoder.encoder.(\d+).layers.0.norm2.weight": r"model.encoder.encoder.\1.layers.0.final_layer_norm.weight",
-    r"encoder.encoder.(\d+).layers.0.norm2.bias": r"model.encoder.encoder.\1.layers.0.final_layer_norm.bias",
-    r"encoder.input_proj.(\d+).conv.weight": r"model.encoder_input_proj.\1.0.weight",
-    r"encoder.input_proj.(\d+).norm.(.*)": r"model.encoder_input_proj.\1.1.\2",
-    r"encoder.fpn_blocks.(\d+).conv(\d+).conv.weight": r"model.encoder.fpn_blocks.\1.conv\2.conv.weight",
-    # r"encoder.fpn_blocks.(\d+).conv(\d+).norm.(.*)": r"model.encoder.fpn_blocks.\1.conv\2.norm.\3",
-    r"encoder.fpn_blocks.(\d+).conv(\d+).norm.(weight|bias|running_mean|running_var)": r"model.encoder.fpn_blocks.\1.conv\2.norm.\3",
-    r"encoder.lateral_convs.(\d+).conv.weight": r"model.encoder.lateral_convs.\1.conv.weight",
-    r"encoder.lateral_convs.(\d+).norm.(.*)": r"model.encoder.lateral_convs.\1.norm.\2",
-    r"encoder.fpn_blocks.(\d+).bottlenecks.(\d+).conv(\d+).conv.weight": r"model.encoder.fpn_blocks.\1.bottlenecks.\2.conv\3.conv.weight",
-    r"encoder.fpn_blocks.(\d+).bottlenecks.(\d+).conv(\d+).norm.(\w+)": r"model.encoder.fpn_blocks.\1.bottlenecks.\2.conv\3.norm.\4",
-    r"encoder.pan_blocks.(\d+).conv(\d+).conv.weight": r"model.encoder.pan_blocks.\1.conv\2.conv.weight",
-    r"encoder.pan_blocks.(\d+).conv(\d+).norm.(weight|bias|running_mean|running_var)": r"model.encoder.pan_blocks.\1.conv\2.norm.\3",
-    r"encoder.pan_blocks.(\d+).bottlenecks.(\d+).conv(\d+).conv.weight": r"model.encoder.pan_blocks.\1.bottlenecks.\2.conv\3.conv.weight",
-    r"encoder.pan_blocks.(\d+).bottlenecks.(\d+).conv(\d+).norm.(weight|bias|running_mean|running_var)": r"model.encoder.pan_blocks.\1.bottlenecks.\2.conv\3.norm.\4",
-    r"encoder.downsample_convs.(\d+).conv.weight": r"model.encoder.downsample_convs.\1.conv.weight",
-    r"encoder.downsample_convs.(\d+).norm.(weight|bias|running_mean|running_var)": r"model.encoder.downsample_convs.\1.norm.\2",
-    r"decoder.decoder.layers.(\d+).self_attn.out_proj.weight": r"model.decoder.layers.\1.self_attn.out_proj.weight",
-    r"decoder.decoder.layers.(\d+).self_attn.out_proj.bias": r"model.decoder.layers.\1.self_attn.out_proj.bias",
-    r"decoder.decoder.layers.(\d+).cross_attn.sampling_offsets.weight": r"model.decoder.layers.\1.encoder_attn.sampling_offsets.weight",
-    r"decoder.decoder.layers.(\d+).cross_attn.sampling_offsets.bias": r"model.decoder.layers.\1.encoder_attn.sampling_offsets.bias",
-    r"decoder.decoder.layers.(\d+).cross_attn.attention_weights.weight": r"model.decoder.layers.\1.encoder_attn.attention_weights.weight",
-    r"decoder.decoder.layers.(\d+).cross_attn.attention_weights.bias": r"model.decoder.layers.\1.encoder_attn.attention_weights.bias",
-    r"decoder.decoder.layers.(\d+).cross_attn.value_proj.weight": r"model.decoder.layers.\1.encoder_attn.value_proj.weight",
-    r"decoder.decoder.layers.(\d+).cross_attn.value_proj.bias": r"model.decoder.layers.\1.encoder_attn.value_proj.bias",
-    r"decoder.decoder.layers.(\d+).cross_attn.output_proj.weight": r"model.decoder.layers.\1.encoder_attn.output_proj.weight",
-    r"decoder.decoder.layers.(\d+).cross_attn.output_proj.bias": r"model.decoder.layers.\1.encoder_attn.output_proj.bias",
-    r"decoder.decoder.layers.(\d+).norm1.weight": r"model.decoder.layers.\1.self_attn_layer_norm.weight",
-    r"decoder.decoder.layers.(\d+).norm1.bias": r"model.decoder.layers.\1.self_attn_layer_norm.bias",
-    r"decoder.decoder.layers.(\d+).norm2.weight": r"model.decoder.layers.\1.encoder_attn_layer_norm.weight",
-    r"decoder.decoder.layers.(\d+).norm2.bias": r"model.decoder.layers.\1.encoder_attn_layer_norm.bias",
-    r"decoder.decoder.layers.(\d+).linear1.weight": r"model.decoder.layers.\1.fc1.weight",
-    r"decoder.decoder.layers.(\d+).linear1.bias": r"model.decoder.layers.\1.fc1.bias",
-    r"decoder.decoder.layers.(\d+).linear2.weight": r"model.decoder.layers.\1.fc2.weight",
-    r"decoder.decoder.layers.(\d+).linear2.bias": r"model.decoder.layers.\1.fc2.bias",
-    r"decoder.decoder.layers.(\d+).norm3.weight": r"model.decoder.layers.\1.final_layer_norm.weight",
-    r"decoder.decoder.layers.(\d+).norm3.bias": r"model.decoder.layers.\1.final_layer_norm.bias",
-    r"decoder.decoder.layers.(\d+).cross_attn.num_points_scale": r"model.decoder.layers.\1.encoder_attn.n_points_scale",
-    r"decoder.dec_score_head.(\d+).weight": r"model.decoder.class_embed.\1.weight",
-    r"decoder.dec_score_head.(\d+).bias": r"model.decoder.class_embed.\1.bias",
-    r"decoder.dec_bbox_head.(\d+).layers.(\d+).(weight|bias)": r"model.decoder.bbox_embed.\1.layers.\2.\3",
-    r"decoder.denoising_class_embed.weight": r"model.denoising_class_embed.weight",
-    r"decoder.query_pos_head.layers.0.weight": r"model.decoder.query_pos_head.layers.0.weight",
-    r"decoder.query_pos_head.layers.0.bias": r"model.decoder.query_pos_head.layers.0.bias",
-    r"decoder.query_pos_head.layers.1.weight": r"model.decoder.query_pos_head.layers.1.weight",
-    r"decoder.query_pos_head.layers.1.bias": r"model.decoder.query_pos_head.layers.1.bias",
-    r"decoder.enc_output.proj.weight": r"model.enc_output.0.weight",
-    r"decoder.enc_output.proj.bias": r"model.enc_output.0.bias",
-    r"decoder.enc_output.norm.weight": r"model.enc_output.1.weight",
-    r"decoder.enc_output.norm.bias": r"model.enc_output.1.bias",
-    r"decoder.enc_score_head.weight": r"model.enc_score_head.weight",
-    r"decoder.enc_score_head.bias": r"model.enc_score_head.bias",
-    r"decoder.enc_bbox_head.layers.(\d+).(weight|bias)": r"model.enc_bbox_head.layers.\1.\2",
-    r"backbone.res_layers.0.blocks.0.short.conv.weight": r"model.backbone.model.encoder.stages.0.layers.0.shortcut.convolution.weight",
-    r"backbone.res_layers.0.blocks.0.short.norm.(weight|bias|running_mean|running_var)": r"model.backbone.model.encoder.stages.0.layers.0.shortcut.normalization.\1",
-    r"backbone.res_layers.(\d+).blocks.0.short.conv.conv.weight": r"model.backbone.model.encoder.stages.\1.layers.0.shortcut.1.convolution.weight",
-    r"backbone.res_layers.(\d+).blocks.0.short.conv.norm.(\w+)": r"model.backbone.model.encoder.stages.\1.layers.0.shortcut.1.normalization.\2",
-    # Mapping for subsequent blocks in other stages
-    r"backbone.res_layers.(\d+).blocks.0.short.conv.weight": r"model.backbone.model.encoder.stages.\1.layers.0.shortcut.1.convolution.weight",
-    r"backbone.res_layers.(\d+).blocks.0.short.norm.(weight|bias|running_mean|running_var)": r"model.backbone.model.encoder.stages.\1.layers.0.shortcut.1.normalization.\2",
-    r"decoder.input_proj.(\d+).conv.weight": r"model.decoder_input_proj.\1.0.weight",
-    r"decoder.input_proj.(\d+).norm.(.*)": r"model.decoder_input_proj.\1.1.\2",
-}
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    # Use the mapping to rename keys
-    for original_key, converted_key in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-        for key in list(state_dict_keys.keys()):
-            new_key = re.sub(original_key, converted_key, key)
-            if new_key != key:
-                state_dict_keys[new_key] = state_dict_keys.pop(key)
-
-    return state_dict_keys
-
-
-def read_in_q_k_v(state_dict, config):
-    prefix = ""
-    encoder_hidden_dim = config.encoder_hidden_dim
-
-    # first: transformer encoder
-    for i in range(config.encoder_layers):
-        # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"{prefix}encoder.encoder.{i}.layers.0.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}encoder.encoder.{i}.layers.0.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.q_proj.weight"] = in_proj_weight[
-            :encoder_hidden_dim, :
-        ]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.q_proj.bias"] = in_proj_bias[:encoder_hidden_dim]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.k_proj.weight"] = in_proj_weight[
-            encoder_hidden_dim : 2 * encoder_hidden_dim, :
-        ]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.k_proj.bias"] = in_proj_bias[
-            encoder_hidden_dim : 2 * encoder_hidden_dim
-        ]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.v_proj.weight"] = in_proj_weight[
-            -encoder_hidden_dim:, :
-        ]
-        state_dict[f"model.encoder.encoder.{i}.layers.0.self_attn.v_proj.bias"] = in_proj_bias[-encoder_hidden_dim:]
-    # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
-    for i in range(config.decoder_layers):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"{prefix}decoder.decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}decoder.decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-
-    return im
-
-
-@torch.no_grad()
-def write_model_and_image_processor(model_name, output_dir, push_to_hub, repo_id):
-    """
-    Copy/paste/tweak model's weights to our RTDETR structure.
-    """
-
-    # load default config
-    config = get_rt_detr_v2_config(model_name)
-
-    # load original model from torch hub
-    model_name_to_checkpoint_url = {
-        "rtdetr_v2_r18vd": "https://github.com/lyuwenyu/storage/releases/download/v0.2/rtdetrv2_r18vd_120e_coco_rerun_48.1.pth",
-        "rtdetr_v2_r34vd": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetrv2_r34vd_120e_coco_ema.pth",
-        "rtdetr_v2_r50vd": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetrv2_r50vd_6x_coco_ema.pth",
-        "rtdetr_v2_r101vd": "https://github.com/lyuwenyu/storage/releases/download/v0.1/rtdetrv2_r101vd_6x_coco_from_paddle.pth",
-    }
-    logger.info(f"Converting model {model_name}...")
-    state_dict = torch.hub.load_state_dict_from_url(model_name_to_checkpoint_url[model_name], map_location="cpu")[
-        "ema"
-    ]["module"]
-    # rename keys
-    state_dict = convert_old_keys_to_new_keys(state_dict)
-    for key in state_dict.copy().keys():
-        if key.endswith("num_batches_tracked"):
-            del state_dict[key]
-    # query, key and value matrices need special treatment
-    read_in_q_k_v(state_dict, config)
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    for key in state_dict.copy().keys():
-        if key.endswith("num_batches_tracked"):
-            del state_dict[key]
-        # for two_stage
-        if "bbox_embed" in key or ("class_embed" in key and "denoising_" not in key):
-            state_dict[key.split("model.decoder.")[-1]] = state_dict[key]
-
-    # no need in ckpt
-    del state_dict["decoder.anchors"]
-    del state_dict["decoder.valid_mask"]
-    # finally, create HuggingFace model and load state dict
-    model = RTDetrV2ForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # load image processor
-    image_processor = RTDetrImageProcessor()
-
-    # prepare image
-    img = prepare_img()
-
-    # preprocess image
-    transformations = transforms.Compose(
-        [
-            transforms.Resize([640, 640], interpolation=transforms.InterpolationMode.BILINEAR),
-            transforms.ToTensor(),
-        ]
-    )
-    original_pixel_values = transformations(img).unsqueeze(0)  # insert batch dimension
-
-    encoding = image_processor(images=img, return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-
-    assert torch.allclose(original_pixel_values, pixel_values)
-
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-    pixel_values = pixel_values.to(device)
-
-    # Pass image by the model
-    with torch.no_grad():
-        outputs = model(pixel_values)
-
-    if model_name == "rtdetr_v2_r18vd":
-        expected_slice_logits = torch.tensor(
-            [[-3.7045, -5.1913, -6.1787], [-4.0106, -9.3450, -5.2043], [-4.1287, -4.7463, -5.8634]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.2582, 0.5497, 0.4764], [0.1684, 0.1985, 0.2120], [0.7665, 0.4146, 0.4669]]
-        )
-    elif model_name == "rtdetr_v2_r34vd":
-        expected_slice_logits = torch.tensor(
-            [[-4.6108, -5.9453, -3.8505], [-3.8702, -6.1136, -5.5677], [-3.7790, -6.4538, -5.9449]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.1691, 0.1984, 0.2118], [0.2594, 0.5506, 0.4736], [0.7669, 0.4136, 0.4654]]
-        )
-    elif model_name == "rtdetr_v2_r50vd":
-        expected_slice_logits = torch.tensor(
-            [[-4.7881, -4.6754, -6.1624], [-5.4441, -6.6486, -4.3840], [-3.5455, -4.9318, -6.3544]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.2588, 0.5487, 0.4747], [0.5497, 0.2760, 0.0573], [0.7688, 0.4133, 0.4634]]
-        )
-    elif model_name == "rtdetr_v2_r101vd":
-        expected_slice_logits = torch.tensor(
-            [[-4.6162, -4.9189, -4.6656], [-4.4701, -4.4997, -4.9659], [-5.6641, -7.9000, -5.0725]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.7707, 0.4124, 0.4585], [0.2589, 0.5492, 0.4735], [0.1688, 0.1993, 0.2108]]
-        )
-    else:
-        raise ValueError(f"Unknown rt_detr_v2_name: {model_name}")
-    assert torch.allclose(outputs.logits[0, :3, :3], expected_slice_logits.to(outputs.logits.device), atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes[0, :3, :3], expected_slice_boxes.to(outputs.pred_boxes.device), atol=1e-3)
-
-    if output_dir is not None:
-        Path(output_dir).mkdir(exist_ok=True)
-        print(f"Saving model {model_name} to {output_dir}")
-        model.save_pretrained(output_dir)
-        print(f"Saving image processor to {output_dir}")
-        image_processor.save_pretrained(output_dir)
-
-    if push_to_hub:
-        # Upload model, image processor and config to the hub
-        logger.info("Uploading PyTorch model and image processor to the hub...")
-        config.push_to_hub(
-            repo_id=repo_id,
-            commit_message="Add config from convert_rt_detr_v2_original_pytorch_checkpoint_to_pytorch.py",
-        )
-        model.push_to_hub(
-            repo_id=repo_id,
-            commit_message="Add model from convert_rt_detr_v2_original_pytorch_checkpoint_to_pytorch.py",
-        )
-        image_processor.push_to_hub(
-            repo_id=repo_id,
-            commit_message="Add image processor from convert_rt_detr_v2_original_pytorch_checkpoint_to_pytorch.py",
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model_name",
-        default="rtdetr_v2_r18vd",
-        type=str,
-        help="model_name of the checkpoint you'd like to convert.",
-    )
-    parser.add_argument("--output_dir", default=None, type=str, help="Location to write HF model and image processor")
-    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to the hub or not.")
-    parser.add_argument(
-        "--repo_id",
-        type=str,
-        help="repo_id where the model will be pushed to.",
-    )
-    args = parser.parse_args()
-    write_model_and_image_processor(args.model_name, args.output_dir, args.push_to_hub, args.repo_id)
diff --git a/src/transformers/models/rwkv/convert_rwkv_checkpoint_to_hf.py b/src/transformers/models/rwkv/convert_rwkv_checkpoint_to_hf.py
deleted file mode 100644
index a0c97fc4e234..000000000000
--- a/src/transformers/models/rwkv/convert_rwkv_checkpoint_to_hf.py
+++ /dev/null
@@ -1,209 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert a RWKV checkpoint from BlinkDL to the Hugging Face format."""
-
-import argparse
-import gc
-import json
-import os
-import re
-
-import torch
-from huggingface_hub import hf_hub_download, split_torch_state_dict_into_shards
-
-from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedTokenizerFast, RwkvConfig
-from transformers.modeling_utils import WEIGHTS_INDEX_NAME
-
-
-NUM_HIDDEN_LAYERS_MAPPING = {
-    "169M": 12,
-    "430M": 24,
-    "1B5": 24,
-    "3B": 32,
-    "7B": 32,
-    "14B": 40,
-}
-
-HIDEN_SIZE_MAPPING = {
-    "169M": 768,
-    "430M": 1024,
-    "1B5": 2048,
-    "3B": 2560,
-    "7B": 4096,
-    "14B": 5120,
-}
-
-
-def convert_state_dict(state_dict):
-    state_dict_keys = list(state_dict.keys())
-    for name in state_dict_keys:
-        weight = state_dict.pop(name)
-        # emb -> embedding
-        if name.startswith("emb."):
-            name = name.replace("emb.", "embeddings.")
-        # ln_0 -> pre_ln (only present at block 0)
-        if name.startswith("blocks.0.ln0"):
-            name = name.replace("blocks.0.ln0", "blocks.0.pre_ln")
-        # att -> attention
-        name = re.sub(r"blocks\.(\d+)\.att", r"blocks.\1.attention", name)
-        # ffn -> feed_forward
-        name = re.sub(r"blocks\.(\d+)\.ffn", r"blocks.\1.feed_forward", name)
-        # time_mix_k -> time_mix_key and reshape
-        if name.endswith(".time_mix_k"):
-            name = name.replace(".time_mix_k", ".time_mix_key")
-        # time_mix_v -> time_mix_value and reshape
-        if name.endswith(".time_mix_v"):
-            name = name.replace(".time_mix_v", ".time_mix_value")
-        # time_mix_r -> time_mix_key and reshape
-        if name.endswith(".time_mix_r"):
-            name = name.replace(".time_mix_r", ".time_mix_receptance")
-
-        if name != "head.weight":
-            name = "rwkv." + name
-
-        state_dict[name] = weight
-    return state_dict
-
-
-def convert_rmkv_checkpoint_to_hf_format(
-    repo_id, checkpoint_file, output_dir, size=None, tokenizer_file=None, push_to_hub=False, model_name=None
-):
-    # 1. If possible, build the tokenizer.
-    if tokenizer_file is None:
-        print("No `--tokenizer_file` provided, we will use the default tokenizer.")
-        vocab_size = 50277
-        tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b")
-    else:
-        tokenizer = PreTrainedTokenizerFast(tokenizer_file=tokenizer_file)
-        vocab_size = len(tokenizer)
-    tokenizer.save_pretrained(output_dir)
-
-    # 2. Build the config
-    possible_sizes = list(NUM_HIDDEN_LAYERS_MAPPING.keys())
-    if size is None:
-        # Try to infer size from the checkpoint name
-        for candidate in possible_sizes:
-            if candidate in checkpoint_file:
-                size = candidate
-                break
-        if size is None:
-            raise ValueError("Could not infer the size, please provide it with the `--size` argument.")
-    if size not in possible_sizes:
-        raise ValueError(f"`size` should be one of {possible_sizes}, got {size}.")
-
-    config = RwkvConfig(
-        vocab_size=vocab_size,
-        num_hidden_layers=NUM_HIDDEN_LAYERS_MAPPING[size],
-        hidden_size=HIDEN_SIZE_MAPPING[size],
-    )
-    config.save_pretrained(output_dir)
-
-    # 3. Download model file then convert state_dict
-    model_file = hf_hub_download(repo_id, checkpoint_file)
-    state_dict = torch.load(model_file, map_location="cpu")
-    state_dict = convert_state_dict(state_dict)
-
-    # 4. Split in shards and save
-    state_dict_split = split_torch_state_dict_into_shards(state_dict)
-    shards = index = None
-    for tensors in state_dict_split.filename_to_tensors.values():
-        shards = {tensor: state_dict[tensor] for tensor in tensors}
-    if state_dict_split.is_sharded:
-        index = {
-            "metadata": state_dict_split.metadata,
-            "weight_map": state_dict_split.tensor_to_filename,
-        }
-
-    for shard_file, shard in shards.items():
-        torch.save(shard, os.path.join(output_dir, shard_file))
-
-    if index is not None:
-        save_index_file = os.path.join(output_dir, WEIGHTS_INDEX_NAME)
-        # Save the index as well
-        with open(save_index_file, "w", encoding="utf-8") as f:
-            content = json.dumps(index, indent=2, sort_keys=True) + "\n"
-            f.write(content)
-
-        # 5. Clean up shards (for some reason the file PyTorch saves take the same space as the whole state_dict
-        print(
-            "Cleaning up shards. This may error with an OOM error, it this is the case don't worry you still have converted the model."
-        )
-        shard_files = list(shards.keys())
-
-        del state_dict
-        del shards
-        gc.collect()
-
-        for shard_file in shard_files:
-            state_dict = torch.load(os.path.join(output_dir, shard_file))
-            torch.save({k: v.cpu().clone() for k, v in state_dict.items()}, os.path.join(output_dir, shard_file))
-
-    del state_dict
-    gc.collect()
-
-    if push_to_hub:
-        if model_name is None:
-            raise ValueError("Please provide a `model_name` to push the model to the Hub.")
-        model = AutoModelForCausalLM.from_pretrained(output_dir)
-        model.push_to_hub(model_name, max_shard_size="2GB")
-        tokenizer.push_to_hub(model_name)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--repo_id", default=None, type=str, required=True, help="Repo ID from which to pull the checkpoint."
-    )
-    parser.add_argument(
-        "--checkpoint_file", default=None, type=str, required=True, help="Name of the checkpoint file in the repo."
-    )
-    parser.add_argument(
-        "--output_dir", default=None, type=str, required=True, help="Where to save the converted model."
-    )
-    parser.add_argument(
-        "--tokenizer_file",
-        default=None,
-        type=str,
-        help="Path to the tokenizer file to use (if not provided, only the model is converted).",
-    )
-    parser.add_argument(
-        "--size",
-        default=None,
-        type=str,
-        help="Size of the model. Will be inferred from the `checkpoint_file` if not passed.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Push to the Hub the converted model.",
-    )
-    parser.add_argument(
-        "--model_name",
-        default=None,
-        type=str,
-        help="Name of the pushed model on the Hub, including the username / organization.",
-    )
-
-    args = parser.parse_args()
-    convert_rmkv_checkpoint_to_hf_format(
-        args.repo_id,
-        args.checkpoint_file,
-        args.output_dir,
-        size=args.size,
-        tokenizer_file=args.tokenizer_file,
-        push_to_hub=args.push_to_hub,
-        model_name=args.model_name,
-    )
diff --git a/src/transformers/models/sam/convert_sam_to_hf.py b/src/transformers/models/sam/convert_sam_to_hf.py
deleted file mode 100644
index dd8818b68cfc..000000000000
--- a/src/transformers/models/sam/convert_sam_to_hf.py
+++ /dev/null
@@ -1,251 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Convert SAM checkpoints from the original repository.
-
-URL: https://github.com/facebookresearch/segment-anything.
-
-Also supports converting the SlimSAM checkpoints from https://github.com/czg1225/SlimSAM/tree/master.
-"""
-
-import argparse
-import re
-
-import numpy as np
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    SamConfig,
-    SamImageProcessor,
-    SamModel,
-    SamProcessor,
-    SamVisionConfig,
-)
-
-
-def get_config(model_name):
-    if "slimsam-50" in model_name:
-        vision_config = SamVisionConfig(
-            hidden_size=384,
-            mlp_dim=1536,
-            num_hidden_layers=12,
-            num_attention_heads=12,
-            global_attn_indexes=[2, 5, 8, 11],
-        )
-    elif "slimsam-77" in model_name:
-        vision_config = SamVisionConfig(
-            hidden_size=168,
-            mlp_dim=696,
-            num_hidden_layers=12,
-            num_attention_heads=12,
-            global_attn_indexes=[2, 5, 8, 11],
-        )
-    elif "sam_vit_b" in model_name:
-        vision_config = SamVisionConfig()
-    elif "sam_vit_l" in model_name:
-        vision_config = SamVisionConfig(
-            hidden_size=1024,
-            num_hidden_layers=24,
-            num_attention_heads=16,
-            global_attn_indexes=[5, 11, 17, 23],
-        )
-    elif "sam_vit_h" in model_name:
-        vision_config = SamVisionConfig(
-            hidden_size=1280,
-            num_hidden_layers=32,
-            num_attention_heads=16,
-            global_attn_indexes=[7, 15, 23, 31],
-        )
-
-    config = SamConfig(
-        vision_config=vision_config,
-    )
-
-    return config
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "iou_prediction_head.layers.0": "iou_prediction_head.proj_in",
-    "iou_prediction_head.layers.1": "iou_prediction_head.layers.0",
-    "iou_prediction_head.layers.2": "iou_prediction_head.proj_out",
-    "mask_decoder.output_upscaling.0": "mask_decoder.upscale_conv1",
-    "mask_decoder.output_upscaling.1": "mask_decoder.upscale_layer_norm",
-    "mask_decoder.output_upscaling.3": "mask_decoder.upscale_conv2",
-    "mask_downscaling.0": "mask_embed.conv1",
-    "mask_downscaling.1": "mask_embed.layer_norm1",
-    "mask_downscaling.3": "mask_embed.conv2",
-    "mask_downscaling.4": "mask_embed.layer_norm2",
-    "mask_downscaling.6": "mask_embed.conv3",
-    "point_embeddings": "point_embed",
-    "pe_layer.positional_encoding_gaussian_matrix": "shared_embedding.positional_embedding",
-    "image_encoder": "vision_encoder",
-    "neck.0": "neck.conv1",
-    "neck.1": "neck.layer_norm1",
-    "neck.2": "neck.conv2",
-    "neck.3": "neck.layer_norm2",
-    "patch_embed.proj": "patch_embed.projection",
-    ".norm": ".layer_norm",
-    "blocks": "layers",
-}
-
-
-def replace_keys(state_dict):
-    model_state_dict = {}
-    state_dict.pop("pixel_mean", None)
-    state_dict.pop("pixel_std", None)
-
-    output_hypernetworks_mlps_pattern = r".*.output_hypernetworks_mlps.(\d+).layers.(\d+).*"
-
-    for key, value in state_dict.items():
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        if re.match(output_hypernetworks_mlps_pattern, key):
-            layer_nb = int(re.match(output_hypernetworks_mlps_pattern, key).group(2))
-            if layer_nb == 0:
-                key = key.replace("layers.0", "proj_in")
-            elif layer_nb == 1:
-                key = key.replace("layers.1", "layers.0")
-            elif layer_nb == 2:
-                key = key.replace("layers.2", "proj_out")
-
-        model_state_dict[key] = value
-
-    model_state_dict["shared_image_embedding.positional_embedding"] = model_state_dict[
-        "prompt_encoder.shared_embedding.positional_embedding"
-    ]
-
-    return model_state_dict
-
-
-def convert_sam_checkpoint(model_name, checkpoint_path, pytorch_dump_folder, push_to_hub):
-    config = get_config(model_name)
-
-    state_dict = torch.load(checkpoint_path, map_location="cpu")
-    state_dict = replace_keys(state_dict)
-
-    image_processor = SamImageProcessor()
-    processor = SamProcessor(image_processor=image_processor)
-    hf_model = SamModel(config)
-    hf_model.eval()
-
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-
-    hf_model.load_state_dict(state_dict)
-    hf_model = hf_model.to(device)
-
-    img_url = "https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
-    raw_image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB")
-
-    input_points = [[[500, 375]]]
-    input_labels = [[1]]
-
-    inputs = processor(images=np.array(raw_image), return_tensors="pt").to(device)
-
-    with torch.no_grad():
-        output = hf_model(**inputs)
-    scores = output.iou_scores.squeeze()
-
-    if model_name == "sam_vit_b_01ec64":
-        inputs = processor(
-            images=np.array(raw_image), input_points=input_points, input_labels=input_labels, return_tensors="pt"
-        ).to(device)
-
-        with torch.no_grad():
-            output = hf_model(**inputs)
-            scores = output.iou_scores.squeeze()
-
-    elif model_name == "sam_vit_h_4b8939":
-        inputs = processor(
-            images=np.array(raw_image), input_points=input_points, input_labels=input_labels, return_tensors="pt"
-        ).to(device)
-
-        with torch.no_grad():
-            output = hf_model(**inputs)
-        scores = output.iou_scores.squeeze()
-
-        assert scores[-1].item() == 0.9712603092193604
-
-        input_boxes = ((75, 275, 1725, 850),)
-
-        inputs = processor(images=np.array(raw_image), input_boxes=input_boxes, return_tensors="pt").to(device)
-
-        with torch.no_grad():
-            output = hf_model(**inputs)
-        scores = output.iou_scores.squeeze()
-
-        assert scores[-1].item() == 0.8686015605926514
-
-        # Test with 2 points and 1 image.
-        input_points = [[[400, 650], [800, 650]]]
-        input_labels = [[1, 1]]
-
-        inputs = processor(
-            images=np.array(raw_image), input_points=input_points, input_labels=input_labels, return_tensors="pt"
-        ).to(device)
-
-        with torch.no_grad():
-            output = hf_model(**inputs)
-        scores = output.iou_scores.squeeze()
-
-        assert scores[-1].item() == 0.9936047792434692
-
-    if pytorch_dump_folder is not None:
-        processor.save_pretrained(pytorch_dump_folder)
-        hf_model.save_pretrained(pytorch_dump_folder)
-
-    if push_to_hub:
-        repo_id = f"nielsr/{model_name}" if "slimsam" in model_name else f"meta/{model_name}"
-        processor.push_to_hub(repo_id)
-        hf_model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    choices = ["sam_vit_b_01ec64", "sam_vit_h_4b8939", "sam_vit_l_0b3195", "slimsam-50-uniform", "slimsam-77-uniform"]
-    parser.add_argument(
-        "--model_name",
-        default="sam_vit_h_4b8939",
-        choices=choices,
-        type=str,
-        help="Name of the original model to convert",
-    )
-    parser.add_argument(
-        "--checkpoint_path",
-        type=str,
-        required=False,
-        help="Path to the original checkpoint",
-    )
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Whether to push the model and processor to the hub after converting",
-    )
-
-    args = parser.parse_args()
-
-    if "slimsam" in args.model_name:
-        checkpoint_path = args.checkpoint_path
-        if checkpoint_path is None:
-            raise ValueError("You need to provide a checkpoint path for SlimSAM models.")
-    else:
-        checkpoint_path = hf_hub_download("ybelkada/segment-anything", f"checkpoints/{args.model_name}.pth")
-
-    convert_sam_checkpoint(args.model_name, checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/seamless_m4t/convert_fairseq2_to_hf.py b/src/transformers/models/seamless_m4t/convert_fairseq2_to_hf.py
deleted file mode 100644
index 7bef416ec375..000000000000
--- a/src/transformers/models/seamless_m4t/convert_fairseq2_to_hf.py
+++ /dev/null
@@ -1,396 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Converting Meta SeamlessM4T checkpoints from seamless_communication to HF."""
-
-import argparse
-import os
-from pathlib import Path
-
-import torch
-from accelerate.utils.modeling import find_tied_parameters
-from seamless_communication.models.inference.translator import Translator
-
-from transformers import (
-    SeamlessM4TConfig,
-    SeamlessM4TFeatureExtractor,
-    SeamlessM4TModel,
-    SeamlessM4TProcessor,
-    SeamlessM4TTokenizer,
-)
-from transformers.utils import logging
-
-
-UNIT_SUPPORTED_LANGUAGES = ["__arb__", "__ben__", "__cat__", "__ces__", "__cmn__", "__cym__", "__dan__", "__deu__", "__eng__", "__est__", "__fin__", "__fra__", "__hin__", "__ind__", "__ita__", "__jpn__", "__kan__", "__kor__", "__mlt__", "__nld__", "__pes__", "__pol__", "__por__", "__ron__", "__rus__", "__slk__", "__spa__", "__swe__", "__swh__", "__tam__", "__tel__", "__tgl__", "__tha__", "__tur__", "__ukr__", "__urd__", "__uzn__", "__vie__", ]  # fmt: skip
-VOCODER_SUPPORTED_LANGUAGES = ["__arb__", "__ben__", "__cat__", "__ces__", "__cmn__", "__cym__", "__dan__", "__deu__", "__eng__", "__est__", "__fin__", "__fra__", "__hin__", "__ind__", "__ita__", "__jpn__", "__kor__", "__mlt__", "__nld__", "__pes__", "__pol__", "__por__", "__ron__", "__rus__", "__slk__", "__spa__", "__swe__", "__swh__", "__tel__", "__tgl__", "__tha__", "__tur__", "__ukr__", "__urd__", "__uzn__", "__vie__",]  # fmt: skip
-MEDIUM_SUPPORTED_LANGUAGES = ["ace","ace_Latn","acm","acq","aeb","afr","ajp","aka","amh","apc","arb","ars","ary","arz","asm","ast","awa","ayr","azb","azj","bak","bam","ban","bel","bem","ben","bho","bjn","bjn_Latn","bod","bos","bug","bul","cat","ceb","ces","cjk","ckb","crh","cym","dan","deu","dik","dyu","dzo","ell","eng","epo","est","eus","ewe","fao","pes","fij","fin","fon","fra","fur","fuv","gla","gle","glg","grn","guj","hat","hau","heb","hin","hne","hrv","hun","hye","ibo","ilo","ind","isl","ita","jav","jpn","kab","kac","kam","kan","kas","kas_Deva","kat","knc","knc_Latn","kaz","kbp","kea","khm","kik","kin","kir","kmb","kon","kor","kmr","lao","lvs","lij","lim","lin","lit","lmo","ltg","ltz","lua","lug","luo","lus","mag","mai","mal","mar","min","mkd","plt","mlt","mni","khk","mos","mri","zsm","mya","nld","nno","nob","npi","nso","nus","nya","oci","gaz","ory","pag","pan","pap","pol","por","prs","pbt","quy","ron","run","rus","sag","san","sat","scn","shn","sin","slk","slv","smo","sna","snd","som","sot","spa","als","srd","srp","ssw","sun","swe","swh","szl","tam","tat","tel","tgk","tgl","tha","tir","taq","taq_Tfng","tpi","tsn","tso","tuk","tum","tur","twi","tzm","uig","ukr","umb","urd","uzn","vec","vie","war","wol","xho","ydd","yor","yue","cmn","cmn_Hant","zul",]  # fmt: skip
-LARGE_SUPPORTED_LANGUAGES = ["afr","amh","arb","ary","arz","asm","azj","bel","ben","bos","bul","cat","ceb","ces","ckb","cmn","cmn_Hant","cym","dan","deu","ell","eng","est","eus","fin","fra","fuv","gaz","gle","glg","guj","heb","hin","hrv","hun","hye","ibo","ind","isl","ita","jav","jpn","kan","kat","kaz","khk","khm","kir","kor","lao","lit","lug","luo","lvs","mai","mal","mar","mkd","mlt","mni","mya","nld","nno","nob","npi","nya","ory","pan","pbt","pes","pol","por","ron","rus","sat","slk","slv","sna","snd","som","spa","srp","swe","swh","tam","tel","tgk","tgl","tha","tur","ukr","urd","uzn","vie","yor","yue","zlm","zul",]  # fmt: skip
-
-
-def assert_param_count(model_1, model_2):
-    count_1 = sum(p[1].numel() for p in model_1.named_parameters() if "final_proj" not in p[0])
-    count_2 = sum(p[1].numel() for p in model_2.named_parameters() if "final_proj" not in p[0])
-    assert count_1 == count_2, f"{model_1.__class__}: {count_1} != {model_2.__class__}: {count_2}"
-
-
-def param_count(model):
-    return sum(p[1].numel() for p in model.named_parameters() if "final_proj" not in p[0])
-
-
-def _grab_best_device(use_gpu=True):
-    if torch.cuda.device_count() > 0 and use_gpu:
-        device = "cuda"
-    else:
-        device = "cpu"
-    return torch.device(device)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-vocoder_convert_list = [
-    ("ups", "hifi_gan.upsampler"),
-    ("conv_pre", "hifi_gan.conv_pre"),
-    ("resblocks", "hifi_gan.resblocks"),
-    ("conv_post", "hifi_gan.conv_post"),
-    ("lang", "language_embedding"),
-    ("spkr", "speaker_embedding"),
-    ("dict.", "unit_embedding."),
-    ("dur_predictor.conv1.0", "dur_predictor.conv1"),
-    ("dur_predictor.conv2.0", "dur_predictor.conv2"),
-]
-
-# order is important
-wav2vec_convert_list = [
-    ("speech_encoder_frontend.model_dim_proj", "feature_projection.projection"),
-    ("speech_encoder_frontend.post_extract_layer_norm", "feature_projection.layer_norm"),
-    ("speech_encoder_frontend.pos_encoder.conv", "encoder.pos_conv_embed.conv"),
-    ("speech_encoder.inner.layers", "encoder.layers"),
-    ("speech_encoder.inner_layer_norm", "encoder.layer_norm"),
-    ("speech_encoder.adaptor_layers", "adapter.layers"),
-    ("inner_proj", "intermediate_dense"),
-    ("self_attn.output_proj", "self_attn.linear_out"),
-    ("output_proj", "output_dense"),
-    ("self_attn.k_proj", "self_attn.linear_k"),
-    ("self_attn.v_proj", "self_attn.linear_v"),
-    ("self_attn.q_proj", "self_attn.linear_q"),
-    ("self_attn.sdpa.u_bias", "self_attn.pos_bias_u"),
-    ("self_attn.sdpa.v_bias", "self_attn.pos_bias_v"),
-    ("self_attn.sdpa.r_proj", "self_attn.linear_pos"),
-    ("conv.pointwise_conv1", "conv_module.pointwise_conv1"),
-    ("conv.pointwise_conv2", "conv_module.pointwise_conv2"),
-    ("conv.depthwise_conv", "conv_module.depthwise_conv"),
-    ("conv.batch_norm", "conv_module.batch_norm"),
-    ("conv_layer_norm", "conv_module.layer_norm"),
-    ("speech_encoder.proj1", "intermediate_ffn.intermediate_dense"),
-    ("speech_encoder.proj2", "intermediate_ffn.output_dense"),
-    ("speech_encoder.layer_norm", "inner_layer_norm"),
-]
-
-t2u_convert_list = [
-    ("t2u_model.final_proj", "lm_head"),
-    ("t2u_model.", "model."),
-    ("encoder_decoder_attn_layer_norm", "cross_attention_layer_norm"),
-    ("encoder_decoder_attn", "cross_attention"),
-    ("linear_k", "k_proj"),
-    ("linear_v", "v_proj"),
-    ("linear_q", "q_proj"),
-    ("ffn.inner_proj", "ffn.fc1"),
-    ("ffn.output_proj", "ffn.fc2"),
-    ("output_proj", "out_proj"),
-    ("decoder_frontend.embed", "decoder.embed_tokens"),
-]
-
-text_convert_list = [
-    ("text_encoder.", ""),
-    ("text_decoder.", ""),
-    ("text_encoder_frontend.embed", "embed_tokens"),
-    ("text_decoder_frontend.embed", "embed_tokens"),
-    ("encoder_decoder_attn_layer_norm", "cross_attention_layer_norm"),
-    ("encoder_decoder_attn", "cross_attention"),
-    ("linear_k", "k_proj"),
-    ("linear_v", "v_proj"),
-    ("linear_q", "q_proj"),
-    ("ffn.inner_proj", "ffn.fc1"),
-    ("ffn.output_proj", "ffn.fc2"),
-    ("output_proj", "out_proj"),
-    ("final_proj", "lm_head"),
-]
-
-CUR_PATH = os.path.dirname(os.path.abspath(__file__))
-default_cache_dir = os.path.join(os.path.expanduser("~"), ".cache")
-CACHE_DIR = os.path.join(os.getenv("XDG_CACHE_HOME", default_cache_dir), "huggingface", "hub")
-
-
-def _load_hf_config(model_type="medium"):
-    if model_type == "medium":
-        kwargs = {
-            "vocab_size": 256206,
-            "t2u_vocab_size": 10082,
-            "hidden_size": 1024,
-            "max_position_embeddings": 4096,
-            "encoder_layers": 12,
-            "decoder_layers": 12,
-            "encoder_ffn_dim": 4096,
-            "decoder_ffn_dim": 4096,
-            "t2u_encoder_layers": 4,
-            "t2u_decoder_layers": 4,
-            "speech_encoder_layers": 12,
-        }
-        return SeamlessM4TConfig(**kwargs)
-    else:
-        return SeamlessM4TConfig()
-
-
-def _convert_model(
-    original_model,
-    hf_model,
-    convert_list,
-    device,
-    unwanted_prefix="model.",
-    filter_state_dict="speech",
-    exclude_state_dict=None,
-):
-    state_dict = original_model.state_dict()
-
-    # filter func
-    if isinstance(filter_state_dict, str):
-
-        def filter_func(x):
-            return filter_state_dict in x[0]
-
-    else:
-
-        def filter_func(item):
-            if exclude_state_dict is not None and exclude_state_dict in item[0]:
-                return False
-            for filter_el in filter_state_dict:
-                if filter_el in item[0]:
-                    return True
-
-            return False
-
-    state_dict = dict(filter(filter_func, state_dict.items()))
-
-    for k, v in list(state_dict.items()):
-        new_k = k[len(unwanted_prefix) :]
-        for old_layer_name, new_layer_name in convert_list:
-            if old_layer_name in new_k:
-                new_k = new_k.replace(old_layer_name, new_layer_name)
-
-        # must do it by hand
-        if ".layer_norm" in new_k and new_k.split(".layer_norm")[0][-1].isnumeric():
-            new_k = new_k.replace("layer_norm", "final_layer_norm")
-
-        state_dict[new_k] = state_dict.pop(k)
-
-    extra_keys = set(state_dict.keys()) - set(hf_model.state_dict().keys())
-    extra_keys = set(extra_keys)
-    missing_keys = set(hf_model.state_dict().keys()) - set(state_dict.keys())
-    missing_keys = set({k for k in missing_keys if "final_logits_bias" not in k})
-    if len(extra_keys) != 0:
-        raise ValueError(f"extra keys found: {extra_keys}")
-    if len(missing_keys) != 0:
-        raise ValueError(f"missing keys: {missing_keys}")
-    hf_model.load_state_dict(state_dict, strict=False)
-    n_params = param_count(hf_model)
-
-    logger.info(f"model loaded: {round(n_params / 1e6, 1)}M params")
-
-    hf_model.eval()
-    hf_model.to(device)
-    del state_dict
-
-    return hf_model
-
-
-def load_model(save_dir, model_type, repo_id):
-    """
-    Meta SeamlessM4T is made of 8 main components:
-    - speech_encoder (#1) and speech_encoder_frontend (#2)
-    - t2u_model (#3)
-    - text_encoder (#4) and text_encoder_frontend (#5)
-    - text_decoder (#6) [and text_decoder_frontend (#5) = equals to text_encoder_frontend]
-    - final_proj (#7)
-    - vocoder (#8)
-    """
-    device = _grab_best_device()
-    if model_type == "medium":
-        name = "seamlessM4T_medium"
-    else:
-        name = "seamlessM4T_large"
-
-    original_model = Translator(name, "vocoder_36langs", device, torch.float32)
-
-    ######### TOKENIZER
-
-    langs = MEDIUM_SUPPORTED_LANGUAGES if model_type == "medium" else LARGE_SUPPORTED_LANGUAGES
-    langs = [f"__{lang}__" for lang in langs]
-    vocab_file = os.path.join(os.path.expanduser("~"), "tokenizer", model_type, "tokenizer.model")
-
-    save_dir = os.path.join(save_dir, name)
-    Path(save_dir).mkdir(exist_ok=True)
-
-    tokenizer = SeamlessM4TTokenizer(vocab_file, additional_special_tokens=langs)
-
-    sanity_check_lang_id = tokenizer.convert_tokens_to_ids("__fra__")
-
-    tokenizer.save_pretrained(save_dir)
-    tokenizer = SeamlessM4TTokenizer.from_pretrained(save_dir)
-
-    if sanity_check_lang_id != tokenizer.convert_tokens_to_ids("__fra__"):
-        raise ValueError(
-            f"Error in tokenizer saving/loading - __fra__ lang id is not coherent: {sanity_check_lang_id} vs {tokenizer.convert_tokens_to_ids('__fra__')}"
-        )
-
-    ####### get language to ids dict
-    text_decoder_lang_code_to_id = {lang.replace("__", ""): tokenizer.convert_tokens_to_ids(lang) for lang in langs}
-    # offset: vocoder unit vocab size + 5 (for EOS/PAD/BOS/UNK/MSK) + len(supported_languages)
-    t2u_lang_code_to_id = {
-        code.replace("__", ""): i + 10005 + len(UNIT_SUPPORTED_LANGUAGES)
-        for i, code in enumerate(UNIT_SUPPORTED_LANGUAGES)
-    }
-    vocoder_lang_code_to_id = {code.replace("__", ""): i for i, code in enumerate(VOCODER_SUPPORTED_LANGUAGES)}
-
-    ######### FE
-
-    fe = SeamlessM4TFeatureExtractor(language_code=langs)
-
-    fe.save_pretrained(save_dir)
-    fe = SeamlessM4TFeatureExtractor.from_pretrained(save_dir)
-
-    processor = SeamlessM4TProcessor(feature_extractor=fe, tokenizer=tokenizer)
-    processor.save_pretrained(save_dir)
-    processor.push_to_hub(repo_id=repo_id, create_pr=True)
-
-    processor = SeamlessM4TProcessor.from_pretrained(save_dir)
-
-    ######## Model
-
-    # init model
-    hf_config = _load_hf_config(model_type)
-    hf_model = SeamlessM4TModel(hf_config)
-
-    hf_model.generation_config.__setattr__("text_decoder_lang_to_code_id", text_decoder_lang_code_to_id)
-    hf_model.generation_config.__setattr__("t2u_lang_code_to_id", t2u_lang_code_to_id)
-    hf_model.generation_config.__setattr__("vocoder_lang_code_to_id", vocoder_lang_code_to_id)
-
-    # -1. take care of vocoder
-    # similarly to speech T5 must apply and remove weight norm
-    hf_model.vocoder.apply_weight_norm()
-    hf_model.vocoder = _convert_model(
-        original_model,
-        hf_model.vocoder,
-        vocoder_convert_list,
-        device,
-        unwanted_prefix="vocoder.code_generator.",
-        filter_state_dict="vocoder",
-    )
-    hf_model.vocoder.remove_weight_norm()
-
-    # 1. take care of speech encoder
-    wav2vec = hf_model.speech_encoder
-    hf_model.speech_encoder = _convert_model(
-        original_model, wav2vec, wav2vec_convert_list, device, unwanted_prefix="model.", filter_state_dict="speech"
-    )
-
-    # 2. take care of t2u
-
-    hf_model.t2u_model = _convert_model(
-        original_model,
-        hf_model.t2u_model,
-        t2u_convert_list,
-        device,
-        unwanted_prefix="model.",
-        filter_state_dict="t2u_model",
-    )
-
-    # 3. take care of text encoder
-    hf_model.text_encoder = _convert_model(
-        original_model,
-        hf_model.text_encoder,
-        text_convert_list,
-        device,
-        unwanted_prefix="model.",
-        filter_state_dict=["model.text_encoder"],
-        exclude_state_dict="t2u_model",
-    )
-
-    # 4. take care of text decoder
-    hf_model.text_decoder = _convert_model(
-        original_model,
-        hf_model.text_decoder,
-        text_convert_list,
-        device,
-        unwanted_prefix="model.",
-        filter_state_dict=["model.text_decoder"],
-        exclude_state_dict="t2u_model",
-    )
-
-    # 5. take care of final proj
-    hf_model.lm_head = _convert_model(
-        original_model,
-        hf_model.lm_head,
-        [("final_proj.", "")],
-        device,
-        unwanted_prefix="model.",
-        filter_state_dict=["model.final_proj"],
-        exclude_state_dict="t2u_model",
-    )
-
-    # sanity check
-    print(find_tied_parameters(hf_model))
-
-    count_1 = param_count(hf_model)
-    count_2 = param_count(original_model)
-
-    print(f"HF MODEL:{count_1}, ORIGINAL_MODEL: {count_2}, diff:{count_1 - count_2}")
-    print(f"HF MODEL excluding embeddings:{hf_model.num_parameters(exclude_embeddings=True)}")
-
-    del original_model
-
-    hf_model.generation_config._from_model_config = False
-    hf_model.save_pretrained(save_dir)
-    hf_model.push_to_hub(repo_id=repo_id, create_pr=True)
-    hf_model = SeamlessM4TModel.from_pretrained(save_dir)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-
-    parser.add_argument(
-        "--model_type",
-        default="medium",
-        type=str,
-        help="Model type.",
-    )
-
-    parser.add_argument(
-        "--save_dir",
-        default="/home/ubuntu/weights",
-        type=str,
-        help="Path to the output PyTorch model.",
-    )
-
-    parser.add_argument(
-        "--repo_id",
-        default="facebook/hf-seamless-m4t-medium",
-        type=str,
-        help="Repo ID.",
-    )
-
-    args = parser.parse_args()
-
-    load_model(args.save_dir, args.model_type, args.repo_id)
diff --git a/src/transformers/models/seamless_m4t_v2/convert_fairseq2_to_hf.py b/src/transformers/models/seamless_m4t_v2/convert_fairseq2_to_hf.py
deleted file mode 100644
index c75b7c8139d3..000000000000
--- a/src/transformers/models/seamless_m4t_v2/convert_fairseq2_to_hf.py
+++ /dev/null
@@ -1,404 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Converting Meta SeamlessM4Tv2 checkpoints from seamless_communication to HF."""
-
-import argparse
-import os
-from pathlib import Path
-
-import torch
-from accelerate.utils.modeling import find_tied_parameters
-from seamless_communication.inference import Translator
-
-from transformers import (
-    SeamlessM4TFeatureExtractor,
-    SeamlessM4TProcessor,
-    SeamlessM4TTokenizer,
-    SeamlessM4Tv2Config,
-    SeamlessM4Tv2Model,
-)
-from transformers.utils import logging
-
-
-# fmt: off
-UNIT_SUPPORTED_LANGUAGES = ["__arb__", "__ben__", "__cat__", "__ces__", "__cmn__", "__cym__", "__dan__", "__deu__", "__eng__", "__est__", "__fin__", "__fra__", "__hin__", "__ind__", "__ita__", "__jpn__", "__kan__", "__kor__", "__mlt__", "__nld__", "__pes__", "__pol__", "__por__", "__ron__", "__rus__", "__slk__", "__spa__", "__swe__", "__swh__", "__tam__", "__tel__", "__tgl__", "__tha__", "__tur__", "__ukr__", "__urd__", "__uzn__", "__vie__", ]
-# fmt: on
-
-# fmt: off
-VOCODER_SUPPORTED_LANGUAGES = ["__arb__", "__ben__", "__cat__", "__ces__", "__cmn__", "__cym__", "__dan__", "__deu__", "__eng__", "__est__", "__fin__", "__fra__", "__hin__", "__ind__", "__ita__", "__jpn__", "__kor__", "__mlt__", "__nld__", "__pes__", "__pol__", "__por__", "__ron__", "__rus__", "__slk__", "__spa__", "__swe__", "__swh__", "__tel__", "__tgl__", "__tha__", "__tur__", "__ukr__", "__urd__", "__uzn__", "__vie__",]
-# fmt: on
-
-# fmt: off
-LARGE_SUPPORTED_LANGUAGES = ["afr","amh","arb","ary","arz","asm","azj","bel","ben","bos","bul","cat","ceb","ces","ckb","cmn","cmn_Hant","cym","dan","deu","ell","eng","est","eus","fin","fra","fuv","gaz","gle","glg","guj","heb","hin","hrv","hun","hye","ibo","ind","isl","ita","jav","jpn","kan","kat","kaz","khk","khm","kir","kor","lao","lit","lug","luo","lvs","mai","mal","mar","mkd","mlt","mni","mya","nld","nno","nob","npi","nya","ory","pan","pbt","pes","pol","por","ron","rus","sat","slk","slv","sna","snd","som","spa","srp","swe","swh","tam","tel","tgk","tgl","tha","tur","ukr","urd","uzn","vie","yor","yue","zlm","zul",]
-# fmt: on
-
-
-def assert_param_count(model_1, model_2):
-    count_1 = sum(p[1].numel() for p in model_1.named_parameters() if "final_proj" not in p[0])
-    count_2 = sum(p[1].numel() for p in model_2.named_parameters() if "final_proj" not in p[0])
-    assert count_1 == count_2, f"{model_1.__class__}: {count_1} != {model_2.__class__}: {count_2}"
-
-
-def param_count(model):
-    return sum(p[1].numel() for p in model.named_parameters() if "final_proj" not in p[0])
-
-
-def _grab_best_device(use_gpu=True):
-    if torch.cuda.device_count() > 0 and use_gpu:
-        device = "cuda"
-    else:
-        device = "cpu"
-    return torch.device(device)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-vocoder_convert_list = [
-    ("ups", "hifi_gan.upsampler"),
-    ("conv_pre", "hifi_gan.conv_pre"),
-    ("resblocks", "hifi_gan.resblocks"),
-    ("conv_post", "hifi_gan.conv_post"),
-    ("lang", "language_embedding"),
-    ("spkr", "speaker_embedding"),
-    ("dict.", "unit_embedding."),
-    ("dur_predictor.conv1.0", "dur_predictor.conv1"),
-    ("dur_predictor.conv2.0", "dur_predictor.conv2"),
-]
-
-# order is important
-wav2vec_convert_list = [
-    ("speech_encoder_frontend.model_dim_proj", "feature_projection.projection"),
-    ("speech_encoder_frontend.post_extract_layer_norm", "feature_projection.layer_norm"),
-    ("speech_encoder_frontend.pos_encoder.conv", "encoder.pos_conv_embed.conv"),
-    ("speech_encoder.inner.layers", "encoder.layers"),
-    ("speech_encoder.inner_layer_norm", "encoder.layer_norm"),
-    ("speech_encoder.adaptor_layers", "adapter.layers"),
-    ("inner_proj", "intermediate_dense"),
-    ("self_attn.output_proj", "self_attn.linear_out"),
-    ("output_proj", "output_dense"),
-    ("self_attn.k_proj", "self_attn.linear_k"),
-    ("self_attn.v_proj", "self_attn.linear_v"),
-    ("self_attn.q_proj", "self_attn.linear_q"),
-    ("self_attn.sdpa.u_bias", "self_attn.pos_bias_u"),
-    ("self_attn.sdpa.v_bias", "self_attn.pos_bias_v"),
-    ("self_attn.sdpa.rel_k_embed", "self_attn.distance_embedding"),
-    ("self_attn.sdpa.r_proj", "self_attn.linear_pos"),
-    ("conv.pointwise_conv1", "conv_module.pointwise_conv1"),
-    ("conv.pointwise_conv2", "conv_module.pointwise_conv2"),
-    ("conv.depthwise_conv", "conv_module.depthwise_conv"),
-    ("conv.batch_norm", "conv_module.batch_norm"),
-    ("conv.layer_norm", "conv_module.depthwise_layer_norm"),
-    ("conv_layer_norm", "conv_module.layer_norm"),
-    ("speech_encoder.proj1", "intermediate_ffn.intermediate_dense"),
-    ("speech_encoder.proj2", "intermediate_ffn.output_dense"),
-    ("speech_encoder.layer_norm", "inner_layer_norm"),
-]
-
-t2u_convert_list = [
-    ("t2u_model.final_proj", "lm_head"),
-    ("t2u_model.", "model."),
-    ("encoder_decoder_attn_layer_norm", "cross_attention_layer_norm"),
-    ("encoder_decoder_attn", "cross_attention"),
-    ("linear_k", "k_proj"),
-    ("linear_v", "v_proj"),
-    ("linear_q", "q_proj"),
-    ("ffn.inner_proj", "ffn.fc1"),
-    ("ffn.output_proj", "ffn.fc2"),
-    ("output_proj", "out_proj"),
-    ("decoder_frontend.embed_char", "decoder.embed_char"),
-    ("decoder_frontend.pos_emb_alpha_char", "decoder.pos_emb_alpha_char"),
-    ("decoder_frontend.embed", "decoder.embed_tokens"),
-    ("decoder_frontend.pos_emb_alpha", "decoder.pos_emb_alpha"),
-    ("conv1d.conv", "conv"),
-    ("conv1d_layer_norm", "conv_layer_norm"),
-    ("decoder_frontend.variance_adaptor", "decoder"),
-    ("duration_predictor.conv1.0", "duration_predictor.conv1"),
-    ("duration_predictor.conv2.0", "duration_predictor.conv2"),
-]
-
-text_convert_list = [
-    ("text_encoder.", ""),
-    ("text_decoder.", ""),
-    ("text_encoder_frontend.embed", "embed_tokens"),
-    ("text_decoder_frontend.embed", "embed_tokens"),
-    ("encoder_decoder_attn_layer_norm", "cross_attention_layer_norm"),
-    ("encoder_decoder_attn", "cross_attention"),
-    ("linear_k", "k_proj"),
-    ("linear_v", "v_proj"),
-    ("linear_q", "q_proj"),
-    ("ffn.inner_proj", "ffn.fc1"),
-    ("ffn.output_proj", "ffn.fc2"),
-    ("output_proj", "out_proj"),
-    ("final_proj", "lm_head"),
-]
-
-CUR_PATH = os.path.dirname(os.path.abspath(__file__))
-default_cache_dir = os.path.join(os.path.expanduser("~"), ".cache")
-CACHE_DIR = os.path.join(os.getenv("XDG_CACHE_HOME", default_cache_dir), "huggingface", "hub")
-
-
-def _load_hf_config():
-    return SeamlessM4Tv2Config()
-
-
-def _convert_model(
-    original_model,
-    hf_model,
-    convert_list,
-    device,
-    unwanted_prefix="model.",
-    filter_state_dict="speech",
-    exclude_state_dict=None,
-):
-    state_dict = original_model.state_dict()
-
-    # filter func
-    if isinstance(filter_state_dict, str):
-
-        def filter_func(x):
-            return filter_state_dict in x[0]
-
-    else:
-
-        def filter_func(item):
-            if exclude_state_dict is not None and exclude_state_dict in item[0]:
-                return False
-            for filter_el in filter_state_dict:
-                if filter_el in item[0]:
-                    return True
-
-            return False
-
-    state_dict = dict(filter(filter_func, state_dict.items()))
-
-    for k, v in list(state_dict.items()):
-        new_k = k[len(unwanted_prefix) :]
-        for old_layer_name, new_layer_name in convert_list:
-            if old_layer_name in new_k:
-                new_k = new_k.replace(old_layer_name, new_layer_name)
-
-        # must do it by hand
-        if ".layer_norm" in new_k and new_k.split(".layer_norm")[0][-1].isnumeric():
-            new_k = new_k.replace("layer_norm", "final_layer_norm")
-
-        state_dict[new_k] = state_dict.pop(k)
-
-    extra_keys = set(state_dict.keys()) - set(hf_model.state_dict().keys())
-    extra_keys = set(extra_keys)
-    missing_keys = set(hf_model.state_dict().keys()) - set(state_dict.keys())
-    missing_keys = set({k for k in missing_keys if "final_logits_bias" not in k})
-    if len(extra_keys) != 0:
-        raise ValueError(f"extra keys found: {extra_keys}")
-    if len(missing_keys) != 0:
-        raise ValueError(f"missing keys: {missing_keys}")
-    hf_model.load_state_dict(state_dict, strict=False)
-    n_params = param_count(hf_model)
-
-    logger.info(f"model loaded: {round(n_params / 1e6, 1)}M params")
-
-    hf_model.eval()
-    hf_model.to(device)
-    del state_dict
-
-    return hf_model
-
-
-def load_model(save_dir, model_type, repo_id):
-    """
-    Meta SeamlessM4Tv2 is made of 8 main components:
-    - speech_encoder (#1) and speech_encoder_frontend (#2)
-    - t2u_model (#3)
-    - text_encoder (#4) and text_encoder_frontend (#5)
-    - text_decoder (#6) [and text_decoder_frontend (#5) = equals to text_encoder_frontend]
-    - final_proj (#7)
-    - vocoder (#8)
-    """
-    device = _grab_best_device()
-    name = "seamlessM4T_v2_large"
-
-    original_model = Translator(name, "vocoder_v2", device, dtype=torch.float32)
-
-    ######### TOKENIZER
-
-    langs = LARGE_SUPPORTED_LANGUAGES
-    langs = [f"__{lang}__" for lang in langs]
-    vocab_file = os.path.join(os.path.expanduser("~"), "tokenizer", model_type, "tokenizer.model")
-
-    save_dir = os.path.join(save_dir, name)
-    Path(save_dir).mkdir(exist_ok=True)
-
-    tokenizer = SeamlessM4TTokenizer(vocab_file, additional_special_tokens=langs)
-
-    sanity_check_lang_id = tokenizer.convert_tokens_to_ids("__fra__")
-
-    tokenizer.save_pretrained(save_dir)
-    tokenizer = SeamlessM4TTokenizer.from_pretrained(save_dir)
-
-    if sanity_check_lang_id != tokenizer.convert_tokens_to_ids("__fra__"):
-        raise ValueError(
-            f"Error in tokenizer saving/loading - __fra__ lang id is not coherent: {sanity_check_lang_id} vs {tokenizer.convert_tokens_to_ids('__fra__')}"
-        )
-
-    ####### get language to ids dict
-    text_decoder_lang_code_to_id = {lang.replace("__", ""): tokenizer.convert_tokens_to_ids(lang) for lang in langs}
-    # offset: vocoder unit vocab size + 5 (for EOS/PAD/BOS/UNK/MSK) + len(supported_languages)
-    t2u_lang_code_to_id = {
-        code.replace("__", ""): i + 10005 + len(UNIT_SUPPORTED_LANGUAGES)
-        for i, code in enumerate(UNIT_SUPPORTED_LANGUAGES)
-    }
-    vocoder_lang_code_to_id = {code.replace("__", ""): i for i, code in enumerate(VOCODER_SUPPORTED_LANGUAGES)}
-
-    ######### FE
-
-    fe = SeamlessM4TFeatureExtractor(language_code=langs)
-
-    fe.save_pretrained(save_dir)
-    fe = SeamlessM4TFeatureExtractor.from_pretrained(save_dir)
-
-    processor = SeamlessM4TProcessor(feature_extractor=fe, tokenizer=tokenizer)
-    processor.save_pretrained(save_dir)
-    processor.push_to_hub(repo_id=repo_id, create_pr=True)
-
-    processor = SeamlessM4TProcessor.from_pretrained(save_dir)
-
-    ######## Model
-
-    # init config
-    hf_config = _load_hf_config()
-
-    ######## get id_to_text and char_to_id from original model tokenizers
-    id_to_text = {i: original_model.text_tokenizer.model.index_to_token(i) for i in range(hf_config.vocab_size)}
-    char_to_id = {
-        original_model.model.t2u_model.decoder_frontend.char_tokenizer.model.index_to_token(i): i for i in range(10904)
-    }
-
-    # init model
-    hf_model = SeamlessM4Tv2Model(hf_config)
-
-    hf_model.generation_config.__setattr__("text_decoder_lang_to_code_id", text_decoder_lang_code_to_id)
-    hf_model.generation_config.__setattr__("t2u_lang_code_to_id", t2u_lang_code_to_id)
-    hf_model.generation_config.__setattr__("vocoder_lang_code_to_id", vocoder_lang_code_to_id)
-    hf_model.generation_config.__setattr__("id_to_text", id_to_text)
-    hf_model.generation_config.__setattr__("char_to_id", char_to_id)
-
-    # -1. take care of vocoder
-    # similarly to speech T5 must apply and remove weight norm
-    hf_model.vocoder.apply_weight_norm()
-    hf_model.vocoder = _convert_model(
-        original_model,
-        hf_model.vocoder,
-        vocoder_convert_list,
-        device,
-        unwanted_prefix="vocoder.code_generator.",
-        filter_state_dict="vocoder",
-    )
-    hf_model.vocoder.remove_weight_norm()
-
-    # 1. take care of speech encoder
-    wav2vec = hf_model.speech_encoder
-    hf_model.speech_encoder = _convert_model(
-        original_model, wav2vec, wav2vec_convert_list, device, unwanted_prefix="model.", filter_state_dict="speech"
-    )
-
-    # 2. take care of t2u
-
-    hf_model.t2u_model = _convert_model(
-        original_model,
-        hf_model.t2u_model,
-        t2u_convert_list,
-        device,
-        unwanted_prefix="model.",
-        filter_state_dict="t2u_model",
-    )
-
-    # 3. take care of text encoder
-    hf_model.text_encoder = _convert_model(
-        original_model,
-        hf_model.text_encoder,
-        text_convert_list,
-        device,
-        unwanted_prefix="model.",
-        filter_state_dict=["model.text_encoder"],
-        exclude_state_dict="t2u_model",
-    )
-
-    # 4. take care of text decoder
-    hf_model.text_decoder = _convert_model(
-        original_model,
-        hf_model.text_decoder,
-        text_convert_list,
-        device,
-        unwanted_prefix="model.",
-        filter_state_dict=["model.text_decoder"],
-        exclude_state_dict="t2u_model",
-    )
-
-    # 5. take care of final proj
-    hf_model.lm_head = _convert_model(
-        original_model,
-        hf_model.lm_head,
-        [("final_proj.", "")],
-        device,
-        unwanted_prefix="model.",
-        filter_state_dict=["model.final_proj"],
-        exclude_state_dict="t2u_model",
-    )
-
-    # sanity check
-    print(find_tied_parameters(hf_model))
-
-    count_1 = param_count(hf_model)
-    count_2 = param_count(original_model)
-
-    print(f"HF MODEL:{count_1}, ORIGINAL_MODEL: {count_2}, diff:{count_1 - count_2}")
-    print(f"HF MODEL excluding embeddings:{hf_model.num_parameters(exclude_embeddings=True)}")
-
-    del original_model
-
-    hf_model.generation_config._from_model_config = False
-    hf_model.save_pretrained(save_dir)
-    hf_model.push_to_hub(repo_id=repo_id, create_pr=True)
-    hf_model = SeamlessM4Tv2Model.from_pretrained(save_dir)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-
-    parser.add_argument(
-        "--model_type",
-        default="large",
-        type=str,
-        help="Model type.",
-    )
-
-    parser.add_argument(
-        "--save_dir",
-        default="/home/ubuntu/weights_v2",
-        type=str,
-        help="Path to the output PyTorch model.",
-    )
-
-    parser.add_argument(
-        "--repo_id",
-        default="facebook/seamless-m4t-v2-large",
-        type=str,
-        help="Repo ID.",
-    )
-
-    args = parser.parse_args()
-
-    load_model(args.save_dir, args.model_type, args.repo_id)
diff --git a/src/transformers/models/segformer/convert_segformer_original_to_pytorch.py b/src/transformers/models/segformer/convert_segformer_original_to_pytorch.py
deleted file mode 100644
index 3bbc86e433b0..000000000000
--- a/src/transformers/models/segformer/convert_segformer_original_to_pytorch.py
+++ /dev/null
@@ -1,387 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert SegFormer checkpoints."""
-
-import argparse
-import json
-from collections import OrderedDict
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    SegformerConfig,
-    SegformerForImageClassification,
-    SegformerForSemanticSegmentation,
-    SegformerImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def rename_keys(state_dict, encoder_only=False):
-    new_state_dict = OrderedDict()
-    for key, value in state_dict.items():
-        if encoder_only and not key.startswith("head"):
-            key = "segformer.encoder." + key
-        if key.startswith("backbone"):
-            key = key.replace("backbone", "segformer.encoder")
-        if "patch_embed" in key:
-            # replace for example patch_embed1 by patch_embeddings.0
-            idx = key[key.find("patch_embed") + len("patch_embed")]
-            key = key.replace(f"patch_embed{idx}", f"patch_embeddings.{int(idx) - 1}")
-        if "norm" in key:
-            key = key.replace("norm", "layer_norm")
-        if "segformer.encoder.layer_norm" in key:
-            # replace for example layer_norm1 by layer_norm.0
-            idx = key[key.find("segformer.encoder.layer_norm") + len("segformer.encoder.layer_norm")]
-            key = key.replace(f"layer_norm{idx}", f"layer_norm.{int(idx) - 1}")
-        if "layer_norm1" in key:
-            key = key.replace("layer_norm1", "layer_norm_1")
-        if "layer_norm2" in key:
-            key = key.replace("layer_norm2", "layer_norm_2")
-        if "block" in key:
-            # replace for example block1 by block.0
-            idx = key[key.find("block") + len("block")]
-            key = key.replace(f"block{idx}", f"block.{int(idx) - 1}")
-        if "attn.q" in key:
-            key = key.replace("attn.q", "attention.self.query")
-        if "attn.proj" in key:
-            key = key.replace("attn.proj", "attention.output.dense")
-        if "attn" in key:
-            key = key.replace("attn", "attention.self")
-        if "fc1" in key:
-            key = key.replace("fc1", "dense1")
-        if "fc2" in key:
-            key = key.replace("fc2", "dense2")
-        if "linear_pred" in key:
-            key = key.replace("linear_pred", "classifier")
-        if "linear_fuse" in key:
-            key = key.replace("linear_fuse.conv", "linear_fuse")
-            key = key.replace("linear_fuse.bn", "batch_norm")
-        if "linear_c" in key:
-            # replace for example linear_c4 by linear_c.3
-            idx = key[key.find("linear_c") + len("linear_c")]
-            key = key.replace(f"linear_c{idx}", f"linear_c.{int(idx) - 1}")
-        if key.startswith("head"):
-            key = key.replace("head", "classifier")
-        new_state_dict[key] = value
-
-    return new_state_dict
-
-
-def read_in_k_v(state_dict, config):
-    # for each of the encoder blocks:
-    for i in range(config.num_encoder_blocks):
-        for j in range(config.depths[i]):
-            # read in weights + bias of keys and values (which is a single matrix in the original implementation)
-            kv_weight = state_dict.pop(f"segformer.encoder.block.{i}.{j}.attention.self.kv.weight")
-            kv_bias = state_dict.pop(f"segformer.encoder.block.{i}.{j}.attention.self.kv.bias")
-            # next, add keys and values (in that order) to the state dict
-            state_dict[f"segformer.encoder.block.{i}.{j}.attention.self.key.weight"] = kv_weight[
-                : config.hidden_sizes[i], :
-            ]
-            state_dict[f"segformer.encoder.block.{i}.{j}.attention.self.key.bias"] = kv_bias[: config.hidden_sizes[i]]
-            state_dict[f"segformer.encoder.block.{i}.{j}.attention.self.value.weight"] = kv_weight[
-                config.hidden_sizes[i] :, :
-            ]
-            state_dict[f"segformer.encoder.block.{i}.{j}.attention.self.value.bias"] = kv_bias[
-                config.hidden_sizes[i] :
-            ]
-
-
-# We will verify our results on a COCO image
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-
-    return image
-
-
-@torch.no_grad()
-def convert_segformer_checkpoint(model_name, checkpoint_path, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our SegFormer structure.
-    """
-
-    # load default SegFormer configuration
-    config = SegformerConfig()
-    encoder_only = False
-
-    # set attributes based on model_name
-    repo_id = "huggingface/label-files"
-    if "segformer" in model_name:
-        size = model_name[len("segformer.") : len("segformer.") + 2]
-        if "ade" in model_name:
-            config.num_labels = 150
-            filename = "ade20k-id2label.json"
-            expected_shape = (1, 150, 128, 128)
-        elif "city" in model_name:
-            config.num_labels = 19
-            filename = "cityscapes-id2label.json"
-            expected_shape = (1, 19, 128, 128)
-        else:
-            raise ValueError(f"Model {model_name} not supported")
-    elif "mit" in model_name:
-        encoder_only = True
-        size = model_name[4:6]
-        config.num_labels = 1000
-        filename = "imagenet-1k-id2label.json"
-        expected_shape = (1, 1000)
-    else:
-        raise ValueError(f"Model {model_name} not supported")
-
-    # set config attributes
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-    if size == "b0":
-        pass
-    elif size == "b1":
-        config.hidden_sizes = [64, 128, 320, 512]
-        config.decoder_hidden_size = 256
-    elif size == "b2":
-        config.hidden_sizes = [64, 128, 320, 512]
-        config.decoder_hidden_size = 768
-        config.depths = [3, 4, 6, 3]
-    elif size == "b3":
-        config.hidden_sizes = [64, 128, 320, 512]
-        config.decoder_hidden_size = 768
-        config.depths = [3, 4, 18, 3]
-    elif size == "b4":
-        config.hidden_sizes = [64, 128, 320, 512]
-        config.decoder_hidden_size = 768
-        config.depths = [3, 8, 27, 3]
-    elif size == "b5":
-        config.hidden_sizes = [64, 128, 320, 512]
-        config.decoder_hidden_size = 768
-        config.depths = [3, 6, 40, 3]
-    else:
-        raise ValueError(f"Size {size} not supported")
-
-    # load image processor (only resize + normalize)
-    image_processor = SegformerImageProcessor(
-        image_scale=(512, 512), keep_ratio=False, align=False, do_random_crop=False
-    )
-
-    # prepare image
-    image = prepare_img()
-    pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
-
-    logger.info(f"Converting model {model_name}...")
-
-    # load original state dict
-    if encoder_only:
-        state_dict = torch.load(checkpoint_path, map_location=torch.device("cpu"))
-    else:
-        state_dict = torch.load(checkpoint_path, map_location=torch.device("cpu"))["state_dict"]
-
-    # rename keys
-    state_dict = rename_keys(state_dict, encoder_only=encoder_only)
-    if not encoder_only:
-        del state_dict["decode_head.conv_seg.weight"]
-        del state_dict["decode_head.conv_seg.bias"]
-
-    # key and value matrices need special treatment
-    read_in_k_v(state_dict, config)
-
-    # create HuggingFace model and load state dict
-    if encoder_only:
-        config.reshape_last_stage = False
-        model = SegformerForImageClassification(config)
-    else:
-        model = SegformerForSemanticSegmentation(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # forward pass
-    outputs = model(pixel_values)
-    logits = outputs.logits
-
-    # set expected_slice based on model name
-    # ADE20k checkpoints
-    if model_name == "segformer.b0.512x512.ade.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-4.6310, -5.5232, -6.2356], [-5.1921, -6.1444, -6.5996], [-5.4424, -6.2790, -6.7574]],
-                [[-12.1391, -13.3122, -13.9554], [-12.8732, -13.9352, -14.3563], [-12.9438, -13.8226, -14.2513]],
-                [[-12.5134, -13.4686, -14.4915], [-12.8669, -14.4343, -14.7758], [-13.2523, -14.5819, -15.0694]],
-            ]
-        )
-    elif model_name == "segformer.b1.512x512.ade.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-7.5820, -8.7231, -8.3215], [-8.0600, -10.3529, -10.0304], [-7.5208, -9.4103, -9.6239]],
-                [[-12.6918, -13.8994, -13.7137], [-13.3196, -15.7523, -15.4789], [-12.9343, -14.8757, -14.9689]],
-                [[-11.1911, -11.9421, -11.3243], [-11.3342, -13.6839, -13.3581], [-10.3909, -12.1832, -12.4858]],
-            ]
-        )
-    elif model_name == "segformer.b2.512x512.ade.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-11.8173, -14.3850, -16.3128], [-14.5648, -16.5804, -18.6568], [-14.7223, -15.7387, -18.4218]],
-                [[-15.7290, -17.9171, -19.4423], [-18.3105, -19.9448, -21.4661], [-17.9296, -18.6497, -20.7910]],
-                [[-15.0783, -17.0336, -18.2789], [-16.8771, -18.6870, -20.1612], [-16.2454, -17.1426, -19.5055]],
-            ]
-        )
-    elif model_name == "segformer.b3.512x512.ade.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-9.0878, -10.2081, -10.1891], [-9.3144, -10.7941, -10.9843], [-9.2294, -10.3855, -10.5704]],
-                [[-12.2316, -13.9068, -13.6102], [-12.9161, -14.3702, -14.3235], [-12.5233, -13.7174, -13.7932]],
-                [[-14.6275, -15.2490, -14.9727], [-14.3400, -15.9687, -16.2827], [-14.1484, -15.4033, -15.8937]],
-            ]
-        )
-    elif model_name == "segformer.b4.512x512.ade.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-12.3144, -13.2447, -14.0802], [-13.3614, -14.5816, -15.6117], [-13.3340, -14.4433, -16.2219]],
-                [[-19.2781, -20.4128, -20.7506], [-20.6153, -21.6566, -22.0998], [-19.9800, -21.0430, -22.1494]],
-                [[-18.8739, -19.7804, -21.1834], [-20.1233, -21.6765, -23.2944], [-20.0315, -21.2641, -23.6944]],
-            ]
-        )
-    elif model_name == "segformer.b5.640x640.ade.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-9.5524, -12.0835, -11.7348], [-10.5229, -13.6446, -14.5662], [-9.5842, -12.8851, -13.9414]],
-                [[-15.3432, -17.5323, -17.0818], [-16.3330, -18.9255, -19.2101], [-15.1340, -17.7848, -18.3971]],
-                [[-12.6072, -14.9486, -14.6631], [-13.7629, -17.0907, -17.7745], [-12.7899, -16.1695, -17.1671]],
-            ]
-        )
-    # Cityscapes checkpoints
-    elif model_name == "segformer.b0.1024x1024.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-11.9295, -13.4057, -14.8106], [-13.3431, -14.8179, -15.3781], [-14.2836, -15.5942, -16.1588]],
-                [[-11.4906, -12.8067, -13.6564], [-13.1189, -14.0500, -14.1543], [-13.8748, -14.5136, -14.8789]],
-                [[0.5374, 0.1067, -0.4742], [0.1141, -0.2255, -0.7099], [-0.3000, -0.5924, -1.3105]],
-            ]
-        )
-    elif model_name == "segformer.b0.512x1024.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-7.8217, -9.8767, -10.1717], [-9.4438, -10.9058, -11.4047], [-9.7939, -12.3495, -12.1079]],
-                [[-7.1514, -9.5336, -10.0860], [-9.7776, -11.6822, -11.8439], [-10.1411, -12.7655, -12.8972]],
-                [[0.3021, 0.0805, -0.2310], [-0.0328, -0.1605, -0.2714], [-0.1408, -0.5477, -0.6976]],
-            ]
-        )
-    elif model_name == "segformer.b0.640x1280.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [
-                    [-1.1372e01, -1.2787e01, -1.3477e01],
-                    [-1.2536e01, -1.4194e01, -1.4409e01],
-                    [-1.3217e01, -1.4888e01, -1.5327e01],
-                ],
-                [
-                    [-1.4791e01, -1.7122e01, -1.8277e01],
-                    [-1.7163e01, -1.9192e01, -1.9533e01],
-                    [-1.7897e01, -1.9991e01, -2.0315e01],
-                ],
-                [
-                    [7.6723e-01, 4.1921e-01, -7.7878e-02],
-                    [4.7772e-01, 9.5557e-03, -2.8082e-01],
-                    [3.6032e-01, -2.4826e-01, -5.1168e-01],
-                ],
-            ]
-        )
-    elif model_name == "segformer.b0.768x768.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-9.4959, -11.3087, -11.7479], [-11.0025, -12.6540, -12.3319], [-11.4064, -13.0487, -12.9905]],
-                [[-9.8905, -11.3084, -12.0854], [-11.1726, -12.7698, -12.9583], [-11.5985, -13.3278, -14.1774]],
-                [[0.2213, 0.0192, -0.2466], [-0.1731, -0.4213, -0.4874], [-0.3126, -0.6541, -1.1389]],
-            ]
-        )
-    elif model_name == "segformer.b1.1024x1024.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-13.5748, -13.9111, -12.6500], [-14.3500, -15.3683, -14.2328], [-14.7532, -16.0424, -15.6087]],
-                [[-17.1651, -15.8725, -12.9653], [-17.2580, -17.3718, -14.8223], [-16.6058, -16.8783, -16.7452]],
-                [[-3.6456, -3.0209, -1.4203], [-3.0797, -3.1959, -2.0000], [-1.8757, -1.9217, -1.6997]],
-            ]
-        )
-    elif model_name == "segformer.b2.1024x1024.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-16.0976, -16.4856, -17.3962], [-16.6234, -19.0342, -19.7685], [-16.0900, -18.0661, -19.1180]],
-                [[-18.4750, -18.8488, -19.5074], [-19.4030, -22.1570, -22.5977], [-19.1191, -20.8486, -22.3783]],
-                [[-4.5178, -5.5037, -6.5109], [-5.0884, -7.2174, -8.0334], [-4.4156, -5.8117, -7.2970]],
-            ]
-        )
-    elif model_name == "segformer.b3.1024x1024.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-14.2081, -14.4732, -14.1977], [-14.5867, -16.4423, -16.6356], [-13.4441, -14.9685, -16.8696]],
-                [[-14.4576, -14.7073, -15.0451], [-15.0816, -17.6237, -17.9873], [-14.4213, -16.0199, -18.5992]],
-                [[-4.7349, -4.9588, -5.0966], [-4.3210, -6.9325, -7.2591], [-3.4312, -4.7484, -7.1917]],
-            ]
-        )
-    elif model_name == "segformer.b4.1024x1024.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-11.7737, -11.9526, -11.3273], [-13.6692, -14.4574, -13.8878], [-13.8937, -14.6924, -15.9345]],
-                [[-14.6706, -14.5330, -14.1306], [-16.1502, -16.8180, -16.4269], [-16.8338, -17.8939, -20.1746]],
-                [[1.0491, 0.8289, 1.0310], [1.1044, 0.5219, 0.8055], [1.0899, 0.6926, 0.5590]],
-            ]
-        )
-    elif model_name == "segformer.b5.1024x1024.city.160k":
-        expected_slice = torch.tensor(
-            [
-                [[-12.5641, -13.4777, -13.0684], [-13.9587, -15.8983, -16.6557], [-13.3109, -15.7350, -16.3141]],
-                [[-14.7074, -15.4352, -14.5944], [-16.6353, -18.1663, -18.6120], [-15.1702, -18.0329, -18.1547]],
-                [[-1.7990, -2.0951, -1.7784], [-2.6397, -3.8245, -3.9686], [-1.5264, -2.8126, -2.9316]],
-            ]
-        )
-    else:
-        predicted_class_idx = logits.argmax(-1).item()
-        print("Predicted class:", model.config.id2label[predicted_class_idx])
-
-    # verify logits
-    if not encoder_only:
-        assert logits.shape == expected_shape
-        assert torch.allclose(logits[0, :3, :3, :3], expected_slice, atol=1e-2)
-
-    # finally, save model and image processor
-    logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--model_name",
-        default="segformer.b0.512x512.ade.160k",
-        type=str,
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--checkpoint_path", default=None, type=str, help="Path to the original PyTorch checkpoint (.pth file)."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_segformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/seggpt/convert_seggpt_to_hf.py b/src/transformers/models/seggpt/convert_seggpt_to_hf.py
deleted file mode 100644
index d67daeab93d8..000000000000
--- a/src/transformers/models/seggpt/convert_seggpt_to_hf.py
+++ /dev/null
@@ -1,221 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert SegGPT checkpoints from the original repository.
-
-URL: https://github.com/baaivision/Painter/tree/main/SegGPT
-"""
-
-import argparse
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import SegGptConfig, SegGptForImageSegmentation, SegGptImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-
-    # fmt: off
-
-    # rename embedding and its parameters
-    rename_keys.append(("patch_embed.proj.weight", "model.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("patch_embed.proj.bias", "model.embeddings.patch_embeddings.projection.bias"))
-    rename_keys.append(("mask_token", "model.embeddings.mask_token"))
-    rename_keys.append(("segment_token_x", "model.embeddings.segment_token_input"))
-    rename_keys.append(("segment_token_y", "model.embeddings.segment_token_prompt"))
-    rename_keys.append(("type_token_cls", "model.embeddings.type_token_semantic"))
-    rename_keys.append(("type_token_ins", "model.embeddings.type_token_instance"))
-    rename_keys.append(("pos_embed", "model.embeddings.position_embeddings"))
-
-    # rename decoder and other
-    rename_keys.append(("norm.weight", "model.encoder.layernorm.weight"))
-    rename_keys.append(("norm.bias", "model.encoder.layernorm.bias"))
-    rename_keys.append(("decoder_embed.weight", "decoder.decoder_embed.weight"))
-    rename_keys.append(("decoder_embed.bias", "decoder.decoder_embed.bias"))
-    rename_keys.append(("decoder_pred.0.weight", "decoder.decoder_pred.conv.weight"))
-    rename_keys.append(("decoder_pred.0.bias", "decoder.decoder_pred.conv.bias"))
-    rename_keys.append(("decoder_pred.1.weight", "decoder.decoder_pred.layernorm.weight"))
-    rename_keys.append(("decoder_pred.1.bias", "decoder.decoder_pred.layernorm.bias"))
-    rename_keys.append(("decoder_pred.3.weight", "decoder.decoder_pred.head.weight"))
-    rename_keys.append(("decoder_pred.3.bias", "decoder.decoder_pred.head.bias"))
-
-    # rename blocks
-    for i in range(config.num_hidden_layers):
-        rename_keys.append((f"blocks.{i}.attn.qkv.weight", f"model.encoder.layers.{i}.attention.qkv.weight"))
-        rename_keys.append((f"blocks.{i}.attn.qkv.bias", f"model.encoder.layers.{i}.attention.qkv.bias"))
-        rename_keys.append((f"blocks.{i}.attn.proj.weight", f"model.encoder.layers.{i}.attention.proj.weight"))
-        rename_keys.append((f"blocks.{i}.attn.proj.bias", f"model.encoder.layers.{i}.attention.proj.bias"))
-        rename_keys.append((f"blocks.{i}.attn.rel_pos_h", f"model.encoder.layers.{i}.attention.rel_pos_h"))
-        rename_keys.append((f"blocks.{i}.attn.rel_pos_w", f"model.encoder.layers.{i}.attention.rel_pos_w"))
-
-        rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"model.encoder.layers.{i}.mlp.lin1.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"model.encoder.layers.{i}.mlp.lin1.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"model.encoder.layers.{i}.mlp.lin2.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"model.encoder.layers.{i}.mlp.lin2.bias"))
-
-        rename_keys.append((f"blocks.{i}.norm1.weight", f"model.encoder.layers.{i}.layernorm_before.weight"))
-        rename_keys.append((f"blocks.{i}.norm1.bias", f"model.encoder.layers.{i}.layernorm_before.bias"))
-        rename_keys.append((f"blocks.{i}.norm2.weight", f"model.encoder.layers.{i}.layernorm_after.weight"))
-        rename_keys.append((f"blocks.{i}.norm2.bias", f"model.encoder.layers.{i}.layernorm_after.bias"))
-
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on spongebob images
-def prepare_input():
-    image_input_url = (
-        "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_2.jpg"
-    )
-    image_prompt_url = (
-        "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1.jpg"
-    )
-    mask_prompt_url = (
-        "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1_target.png"
-    )
-
-    image_input = Image.open(requests.get(image_input_url, stream=True).raw)
-    image_prompt = Image.open(requests.get(image_prompt_url, stream=True).raw)
-    mask_prompt = Image.open(requests.get(mask_prompt_url, stream=True).raw)
-
-    return image_input, image_prompt, mask_prompt
-
-
-@torch.no_grad()
-def convert_seggpt_checkpoint(args):
-    model_name = args.model_name
-    pytorch_dump_folder_path = args.pytorch_dump_folder_path
-    verify_logits = args.verify_logits
-    push_to_hub = args.push_to_hub
-
-    # Define default GroundingDINO configuation
-    config = SegGptConfig()
-
-    # Load original checkpoint
-    checkpoint_url = "https://huggingface.co/BAAI/SegGpt/blob/main/seggpt_vit_large.pth"
-    original_state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["model"]
-
-    # # Rename keys
-    new_state_dict = original_state_dict.copy()
-    rename_keys = create_rename_keys(config)
-
-    for src, dest in rename_keys:
-        rename_key(new_state_dict, src, dest)
-
-    # Load HF model
-    model = SegGptForImageSegmentation(config)
-    model.eval()
-    missing_keys, unexpected_keys = model.load_state_dict(new_state_dict, strict=False)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-
-    input_img, prompt_img, prompt_mask = prepare_input()
-    image_processor = SegGptImageProcessor()
-    inputs = image_processor(images=input_img, prompt_images=prompt_img, prompt_masks=prompt_mask, return_tensors="pt")
-
-    expected_prompt_pixel_values = torch.tensor(
-        [
-            [[-0.6965, -0.6965, -0.6965], [-0.6965, -0.6965, -0.6965], [-0.6965, -0.6965, -0.6965]],
-            [[1.6583, 1.6583, 1.6583], [1.6583, 1.6583, 1.6583], [1.6583, 1.6583, 1.6583]],
-            [[2.3088, 2.3088, 2.3088], [2.3088, 2.3088, 2.3088], [2.3088, 2.3088, 2.3088]],
-        ]
-    )
-
-    expected_pixel_values = torch.tensor(
-        [
-            [[1.6324, 1.6153, 1.5810], [1.6153, 1.5982, 1.5810], [1.5810, 1.5639, 1.5639]],
-            [[1.2731, 1.2556, 1.2206], [1.2556, 1.2381, 1.2031], [1.2206, 1.2031, 1.1681]],
-            [[1.6465, 1.6465, 1.6465], [1.6465, 1.6465, 1.6465], [1.6291, 1.6291, 1.6291]],
-        ]
-    )
-
-    expected_prompt_masks = torch.tensor(
-        [
-            [[-2.1179, -2.1179, -2.1179], [-2.1179, -2.1179, -2.1179], [-2.1179, -2.1179, -2.1179]],
-            [[-2.0357, -2.0357, -2.0357], [-2.0357, -2.0357, -2.0357], [-2.0357, -2.0357, -2.0357]],
-            [[-1.8044, -1.8044, -1.8044], [-1.8044, -1.8044, -1.8044], [-1.8044, -1.8044, -1.8044]],
-        ]
-    )
-
-    assert torch.allclose(inputs.pixel_values[0, :, :3, :3], expected_pixel_values, atol=1e-4)
-    assert torch.allclose(inputs.prompt_pixel_values[0, :, :3, :3], expected_prompt_pixel_values, atol=1e-4)
-    assert torch.allclose(inputs.prompt_masks[0, :, :3, :3], expected_prompt_masks, atol=1e-4)
-
-    torch.manual_seed(2)
-    outputs = model(**inputs)
-    print(outputs)
-
-    if verify_logits:
-        expected_output = torch.tensor(
-            [
-                [[-2.1208, -2.1190, -2.1198], [-2.1237, -2.1228, -2.1227], [-2.1232, -2.1226, -2.1228]],
-                [[-2.0405, -2.0396, -2.0403], [-2.0434, -2.0434, -2.0433], [-2.0428, -2.0432, -2.0434]],
-                [[-1.8102, -1.8088, -1.8099], [-1.8131, -1.8126, -1.8129], [-1.8130, -1.8128, -1.8131]],
-            ]
-        )
-        assert torch.allclose(outputs.pred_masks[0, :, :3, :3], expected_output, atol=1e-4)
-        print("Looks good!")
-    else:
-        print("Converted without verifying logits")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor for {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and processor for {model_name} to hub")
-        model.push_to_hub(f"EduardoPacheco/{model_name}")
-        image_processor.push_to_hub(f"EduardoPacheco/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="seggpt-vit-large",
-        type=str,
-        choices=["seggpt-vit-large"],
-        help="Name of the SegGpt model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_false",
-        help="Whether or not to verify the logits against the original implementation.",
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_seggpt_checkpoint(args)
diff --git a/src/transformers/models/sew/convert_sew_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/sew/convert_sew_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index df0cae2a3b29..000000000000
--- a/src/transformers/models/sew/convert_sew_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,305 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert SEW checkpoint."""
-
-import argparse
-import json
-import os
-
-import fairseq
-import torch
-from fairseq.data import Dictionary
-
-# Register SEW's fairseq modules
-from sew_asapp import tasks  # noqa: F401
-
-from transformers import (
-    SEWConfig,
-    SEWForCTC,
-    SEWModel,
-    Wav2Vec2CTCTokenizer,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2Processor,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.upsample.0": "encoder.upsample.projection",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "layer_norm",
-    "w2v_encoder.proj": "lm_head",
-    "mask_emb": "masked_spec_embed",
-}
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    assert hf_shape == value.shape, (
-        f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-        f" {value.shape} for {full_name}"
-    )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model, is_finetuned):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.sew.feature_extractor if is_finetuned else hf_model.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                mapped_key = "sew." + mapped_key if (is_finetuned and mapped_key != "lm_head") else mapped_key
-
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "weight" in name:
-                        weight_type = "weight"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
-                " found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-def convert_config(model, is_finetuned):
-    config = SEWConfig()
-    if is_finetuned:
-        fs_config = model.w2v_encoder.w2v_model.cfg
-    else:
-        fs_config = model.cfg
-
-    config.conv_bias = fs_config.conv_bias
-    conv_layers = eval(fs_config.conv_feature_layers)
-    config.conv_dim = [x[0] for x in conv_layers]
-    config.conv_kernel = [x[1] for x in conv_layers]
-    config.conv_stride = [x[2] for x in conv_layers]
-    config.feat_extract_activation = "gelu"
-    config.feat_extract_norm = "layer" if fs_config.extractor_mode == "layer_norm" else "group"
-    config.final_dropout = 0.0
-    config.hidden_act = fs_config.activation_fn.name
-    config.hidden_size = fs_config.encoder_embed_dim
-    config.initializer_range = 0.02
-    config.intermediate_size = fs_config.encoder_ffn_embed_dim
-    config.layer_norm_eps = 1e-5
-    config.layerdrop = fs_config.encoder_layerdrop
-    config.num_attention_heads = fs_config.encoder_attention_heads
-    config.num_conv_pos_embedding_groups = fs_config.conv_pos_groups
-    config.num_conv_pos_embeddings = fs_config.conv_pos
-    config.num_feat_extract_layers = len(conv_layers)
-    config.num_hidden_layers = fs_config.encoder_layers
-    config.squeeze_factor = fs_config.squeeze_factor
-
-    # take care of any params that are overridden by the Wav2VecCtc model
-    if is_finetuned:
-        fs_config = model.cfg
-        config.final_dropout = fs_config.final_dropout
-        config.layerdrop = fs_config.layerdrop
-    config.activation_dropout = fs_config.activation_dropout
-    config.apply_spec_augment = fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0
-    config.attention_dropout = fs_config.attention_dropout
-    config.feat_proj_dropout = fs_config.dropout_input
-    config.hidden_dropout = fs_config.dropout
-    config.mask_feature_length = fs_config.mask_channel_length
-    config.mask_feature_prob = fs_config.mask_channel_prob
-    config.mask_time_length = fs_config.mask_length
-    config.mask_time_prob = fs_config.mask_prob
-
-    config.feature_extractor_type = "Wav2Vec2FeatureExtractor"
-    config.tokenizer_class = "Wav2Vec2CTCTokenizer"
-
-    return config
-
-
-@torch.no_grad()
-def convert_sew_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, config_path=None, dict_path=None, is_finetuned=True
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-
-    if is_finetuned:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-            [checkpoint_path], arg_overrides={"data": "/".join(dict_path.split("/")[:-1])}
-        )
-    else:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path])
-
-    if config_path is not None:
-        config = SEWConfig.from_pretrained(config_path)
-    else:
-        config = convert_config(model[0], is_finetuned)
-    model = model[0].eval()
-
-    return_attention_mask = True if config.feat_extract_norm == "layer" else False
-    feature_extractor = Wav2Vec2FeatureExtractor(
-        feature_size=1,
-        sampling_rate=16000,
-        padding_value=0,
-        do_normalize=True,
-        return_attention_mask=return_attention_mask,
-    )
-
-    if is_finetuned:
-        if dict_path:
-            target_dict = Dictionary.load(dict_path)
-
-            # important change bos & pad token id since CTC symbol is <pad> and
-            # not <s> as in fairseq
-            target_dict.indices[target_dict.bos_word] = target_dict.pad_index
-            target_dict.indices[target_dict.pad_word] = target_dict.bos_index
-            config.bos_token_id = target_dict.pad_index
-            config.pad_token_id = target_dict.bos_index
-            config.eos_token_id = target_dict.eos_index
-            config.vocab_size = len(target_dict.symbols)
-            vocab_path = os.path.join(pytorch_dump_folder_path, "vocab.json")
-            if not os.path.isdir(pytorch_dump_folder_path):
-                logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(pytorch_dump_folder_path))
-                return
-            os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-            with open(vocab_path, "w", encoding="utf-8") as vocab_handle:
-                json.dump(target_dict.indices, vocab_handle)
-            tokenizer = Wav2Vec2CTCTokenizer(
-                vocab_path,
-                unk_token=target_dict.unk_word,
-                pad_token=target_dict.pad_word,
-                bos_token=target_dict.bos_word,
-                eos_token=target_dict.eos_word,
-                word_delimiter_token="|",
-                do_lower_case=False,
-            )
-            processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
-            processor.save_pretrained(pytorch_dump_folder_path)
-
-        hf_model = SEWForCTC(config)
-    else:
-        hf_model = SEWModel(config)
-        feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-    recursively_load_weights(model, hf_model, is_finetuned)
-
-    hf_model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--is_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
-    )
-    args = parser.parse_args()
-    convert_sew_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned
-    )
diff --git a/src/transformers/models/sew_d/convert_sew_d_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/sew_d/convert_sew_d_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 1540efa4be17..000000000000
--- a/src/transformers/models/sew_d/convert_sew_d_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,317 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert SEW checkpoint."""
-
-import argparse
-import json
-import os
-
-import fairseq
-import torch
-from fairseq.data import Dictionary
-
-# Register SEW's fairseq modules
-from sew_asapp import tasks  # noqa: F401
-
-from transformers import (
-    SEWDConfig,
-    SEWDForCTC,
-    SEWDModel,
-    Wav2Vec2CTCTokenizer,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2Processor,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "attention.self.query_proj": "encoder.encoder.layer.*.attention.self.query_proj",
-    "attention.self.key_proj": "encoder.encoder.layer.*.attention.self.key_proj",
-    "attention.self.value_proj": "encoder.encoder.layer.*.attention.self.value_proj",
-    "attention.output.dense": "encoder.encoder.layer.*.attention.output.dense",
-    "attention.output.LayerNorm": "encoder.encoder.layer.*.attention.output.LayerNorm",
-    "intermediate.dense": "encoder.encoder.layer.*.intermediate.dense",
-    "output.dense": "encoder.encoder.layer.*.output.dense",
-    "output.LayerNorm": "encoder.encoder.layer.*.output.LayerNorm",
-    "encoder.encoder.rel_embeddings": "encoder.encoder.rel_embeddings",
-    "encoder.encoder.LayerNorm": "encoder.encoder.LayerNorm",
-    "encoder.upsample.0": "encoder.upsample.projection",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "layer_norm",
-    "w2v_encoder.proj": "lm_head",
-    "mask_emb": "masked_spec_embed",
-}
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    assert hf_shape == value.shape, (
-        f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-        f" {value.shape} for {full_name}"
-    )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model, is_finetuned):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.sew_d.feature_extractor if is_finetuned else hf_model.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                mapped_key = "sew_d." + mapped_key if (is_finetuned and mapped_key != "lm_head") else mapped_key
-
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        if not layer_index.isnumeric():
-                            continue
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "weight" in name:
-                        weight_type = "weight"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
-                " found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-def convert_config(model, is_finetuned):
-    config = SEWDConfig()
-    if is_finetuned:
-        fs_config = model.w2v_encoder.w2v_model.cfg
-    else:
-        fs_config = model.cfg
-
-    config.conv_bias = fs_config.conv_bias
-    conv_layers = eval(fs_config.conv_feature_layers)
-    config.conv_dim = [x[0] for x in conv_layers]
-    config.conv_kernel = [x[1] for x in conv_layers]
-    config.conv_stride = [x[2] for x in conv_layers]
-    config.feat_extract_activation = "gelu"
-    config.feat_extract_norm = "layer" if fs_config.extractor_mode == "layer_norm" else "group"
-    config.final_dropout = 0.0
-    config.hidden_act = fs_config.activation_fn.name
-    config.hidden_size = fs_config.encoder_embed_dim
-    config.initializer_range = 0.02
-    config.intermediate_size = fs_config.encoder_ffn_embed_dim
-    config.layer_norm_eps = 1e-5
-    config.layerdrop = fs_config.encoder_layerdrop
-    config.num_attention_heads = fs_config.encoder_attention_heads
-    config.num_conv_pos_embedding_groups = fs_config.conv_pos_groups
-    config.num_conv_pos_embeddings = fs_config.conv_pos
-    config.num_feat_extract_layers = len(conv_layers)
-    config.num_hidden_layers = fs_config.encoder_layers
-    config.squeeze_factor = fs_config.squeeze_factor
-    # DeBERTa-specific parameters:
-    config.max_position_embeddings = fs_config.max_position_embeddings
-    config.position_buckets = fs_config.position_buckets
-    config.share_att_key = fs_config.share_att_key
-    config.relative_attention = fs_config.relative_attention
-    config.position_biased_input = fs_config.position_biased_input
-    config.pos_att_type = tuple(fs_config.pos_att_type.split("|"))
-    config.norm_rel_ebd = fs_config.norm_rel_ebd
-
-    # take care of any params that are overridden by the Wav2VecCtc model
-    if is_finetuned:
-        fs_config = model.cfg
-        config.final_dropout = fs_config.final_dropout
-        config.layerdrop = fs_config.layerdrop
-    config.activation_dropout = fs_config.activation_dropout
-    config.apply_spec_augment = fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0
-    config.attention_dropout = fs_config.attention_dropout
-    config.feat_proj_dropout = fs_config.dropout_input
-    config.hidden_dropout = fs_config.dropout
-    config.mask_feature_length = fs_config.mask_channel_length
-    config.mask_feature_prob = fs_config.mask_channel_prob
-    config.mask_time_length = fs_config.mask_length
-    config.mask_time_prob = fs_config.mask_prob
-
-    config.feature_extractor_type = "Wav2Vec2FeatureExtractor"
-    config.tokenizer_class = "Wav2Vec2CTCTokenizer"
-
-    return config
-
-
-@torch.no_grad()
-def convert_sew_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, config_path=None, dict_path=None, is_finetuned=True
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-
-    if is_finetuned:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-            [checkpoint_path], arg_overrides={"data": "/".join(dict_path.split("/")[:-1])}
-        )
-    else:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path])
-
-    if config_path is not None:
-        config = SEWDConfig.from_pretrained(config_path)
-    else:
-        config = convert_config(model[0], is_finetuned)
-    model = model[0].eval()
-
-    return_attention_mask = True if config.feat_extract_norm == "layer" else False
-    feature_extractor = Wav2Vec2FeatureExtractor(
-        feature_size=1,
-        sampling_rate=16000,
-        padding_value=0,
-        do_normalize=True,
-        return_attention_mask=return_attention_mask,
-    )
-
-    if is_finetuned:
-        if dict_path:
-            target_dict = Dictionary.load(dict_path)
-
-            # important change bos & pad token id since CTC symbol is <pad> and
-            # not <s> as in fairseq
-            target_dict.indices[target_dict.bos_word] = target_dict.pad_index
-            target_dict.indices[target_dict.pad_word] = target_dict.bos_index
-            config.bos_token_id = target_dict.pad_index
-            config.pad_token_id = target_dict.bos_index
-            config.eos_token_id = target_dict.eos_index
-            config.vocab_size = len(target_dict.symbols)
-            vocab_path = os.path.join(pytorch_dump_folder_path, "vocab.json")
-            if not os.path.isdir(pytorch_dump_folder_path):
-                logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(pytorch_dump_folder_path))
-                return
-            os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-            with open(vocab_path, "w", encoding="utf-8") as vocab_handle:
-                json.dump(target_dict.indices, vocab_handle)
-            tokenizer = Wav2Vec2CTCTokenizer(
-                vocab_path,
-                unk_token=target_dict.unk_word,
-                pad_token=target_dict.pad_word,
-                bos_token=target_dict.bos_word,
-                eos_token=target_dict.eos_word,
-                word_delimiter_token="|",
-                do_lower_case=False,
-            )
-            processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
-            processor.save_pretrained(pytorch_dump_folder_path)
-
-        hf_model = SEWDForCTC(config)
-    else:
-        hf_model = SEWDModel(config)
-        feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-    recursively_load_weights(model, hf_model, is_finetuned)
-
-    hf_model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--is_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
-    )
-    args = parser.parse_args()
-    convert_sew_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned
-    )
diff --git a/src/transformers/models/shieldgemma2/convert_shieldgemma2_weights_orbax_to_hf.py b/src/transformers/models/shieldgemma2/convert_shieldgemma2_weights_orbax_to_hf.py
deleted file mode 100644
index 0ca46eb29e2d..000000000000
--- a/src/transformers/models/shieldgemma2/convert_shieldgemma2_weights_orbax_to_hf.py
+++ /dev/null
@@ -1,470 +0,0 @@
-r"""Utility to convert Gemma models from Orbax to HF Transformers checkpoint.
-
-python -m transformers.models.shieldgemma2.convert_shieldgemma2_weights_orbax_to_hf \
-    --tokenizer_path="$HOME/gemma3/tokenizer/gemma3_cleaned_262144_v2.spiece.model" \
-    --checkpoint_path_gemma="$HOME/gemma3/gemma3_4b_pt_orbax/" \
-    --checkpoint_path_shieldgemma="$HOME/shieldgemma2/shieldgemma-2_4b_orbax/" \
-    --output_path="$HOME/shieldgemma2/shieldgemma2_4b_pt_safetensors/" \
-    --precision='bfloat16'
-"""
-
-import dataclasses
-from collections.abc import Iterator, Mapping, Sequence
-from typing import Any
-
-import accelerate
-import numpy as np
-import torch
-import tree
-from absl import app, flags, logging
-from orbax import checkpoint as obc
-
-from ...image_utils import PILImageResampling
-from ..gemma import GemmaTokenizerFast
-from ..gemma3 import Gemma3ImageProcessor, Gemma3TextConfig
-from ..siglip import SiglipVisionConfig
-from . import ShieldGemma2Config, ShieldGemma2ForImageClassification, ShieldGemma2Processor
-
-
-# ==== Internal Constants and Classes ====
-
-_CHAT_TEMPLATE = """{{ bos_token }}
-{%- for message in messages -%}
-    {%- if message['content'] is iterable -%}
-        {%- for item in message['content'] -%}
-            {{ '<start_of_turn>user\n' }}
-            {%- if item['type'] == 'image' -%}
-                {{ '<start_of_image>' }}
-            {%- elif item['type'] == 'text' -%}
-                {{ 'You are a policy expert trying to help determine whether a generated or real image is in' }}
-                {{ ' violation of the safety policy below. Your decision must very clearly follow the specific'}}
-                {{ ' language used in the safety policy and should not include any interpretation outside of the' }}
-                {{ ' safety policy.\n\n' }}
-                {{ '<BEGIN_SAFETY_POLICY>\n' }}
-                {{ item['text'] + '\n' }}
-                {{ '</END_SAFETY_POLICY>\n\n' }}
-                {{ 'Does the image violate the above policy? Your Answer must start with \\'Yes\\' or \\'No\\'.' }}
-                {{ '<end_of_turn>\n' }}
-            {%- endif -%}
-        {%- endfor -%}
-        {{'<start_of_turn>model\n'}}
-    {%- else -%}
-        {{ raise_exception("Conversation messages must contain iterable content containing images and policy definitions in text.") }}
-    {%- endif -%}
-{%- endfor -%}
-"""
-
-_DTYPES = {
-    "float32": torch.float32,
-    "bfloat16": torch.bfloat16,
-    "float16": torch.float16,
-}
-
-_SHIELDGEMMA2_POLICIES: Mapping[str, str] = {
-    "dangerous": (
-        "No Dangerous Content: The image shall not contain content that"
-        " facilitates or encourages activities that could cause real-world harm"
-        " (e.g., building firearms and explosive devices, promotion of"
-        " terrorism, instructions for suicide)."
-    ),
-    "sexual": (
-        "No Sexually Explicit content: The image shall not contain content that"
-        " depicts explicit or graphic sexual acts (e.g., pornography, erotic"
-        " nudity, depictions of rape or sexual assault)."
-    ),
-    "violence": (
-        "No Violence/Gore content: The image shall not contain content that"
-        " depicts shocking, sensational, or gratuitous violence (e.g.,"
-        " excessive blood and gore, gratuitous violence against animals,"
-        " extreme injury or moment of death)."
-    ),
-}
-
-_SIGLIP_BASE = "SigLiPFromPatches_0/siglip_encoder"
-_SIGLIP_EMBEDDING = "SigLiPFromPatches_0/siglip_encoder/embedding"
-_SIGLIP_TRANSFORMER_ENCODER_BLOCK = "SigLiPFromPatches_0/siglip_encoder/Transformer/encoderblock_"
-_SIGLIP_TRANSFORMER_ENCODER_BLOCK_LEN = len(_SIGLIP_TRANSFORMER_ENCODER_BLOCK)
-_SIGLIP_TRANSFORMER_ENCODER_NORM = "SigLiPFromPatches_0/siglip_encoder/Transformer/encoder_norm"
-
-_TRANSFORMER_DECODER_BLOCK = "transformer/layer_"
-_TRANSFORMER_DECODER_BLOCK_LEN = len(_TRANSFORMER_DECODER_BLOCK)
-_TRANSFORMER_EMBEDDER = "transformer/embedder"
-_TRANSFORMER_FINAL_NORM = "transformer/final_norm"
-_TRANSFORMER_POST_TRAINING_PREFIX = "rlx_networks/policy_network/"
-_TRANSFORMER_POST_TRAINING_PREFIX_LEN = len(_TRANSFORMER_POST_TRAINING_PREFIX)
-
-# ==== Flags ====
-
-_GEMMA_CHECKPOINT_PATH = flags.DEFINE_string(
-    name="checkpoint_path_gemma",
-    default=None,
-    help="Path to the Orbax checkpoint containing the vision weights.",
-    required=True,
-)
-
-_SHIELDGEMMA_CHECKPOINT_PATH = flags.DEFINE_string(
-    name="checkpoint_path_shieldgemma",
-    default=None,
-    help="Path to the Orbax checkpoint containing the language model weights.",
-    required=True,
-)
-
-OUTPUT_PATH = flags.DEFINE_string(
-    name="output_path",
-    default=None,
-    help="Path to store the HF checkpoint.",
-    required=True,
-)
-
-PRECISION = flags.DEFINE_enum(
-    name="precision",
-    default=None,
-    help="The floating point precision (aka dtype) of the model.",
-    enum_values=set(_DTYPES.keys()),
-    required=True,
-)
-
-TOKENIZER_PATH = flags.DEFINE_string(
-    name="tokenizer_path",
-    default=None,
-    help="Path to the SentencePiece model file.",
-    required=True,
-)
-
-
-def convert_siglip_weight(
-    config: SiglipVisionConfig,
-    paths: Sequence[str],
-    weights: np.ndarray,
-) -> tuple[str, np.ndarray]:
-    path, prop = paths
-    normalized_path: str = ""
-    updated_weights: np.ndarray = None
-
-    if path == _SIGLIP_BASE:
-        normalized_path = "vision_tower.vision_model.embeddings.position_embedding.weight"
-        updated_weights = weights.reshape(-1, config.hidden_size)
-    elif path == _SIGLIP_EMBEDDING:
-        if prop == "kernel":
-            normalized_path = "vision_tower.vision_model.embeddings.patch_embedding.weight"
-            updated_weights = weights.transpose(3, 2, 0, 1)
-        elif prop == "bias":
-            normalized_path = "vision_tower.vision_model.embeddings.patch_embedding.bias"
-            updated_weights = weights
-        else:
-            raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `kernel`.")
-    elif path.startswith(_SIGLIP_TRANSFORMER_ENCODER_BLOCK):
-        encoder_block_path = path[_SIGLIP_TRANSFORMER_ENCODER_BLOCK_LEN:]
-        next_path_seperator_idx = encoder_block_path.find("/")
-        layer_idx = encoder_block_path[:next_path_seperator_idx]
-        encoder_block_path = encoder_block_path[next_path_seperator_idx:]
-        normalized_path = f"vision_tower.vision_model.encoder.layers.{layer_idx}"
-
-        if encoder_block_path.startswith("/LayerNorm"):
-            normalized_path += ".layer_norm1" if path.endswith("_0") else ".layer_norm2"
-
-            if prop == "scale":
-                normalized_path += ".weight"
-                updated_weights = weights.transpose()
-            elif prop == "bias":
-                normalized_path += ".bias"
-                updated_weights = weights
-            else:
-                raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `scale`.")
-        elif encoder_block_path.startswith("/MlpBlock_0"):
-            normalized_path += ".mlp.fc1" if "/Dense_0" in encoder_block_path else ".mlp.fc2"
-
-            if prop == "kernel":
-                normalized_path += ".weight"
-                updated_weights = weights.transpose()
-            elif prop == "bias":
-                normalized_path += ".bias"
-                updated_weights = weights
-            else:
-                raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `kernel`.")
-        elif encoder_block_path.startswith("/MultiHeadDotProductAttention_0"):
-            if encoder_block_path.endswith("/key"):
-                normalized_path += ".self_attn.k_proj"
-            elif encoder_block_path.endswith("/out"):
-                normalized_path += ".self_attn.out_proj"
-            elif encoder_block_path.endswith("/query"):
-                normalized_path += ".self_attn.q_proj"
-            elif encoder_block_path.endswith("/value"):
-                normalized_path += ".self_attn.v_proj"
-            else:
-                raise ValueError(f"Unexpected path `{path}` in SigLIP Transformer MultiHeadDotProductAttention_0.")
-
-            if prop == "bias":
-                normalized_path += ".bias"
-                updated_weights = weights.reshape(-1, config.hidden_size).reshape(-1)
-            elif prop == "kernel":
-                normalized_path += ".weight"
-                updated_weights = weights.reshape(-1, config.hidden_size).transpose()
-            else:
-                raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `kernel`.")
-        else:
-            raise ValueError(f"Unexpected path `{path}` in SigLIP Transformer Encoder Block.")
-    elif path == _SIGLIP_TRANSFORMER_ENCODER_NORM:
-        if prop == "scale":
-            normalized_path = "vision_tower.vision_model.post_layernorm.weight"
-            updated_weights = weights.transpose()
-        elif prop == "bias":
-            normalized_path = "vision_tower.vision_model.post_layernorm.bias"
-            updated_weights = weights
-        else:
-            raise ValueError(f"Unexpected member, `{prop}`, for path `{path}`. Should be `bias` or `scale`.")
-    else:
-        raise ValueError(f"Unexpected path `{path}`.")
-
-    if "vision" in normalized_path:
-        print(normalized_path)
-    return normalized_path, updated_weights
-
-
-def convert_transformer_weights(
-    config: Gemma3TextConfig,
-    paths: Sequence[str],
-    weights: np.ndarray,
-) -> Iterator[tuple[str, np.ndarray]]:
-    path, prop = paths
-
-    if path.startswith(_TRANSFORMER_POST_TRAINING_PREFIX):
-        path = path[_TRANSFORMER_POST_TRAINING_PREFIX_LEN:]
-
-    converted_paths: list[str] = []
-    converted_weights: list[Any] = []
-
-    attn_head_dim = config.num_attention_heads * config.head_dim
-    kv_head_dim = config.num_key_value_heads * config.head_dim
-
-    if path == _TRANSFORMER_EMBEDDER:
-        if prop == "input_embedding":
-            # Tied to language_model.lm_head.weight, assigned at the end.
-            converted_paths = ["language_model.model.embed_tokens.weight"]
-            # Gemma3 model doesn't have image soft token in input and output embeddings, resize to avoid bugs we had with Mllama
-            pre_expansion_embeddings = weights
-            mu = np.mean(pre_expansion_embeddings, axis=0)
-            sigma = np.cov(pre_expansion_embeddings, rowvar=False, bias=True)
-            new_embeddings = np.random.multivariate_normal(mu, 1e-5 * sigma, size=64)
-            weights = np.vstack([pre_expansion_embeddings, new_embeddings])
-            converted_weights = [weights]
-        else:
-            raise ValueError(f"Unexpected member, {prop}, in Embedder.")
-    elif path.startswith(f"{_TRANSFORMER_EMBEDDER}/mm"):
-        if path.endswith("/mm_input_projection"):
-            converted_paths = ["multi_modal_projector.mm_input_projection_weight"]
-            converted_weights = [weights]
-        elif path.endswith("/mm_soft_embedding_norm"):
-            converted_paths = ["multi_modal_projector.mm_soft_emb_norm.weight"]
-            converted_weights = [weights]
-        else:
-            raise ValueError(f"Unexpected subpath, `{path}`, in Embedder.")
-    elif path == _TRANSFORMER_FINAL_NORM:
-        converted_paths = ["language_model.model.norm.weight"]
-        converted_weights = [weights]
-    elif path.startswith(_TRANSFORMER_DECODER_BLOCK):
-        decoder_block_path = path[_TRANSFORMER_DECODER_BLOCK_LEN:]
-        next_path_seperator_idx = decoder_block_path.find("/")
-        layer_idx = decoder_block_path[:next_path_seperator_idx]
-        decoder_block_path = decoder_block_path[next_path_seperator_idx:]
-
-        base_path = f"language_model.model.layers.{layer_idx}"
-
-        if path.endswith("attn/attn_vec_einsum"):
-            converted_paths = [f"{base_path}.self_attn.o_proj.weight"]
-            converted_weights = [weights.transpose(2, 0, 1).reshape(config.hidden_size, attn_head_dim)]
-        elif path.endswith("attn/_key_norm"):
-            converted_paths = [f"{base_path}.self_attn.k_norm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("attn/kv_einsum"):
-            converted_paths = [
-                f"{base_path}.self_attn.k_proj.weight",
-                f"{base_path}.self_attn.v_proj.weight",
-            ]
-            k_proj_weights, v_proj_weights = weights
-            converted_weights = [
-                k_proj_weights.transpose(0, 2, 1).reshape(kv_head_dim, config.hidden_size),
-                v_proj_weights.transpose(0, 2, 1).reshape(kv_head_dim, config.hidden_size),
-            ]
-        elif path.endswith("attn/q_einsum"):
-            converted_paths = [f"{base_path}.self_attn.q_proj.weight"]
-            converted_weights = [weights.transpose(0, 2, 1).reshape(attn_head_dim, config.hidden_size)]
-        elif path.endswith("attn/_query_norm"):
-            converted_paths = [f"{base_path}.self_attn.q_norm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("mlp/gating_einsum"):
-            converted_paths = [
-                f"{base_path}.mlp.gate_proj.weight",
-                f"{base_path}.mlp.up_proj.weight",
-            ]
-            gate_proj_weight, up_proj_weight = weights
-            converted_weights = [gate_proj_weight, up_proj_weight]
-        elif path.endswith("mlp/linear"):
-            converted_paths = [f"{base_path}.mlp.down_proj.weight"]
-            converted_weights = [weights.transpose()]
-        elif path.endswith("post_attention_norm"):
-            converted_paths = [f"{base_path}.post_attention_layernorm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("post_ffw_norm"):
-            converted_paths = [f"{base_path}.post_feedforward_layernorm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("pre_attention_norm"):
-            converted_paths = [f"{base_path}.input_layernorm.weight"]
-            converted_weights = [weights]
-        elif path.endswith("pre_ffw_norm"):
-            converted_paths = [f"{base_path}.pre_feedforward_layernorm.weight"]
-            converted_weights = [weights]
-        else:
-            raise ValueError(f"Unexpected path `{path}` in Decoder Block.")
-    else:
-        raise ValueError(f"Unexpected path `{path}`.")
-
-    if (cpl := len(converted_paths)) != (cwl := len(converted_weights)):
-        raise ValueError(
-            "The `converted_paths` and `converted_weights` should be the same "
-            f"length. Got {cpl} and {cwl}, respectively, for {path}."
-        )
-
-    return zip(converted_paths, converted_weights)
-
-
-def transpose_reshape(x: torch.Tensor) -> torch.Tensor:
-    x = x.transpose(1, 2)
-    return x.reshape(x.shape[0] * x.shape[1], x.shape[2]).contiguous()
-
-
-@dataclasses.dataclass(frozen=True)
-class ConversionResult:
-    state_tree: dict[str, torch.Tensor]
-    config: ShieldGemma2Config
-
-
-def convert(
-    shieldgemma_checkpoint_path: str,
-    gemma_checkpoint_path: str,
-    config: ShieldGemma2Config,
-    target_dtype: torch.dtype,
-) -> ConversionResult:
-    """Loads Orbax checkpoint from `input_path` and converts it to HF tree."""
-    checkpointer = obc.PyTreeCheckpointer()
-
-    sg2_ckpt = checkpointer.restore(shieldgemma_checkpoint_path)
-    g3_ckpt = checkpointer.restore(gemma_checkpoint_path)
-
-    hf_tree: dict[str, torch.Tensor] = {}
-
-    def update_tree(path: str, weights: np.ndarray) -> None:
-        torch_tensor = torch.from_numpy(weights.astype("float32")).type(target_dtype)
-        logging.info(
-            "%s converted shape=%s with dtype=%s",
-            path,
-            weights.shape,
-            torch_tensor.dtype,
-        )
-        hf_tree[f"model.{path}"] = torch_tensor
-
-    for paths, value in tree.flatten_with_path(g3_ckpt):
-        if paths[0].startswith("SigLiPFromPatches_"):
-            path, weights = convert_siglip_weight(config=config.vision_config, paths=paths, weights=value)
-            update_tree(path, weights)
-
-    for paths, value in tree.flatten_with_path(sg2_ckpt):
-        for path, weights in convert_transformer_weights(config=config.text_config, paths=paths, weights=value):
-            update_tree(path, weights)
-
-    hf_tree["model.language_model.lm_head.weight"] = hf_tree["model.language_model.model.embed_tokens.weight"]
-
-    return ConversionResult(state_tree=hf_tree, config=config)
-
-
-def main(*args):
-    del args
-
-    dtype = getattr(torch, PRECISION.value)
-    output_path = OUTPUT_PATH.value
-
-    tokenizer = GemmaTokenizerFast(
-        TOKENIZER_PATH.value,
-        extra_special_tokens={
-            "image_token": "<image_soft_token>",  # Should be ID=262_144
-            "boi_token": "<start_of_image>",  # Should be ID=255_999
-            "eoi_token": "<end_of_image>",  # Should be ID=256_000
-        },
-    )
-
-    yes_token_index, no_token_index = torch.tensor(tokenizer(["Yes", "No"])["input_ids"])[:, 1].numpy()
-
-    config = ShieldGemma2Config(
-        yes_token_index=int(yes_token_index),
-        no_token_index=int(no_token_index),
-        text_config=Gemma3TextConfig(
-            vocab_size=262_208,
-            hidden_size=2560,
-            intermediate_size=2560 * 8 // 2,
-            num_attention_heads=8,
-            head_dim=256,
-            num_hidden_layers=34,
-            num_key_value_heads=4,
-            sliding_window=1024,
-            rope_scaling={"rope_type": "linear", "factor": 8.0},  # used for global RoPE only
-            rope_theta=1_000_000,
-            rope_local_base_freq=10_000,
-            attn_logit_softcapping=None,
-            query_pre_attn_scalar=256,
-            max_position_embeddings=8192,
-        ),
-        vision_config={
-            "hidden_size": 1152,
-            "intermediate_size": 4304,
-            "num_hidden_layers": 27,
-            "num_attention_heads": 16,
-            "num_channels": 3,
-            "image_size": 896,
-            "patch_size": 14,
-            "hidden_act": "gelu_pytorch_tanh",
-            "layer_norm_eps": 1e-6,
-            "attention_dropout": 0.0,
-            "vision_use_head": False,
-        },
-    )
-
-    config.save_pretrained(output_path)
-
-    image_processor = Gemma3ImageProcessor(
-        image_seq_length=256,
-        image_mean=(0.5,) * 3,
-        image_std=(0.5,) * 3,
-        size={"height": 896, "width": 896},
-        resample=PILImageResampling.BILINEAR,
-    )
-    processor = ShieldGemma2Processor(
-        image_processor=image_processor,
-        tokenizer=tokenizer,
-        policy_definitions=_SHIELDGEMMA2_POLICIES,
-    )
-    tokenizer.chat_template = _CHAT_TEMPLATE
-    processor.chat_template = _CHAT_TEMPLATE
-
-    processor.save_pretrained(output_path)
-    logging.info("Saved Shieldgemma2Processor to %s", output_path)
-    del processor
-    del tokenizer
-
-    logging.info("Converting Shieldgemma2 @ %s", dtype)
-    result = convert(_SHIELDGEMMA_CHECKPOINT_PATH.value, _GEMMA_CHECKPOINT_PATH.value, config, dtype)
-    logging.info("Converted Shieldgemma2 state tree from Orbax to Hugging Face.")
-
-    with accelerate.init_empty_weights():
-        model = ShieldGemma2ForImageClassification(config=config)
-
-    model.load_state_dict(result.state_tree, assign=True, strict=True)
-    model.config.torch_dtype = dtype
-    logging.info("Loaded Shieldgemma2 in Hugging Face Transformers.")
-    model.save_pretrained(output_path, safe_serialization=True)
-    logging.info("Saved Shieldgemma2 to SafeTensors in %s", output_path)
-    del model
-    del result
-
-
-if __name__ == "__main__":
-    app.run(main)
diff --git a/src/transformers/models/siglip/convert_siglip_to_hf.py b/src/transformers/models/siglip/convert_siglip_to_hf.py
deleted file mode 100644
index 8b0a8a250dd8..000000000000
--- a/src/transformers/models/siglip/convert_siglip_to_hf.py
+++ /dev/null
@@ -1,533 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert SigLIP checkpoints from the original repository.
-
-URL: https://github.com/google-research/big_vision/tree/main
-"""
-
-import argparse
-import collections
-import os
-from typing import Tuple
-
-import numpy as np
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from numpy import load
-from PIL import Image
-
-from transformers import (
-    GemmaTokenizerFast,
-    SiglipConfig,
-    SiglipImageProcessor,
-    SiglipModel,
-    SiglipProcessor,
-    SiglipTokenizer,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-MODEL_CONFIGS = {
-    "base": {
-        "hidden_size": 768,
-        "intermediate_size": 3072,
-        "num_hidden_layers": 12,
-        "num_attention_heads": 12,
-    },
-    "large": {
-        "hidden_size": 1024,
-        "intermediate_size": 4096,
-        "num_hidden_layers": 24,
-        "num_attention_heads": 16,
-    },
-    "giant-opt": {
-        "hidden_size": 1536,
-        "intermediate_size": 6144,
-        "num_hidden_layers": 40,
-        "num_attention_heads": 16,
-    },
-    "so400m": {
-        "hidden_size": 1152,
-        "intermediate_size": 4304,
-        "num_hidden_layers": 27,
-        "num_attention_heads": 16,
-    },
-}
-
-model_name_to_checkpoint = {
-    # base checkpoints
-    "siglip-base-patch16-224": "/Users/nielsrogge/Documents/SigLIP/webli_en_b16_224_63724782.npz",
-    "siglip-base-patch16-256": "/Users/nielsrogge/Documents/SigLIP/webli_en_b16_256_60500360.npz",
-    "siglip-base-patch16-384": "/Users/nielsrogge/Documents/SigLIP/webli_en_b16_384_68578854.npz",
-    "siglip-base-patch16-512": "/Users/nielsrogge/Documents/SigLIP/webli_en_b16_512_68580893.npz",
-    # large checkpoints
-    "siglip-large-patch16-256": "/Users/nielsrogge/Documents/SigLIP/webli_en_l16_256_60552751.npz",
-    "siglip-large-patch16-384": "/Users/nielsrogge/Documents/SigLIP/webli_en_l16_384_63634585.npz",
-    # multilingual checkpoint
-    "siglip-base-patch16-256-i18n": "/Users/nielsrogge/Documents/SigLIP/webli_i18n_b16_256_66117334.npz",
-    # so400m checkpoints
-    "siglip-so400m-patch14-384": "/Users/nielsrogge/Documents/SigLIP/webli_en_so400m_384_58765454.npz",
-    # ----------------- v2 -----------------
-    # base checkpoints
-    "siglip2-base-patch32-256": "gv-hf/siglip2/siglip2_b32_256.npz",
-    "siglip2-base-patch16-224": "gv-hf/siglip2/siglip2_b16_224.npz",
-    "siglip2-base-patch16-256": "gv-hf/siglip2/siglip2_b16_256.npz",
-    "siglip2-base-patch16-384": "gv-hf/siglip2/siglip2_b16_384.npz",
-    "siglip2-base-patch16-512": "gv-hf/siglip2/siglip2_b16_512.npz",
-    # large checkpoints
-    "siglip2-large-patch16-256": "gv-hf/siglip2/siglip2_l16_256.npz",
-    "siglip2-large-patch16-384": "gv-hf/siglip2/siglip2_l16_384.npz",
-    "siglip2-large-patch16-512": "gv-hf/siglip2/siglip2_l16_512.npz",
-    # giant opt checkpoints
-    "siglip2-giant-opt-patch16-256": "gv-hf/siglip2/siglip2_g-opt16_256.npz",
-    "siglip2-giant-opt-patch16-384": "gv-hf/siglip2/siglip2_g-opt16_384.npz",
-    # so400m checkpoints
-    "siglip2-so400m-patch14-224": "gv-hf/siglip2/siglip2_so400m14_224.npz",
-    "siglip2-so400m-patch14-384": "gv-hf/siglip2/siglip2_so400m14_384.npz",
-    "siglip2-so400m-patch16-256": "gv-hf/siglip2/siglip2_so400m16_256.npz",
-    "siglip2-so400m-patch16-384": "gv-hf/siglip2/siglip2_so400m16_384.npz",
-    "siglip2-so400m-patch16-512": "gv-hf/siglip2/siglip2_so400m16_512.npz",
-}
-
-# ------------------------------------------------------------------------------------------------------
-#  CONFIG
-# ------------------------------------------------------------------------------------------------------
-
-
-def get_image_size_from_model_name(model_name: str) -> int:
-    if "-i18n" not in model_name:
-        size = model_name.split("-")[-1]
-    else:
-        size = model_name.split("-")[-2]
-    return int(size)
-
-
-def get_patch_size_from_model_name(model_name: str) -> int:
-    patch_str = [x for x in model_name.split("-") if "patch" in x][0]
-    return int(patch_str[-2:])
-
-
-def get_vocab_size_from_model_name(model_name: str) -> int:
-    if "siglip2" in model_name:
-        vocab_size = 256000
-    elif "-i18n" in model_name:
-        vocab_size = 250000
-    else:
-        vocab_size = 32000
-    return vocab_size
-
-
-def get_vocab_file_from_model_name(model_name: str) -> str:
-    # get vocab file
-    if "i18n" in model_name:
-        vocab_file = "/Users/nielsrogge/Documents/SigLIP/multilingual_vocab/sentencepiece.model"
-    else:
-        vocab_file = "/Users/nielsrogge/Documents/SigLIP/english_vocab/sentencepiece.model"
-    return vocab_file
-
-
-def get_text_and_vision_vit_variants(model_name: str) -> Tuple[str, str]:
-    variant = model_name.split("-")[1] if "giant-opt" not in model_name else "giant-opt"
-    return {
-        "base": ("base", "base"),
-        "large": ("large", "large"),
-        "so400m": ("so400m", "so400m"),
-        # g-opt siglip2 is not symmetric
-        "giant-opt": ("so400m", "giant-opt"),
-    }[variant]
-
-
-def get_siglip_config(model_name):
-    text_variant, vision_variant = get_text_and_vision_vit_variants(model_name)
-    text_config = MODEL_CONFIGS[text_variant].copy()
-    vision_config = MODEL_CONFIGS[vision_variant].copy()
-
-    text_config["vocab_size"] = get_vocab_size_from_model_name(model_name)
-    vision_config["image_size"] = get_image_size_from_model_name(model_name)
-    vision_config["patch_size"] = get_patch_size_from_model_name(model_name)
-
-    if text_config["hidden_size"] != vision_config["hidden_size"]:
-        text_config["projection_size"] = vision_config["hidden_size"]
-
-    return SiglipConfig(text_config=text_config, vision_config=vision_config)
-
-
-# ------------------------------------------------------------------------------------------------------
-#  PROCESSING
-# ------------------------------------------------------------------------------------------------------
-
-
-def get_tokenizer(model_name: str) -> GemmaTokenizerFast:
-    if "siglip2" in model_name:
-        tokenizer = GemmaTokenizerFast.from_pretrained(
-            "google/gemma-2-9b-it",
-            add_bos_token=False,
-            add_eos_token=True,
-            padding_side="right",
-            do_lower_case=True,
-            # important: make tokenizer NOT return attention_mask since original one doesn't require it
-            model_input_names=["input_ids"],
-        )
-    else:
-        # for siglip v1
-        vocab_file = get_vocab_file_from_model_name(model_name)
-        # important: make tokenizer not return attention_mask since original one doesn't require it
-        tokenizer = SiglipTokenizer(vocab_file=vocab_file, model_input_names=["input_ids"])
-    return tokenizer
-
-
-def get_image_processor(model_name: str) -> SiglipImageProcessor:
-    image_size = get_image_size_from_model_name(model_name)
-    size = {"height": image_size, "width": image_size}
-    if "siglip2" in model_name:
-        image_processor = SiglipImageProcessor(size=size, resample=2)  # bilinear resampling
-    else:
-        image_processor = SiglipImageProcessor(size=size)
-    return image_processor
-
-
-# ------------------------------------------------------------------------------------------------------
-#  CONVERT FUNCTIONS
-# ------------------------------------------------------------------------------------------------------
-
-
-def split_encoderblock_layers(state_dict: dict) -> dict:
-    """
-    Split the encoderblock weight into layers. In some cases they are concatenated in
-    the original checkpoints.
-    """
-    # Make shallow copy
-    state_dict = state_dict.copy()
-    # Split encoderblock weight into layers
-    keys = list(state_dict.keys())
-    for key in keys:
-        if "/encoderblock/" in key:
-            weight = state_dict.pop(key)
-            for i, weight_i in enumerate(weight):
-                new_name = key.replace("encoderblock", f"encoderblock_{i}")
-                state_dict[new_name] = weight_i
-    return state_dict
-
-
-def create_rename_keys(config):
-    rename_keys = []
-    # fmt: off
-
-    # vision encoder
-
-    rename_keys.append(("params/img/embedding/kernel", "vision_model.embeddings.patch_embedding.weight"))
-    rename_keys.append(("params/img/embedding/bias", "vision_model.embeddings.patch_embedding.bias"))
-    rename_keys.append(("params/img/pos_embedding", "vision_model.embeddings.position_embedding.weight"))
-
-    for i in range(config.vision_config.num_hidden_layers):
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/LayerNorm_0/scale", f"vision_model.encoder.layers.{i}.layer_norm1.weight"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/LayerNorm_0/bias", f"vision_model.encoder.layers.{i}.layer_norm1.bias"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/LayerNorm_1/scale", f"vision_model.encoder.layers.{i}.layer_norm2.weight"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/LayerNorm_1/bias", f"vision_model.encoder.layers.{i}.layer_norm2.bias"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MlpBlock_0/Dense_0/kernel", f"vision_model.encoder.layers.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MlpBlock_0/Dense_0/bias", f"vision_model.encoder.layers.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MlpBlock_0/Dense_1/kernel", f"vision_model.encoder.layers.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MlpBlock_0/Dense_1/bias", f"vision_model.encoder.layers.{i}.mlp.fc2.bias"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MultiHeadDotProductAttention_0/key/kernel", f"vision_model.encoder.layers.{i}.self_attn.k_proj.weight"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MultiHeadDotProductAttention_0/key/bias", f"vision_model.encoder.layers.{i}.self_attn.k_proj.bias"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MultiHeadDotProductAttention_0/value/kernel", f"vision_model.encoder.layers.{i}.self_attn.v_proj.weight"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MultiHeadDotProductAttention_0/value/bias", f"vision_model.encoder.layers.{i}.self_attn.v_proj.bias"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MultiHeadDotProductAttention_0/query/kernel", f"vision_model.encoder.layers.{i}.self_attn.q_proj.weight"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MultiHeadDotProductAttention_0/query/bias", f"vision_model.encoder.layers.{i}.self_attn.q_proj.bias"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MultiHeadDotProductAttention_0/out/kernel", f"vision_model.encoder.layers.{i}.self_attn.out_proj.weight"))
-        rename_keys.append((f"params/img/Transformer/encoderblock_{i}/MultiHeadDotProductAttention_0/out/bias", f"vision_model.encoder.layers.{i}.self_attn.out_proj.bias"))
-
-    rename_keys.append(("params/img/Transformer/encoder_norm/scale", "vision_model.post_layernorm.weight"))
-    rename_keys.append(("params/img/Transformer/encoder_norm/bias", "vision_model.post_layernorm.bias"))
-
-    rename_keys.append(("params/img/MAPHead_0/probe", "vision_model.head.probe"))
-    rename_keys.append(("params/img/MAPHead_0/LayerNorm_0/scale", "vision_model.head.layernorm.weight"))
-    rename_keys.append(("params/img/MAPHead_0/LayerNorm_0/bias", "vision_model.head.layernorm.bias"))
-    rename_keys.append(("params/img/MAPHead_0/MlpBlock_0/Dense_0/kernel", "vision_model.head.mlp.fc1.weight"))
-    rename_keys.append(("params/img/MAPHead_0/MlpBlock_0/Dense_0/bias", "vision_model.head.mlp.fc1.bias"))
-    rename_keys.append(("params/img/MAPHead_0/MlpBlock_0/Dense_1/kernel", "vision_model.head.mlp.fc2.weight"))
-    rename_keys.append(("params/img/MAPHead_0/MlpBlock_0/Dense_1/bias", "vision_model.head.mlp.fc2.bias"))
-    rename_keys.append(("params/img/MAPHead_0/MultiHeadDotProductAttention_0/out/kernel", "vision_model.head.attention.out_proj.weight"))
-    rename_keys.append(("params/img/MAPHead_0/MultiHeadDotProductAttention_0/out/bias", "vision_model.head.attention.out_proj.bias"))
-
-    # text encoder
-
-    rename_keys.append(("params/txt/Embed_0/embedding", "text_model.embeddings.token_embedding.weight"))
-    rename_keys.append(("params/txt/pos_embedding", "text_model.embeddings.position_embedding.weight"))
-
-    for i in range(config.text_config.num_hidden_layers):
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/LayerNorm_0/scale", f"text_model.encoder.layers.{i}.layer_norm1.weight"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/LayerNorm_0/bias", f"text_model.encoder.layers.{i}.layer_norm1.bias"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/LayerNorm_1/scale", f"text_model.encoder.layers.{i}.layer_norm2.weight"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/LayerNorm_1/bias", f"text_model.encoder.layers.{i}.layer_norm2.bias"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MlpBlock_0/Dense_0/kernel", f"text_model.encoder.layers.{i}.mlp.fc1.weight"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MlpBlock_0/Dense_0/bias", f"text_model.encoder.layers.{i}.mlp.fc1.bias"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MlpBlock_0/Dense_1/kernel", f"text_model.encoder.layers.{i}.mlp.fc2.weight"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MlpBlock_0/Dense_1/bias", f"text_model.encoder.layers.{i}.mlp.fc2.bias"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MultiHeadDotProductAttention_0/key/kernel", f"text_model.encoder.layers.{i}.self_attn.k_proj.weight"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MultiHeadDotProductAttention_0/key/bias", f"text_model.encoder.layers.{i}.self_attn.k_proj.bias"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MultiHeadDotProductAttention_0/value/kernel", f"text_model.encoder.layers.{i}.self_attn.v_proj.weight"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MultiHeadDotProductAttention_0/value/bias", f"text_model.encoder.layers.{i}.self_attn.v_proj.bias"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MultiHeadDotProductAttention_0/query/kernel", f"text_model.encoder.layers.{i}.self_attn.q_proj.weight"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MultiHeadDotProductAttention_0/query/bias", f"text_model.encoder.layers.{i}.self_attn.q_proj.bias"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MultiHeadDotProductAttention_0/out/kernel", f"text_model.encoder.layers.{i}.self_attn.out_proj.weight"))
-        rename_keys.append((f"params/txt/Encoder_0/encoderblock_{i}/MultiHeadDotProductAttention_0/out/bias", f"text_model.encoder.layers.{i}.self_attn.out_proj.bias"))
-
-    rename_keys.append(("params/txt/Encoder_0/encoder_norm/scale", "text_model.final_layer_norm.weight"))
-    rename_keys.append(("params/txt/Encoder_0/encoder_norm/bias", "text_model.final_layer_norm.bias"))
-    rename_keys.append(("params/txt/head/kernel", "text_model.head.weight"))
-    rename_keys.append(("params/txt/head/bias", "text_model.head.bias"))
-
-    # learned temperature and bias
-    rename_keys.append(("params/t", "logit_scale"))
-    rename_keys.append(("params/b", "logit_bias"))
-
-    # fmt: on
-    return rename_keys
-
-
-def rename_key(dct, old, new, config):
-    val = dct.pop(old)
-
-    if ("out_proj" in new or "v_proj" in new or "k_proj" in new or "q_proj" in new) and "vision" in new:
-        val = val.reshape(-1, config.vision_config.hidden_size)
-    if ("out_proj" in new or "v_proj" in new or "k_proj" in new or "q_proj" in new) and "text" in new:
-        val = val.reshape(-1, config.text_config.hidden_size)
-
-    if "patch_embedding.weight" in new:
-        val = val.transpose(3, 2, 0, 1)
-    elif new.endswith("weight") and "position_embedding" not in new and "token_embedding" not in new:
-        val = val.T
-
-    if "position_embedding" in new and "vision" in new:
-        val = val.reshape(-1, config.vision_config.hidden_size)
-    if "position_embedding" in new and "text" in new:
-        val = val.reshape(-1, config.text_config.hidden_size)
-
-    if new.endswith("bias"):
-        val = val.reshape(-1)
-
-    dct[new] = torch.from_numpy(val)
-
-
-def read_in_q_k_v_head(state_dict, config):
-    # read in individual input projection layers
-    key_proj_weight = (
-        state_dict.pop("params/img/MAPHead_0/MultiHeadDotProductAttention_0/key/kernel")
-        .reshape(-1, config.vision_config.hidden_size)
-        .T
-    )
-    key_proj_bias = state_dict.pop("params/img/MAPHead_0/MultiHeadDotProductAttention_0/key/bias").reshape(-1)
-    value_proj_weight = (
-        state_dict.pop("params/img/MAPHead_0/MultiHeadDotProductAttention_0/value/kernel")
-        .reshape(-1, config.vision_config.hidden_size)
-        .T
-    )
-    value_proj_bias = state_dict.pop("params/img/MAPHead_0/MultiHeadDotProductAttention_0/value/bias").reshape(-1)
-    query_proj_weight = (
-        state_dict.pop("params/img/MAPHead_0/MultiHeadDotProductAttention_0/query/kernel")
-        .reshape(-1, config.vision_config.hidden_size)
-        .T
-    )
-    query_proj_bias = state_dict.pop("params/img/MAPHead_0/MultiHeadDotProductAttention_0/query/bias").reshape(-1)
-
-    # next, add them to the state dict as a single matrix + vector
-    state_dict["vision_model.head.attention.in_proj_weight"] = torch.from_numpy(
-        np.concatenate([query_proj_weight, key_proj_weight, value_proj_weight], axis=0)
-    )
-    state_dict["vision_model.head.attention.in_proj_bias"] = torch.from_numpy(
-        np.concatenate([query_proj_bias, key_proj_bias, value_proj_bias], axis=0)
-    )
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-    return image
-
-
-def flatten_nested_dict(params, parent_key="", sep="/"):
-    items = []
-
-    for k, v in params.items():
-        new_key = parent_key + sep + k if parent_key else k
-
-        if isinstance(v, collections.abc.MutableMapping):
-            items.extend(flatten_nested_dict(v, new_key, sep=sep).items())
-        else:
-            items.append((new_key, v))
-    return dict(items)
-
-
-@torch.no_grad()
-def convert_siglip_checkpoint(model_name, pytorch_dump_folder_path, verify_logits=True, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our SigLIP structure.
-    """
-
-    # Define default SigLIP configuration
-    config = get_siglip_config(model_name)
-
-    # Get checkpoint
-    checkpoint = model_name_to_checkpoint[model_name]
-    if not os.path.exists(checkpoint):
-        org, repo_id, *filepath = checkpoint.split("/")
-        checkpoint = hf_hub_download(repo_id=f"{org}/{repo_id}", filename="/".join(filepath))
-
-    # Load original state dict
-    data = load(checkpoint)
-    state_dict = flatten_nested_dict(data)
-    state_dict = split_encoderblock_layers(state_dict)
-
-    # Remove and rename some keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest, config)
-
-    # qkv matrices of attention pooling head need special treatment
-    read_in_q_k_v_head(state_dict, config)
-
-    # Load HuggingFace model
-    model = SiglipModel(config).eval()
-    model.load_state_dict(state_dict)
-
-    # Create processor
-    image_processor = get_image_processor(model_name)
-    tokenizer = get_tokenizer(model_name)
-    processor = SiglipProcessor(image_processor=image_processor, tokenizer=tokenizer)
-
-    # Verify forward pass on dummy images and texts
-    url_1 = "https://cdn.openai.com/multimodal-neurons/assets/apple/apple-ipod.jpg"
-    image_1 = Image.open(requests.get(url_1, stream=True).raw).convert("RGB")
-    url_2 = "https://cdn.openai.com/multimodal-neurons/assets/apple/apple-blank.jpg"
-    image_2 = Image.open(requests.get(url_2, stream=True).raw).convert("RGB")
-    texts = ["an apple", "a picture of an apple"]
-
-    inputs = processor(images=[image_1, image_2], text=texts, padding="max_length", max_length=64, return_tensors="pt")
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    if verify_logits:
-        image_size = config.vision_config.image_size
-
-        # verify input_ids against original ones
-        if image_size == 224:
-            filename = "siglip_pixel_values.pt"
-        elif image_size == 256:
-            filename = "siglip_pixel_values_256.pt"
-        elif image_size == 384:
-            filename = "siglip_pixel_values_384.pt"
-        elif image_size == 512:
-            filename = "siglip_pixel_values_512.pt"
-        else:
-            raise ValueError("Image size not supported")
-
-        filepath = hf_hub_download(repo_id="nielsr/test-image", filename=filename, repo_type="dataset")
-        original_pixel_values = torch.load(filepath)
-        filepath = hf_hub_download(repo_id="nielsr/test-image", filename="siglip_input_ids.pt", repo_type="dataset")
-        original_input_ids = torch.load(filepath)
-
-        if "i18n" not in model_name:
-            assert inputs.input_ids.tolist() == original_input_ids.tolist()
-
-        print("Mean of original pixel values:", original_pixel_values.mean())
-        print("Mean of new pixel values:", inputs.pixel_values.mean())
-
-        # note: we're testing with original pixel values here since we don't have exact pixel values
-        with torch.no_grad():
-            outputs = model(input_ids=original_input_ids, pixel_values=original_pixel_values)
-        print(outputs.logits_per_image[:3, :3])
-
-        probs = torch.sigmoid(outputs.logits_per_image)  # these are the probabilities
-        print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
-        print(f"{probs[0][1]:.1%} that image 0 is '{texts[1]}'")
-
-        if model_name == "siglip-base-patch16-224":
-            expected_slice = torch.tensor(
-                [[-2.9621, -2.1672], [-0.2713, 0.2910]],
-            )
-        elif model_name == "siglip-base-patch16-256":
-            expected_slice = torch.tensor(
-                [[-3.1146, -1.9894], [-0.7312, 0.6387]],
-            )
-        elif model_name == "siglip-base-patch16-384":
-            expected_slice = torch.tensor(
-                [[-2.8098, -2.1891], [-0.4242, 0.4102]],
-            )
-        elif model_name == "siglip-base-patch16-512":
-            expected_slice = torch.tensor(
-                [[-2.7899, -2.2668], [-0.4295, -0.0735]],
-            )
-        elif model_name == "siglip-large-patch16-256":
-            expected_slice = torch.tensor(
-                [[-1.5827, -0.5801], [-0.9153, 0.1363]],
-            )
-        elif model_name == "siglip-large-patch16-384":
-            expected_slice = torch.tensor(
-                [[-2.1523, -0.2899], [-0.2959, 0.7884]],
-            )
-        elif model_name == "siglip-so400m-patch14-384":
-            expected_slice = torch.tensor([[-1.2441, -0.6649], [-0.7060, 0.7374]])
-        elif model_name == "siglip-base-patch16-256-i18n":
-            expected_slice = torch.tensor(
-                [[-0.9064, 0.1073], [-0.0299, 0.5304]],
-            )
-
-        assert torch.allclose(outputs.logits_per_image[:3, :3], expected_slice, atol=1e-4)
-        print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        pytorch_dump_folder_path = os.path.join(pytorch_dump_folder_path, model_name)
-        os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving processor to {pytorch_dump_folder_path}")
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub(f"s0225/{model_name}", private=True)
-        processor.push_to_hub(f"s0225/{model_name}", private=True)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="siglip-base-patch16-224",
-        type=str,
-        choices=model_name_to_checkpoint.keys(),
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_true",
-        help="Whether to verify logits against the original implementation.",
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_siglip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.verify_logits, args.push_to_hub)
diff --git a/src/transformers/models/siglip2/convert_siglip2_to_hf.py b/src/transformers/models/siglip2/convert_siglip2_to_hf.py
deleted file mode 100644
index 819596498996..000000000000
--- a/src/transformers/models/siglip2/convert_siglip2_to_hf.py
+++ /dev/null
@@ -1,438 +0,0 @@
-# coding=utf-8
-# Copyright 2025 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Siglip2 checkpoints from the original repository.
-
-URL: https://github.com/google-research/big_vision/tree/main
-"""
-
-import argparse
-import collections
-import os
-import re
-
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image, ImageDraw
-
-from transformers import GemmaTokenizerFast, Siglip2Config, Siglip2ImageProcessorFast, Siglip2Model, Siglip2Processor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-COMMON_CONFIG_PARAMS = {
-    "base": {
-        "hidden_size": 768,
-        "intermediate_size": 3072,
-        "num_hidden_layers": 12,
-        "num_attention_heads": 12,
-    },
-    "large": {
-        "hidden_size": 1024,
-        "intermediate_size": 4096,
-        "num_hidden_layers": 24,
-        "num_attention_heads": 16,
-    },
-    "so400m": {
-        "hidden_size": 1152,
-        "intermediate_size": 4304,
-        "num_hidden_layers": 27,
-        "num_attention_heads": 16,
-    },
-}
-
-MODEL_NAME_TO_CHECKPOINT_PATH = {
-    # base checkpoints
-    "siglip2-base-patch16-naflex": "gv-hf/siglip2/siglip2_b16_naflex.npz",
-    "siglip2-so400m-patch16-naflex": "gv-hf/siglip2/siglip2_so400m16_naflex.npz",
-}
-
-# fmt: off
-EXPECTED_OUTPUTS = {
-    "siglip2-base-patch16-naflex": torch.tensor([
-        [  1.0195,  -0.0280,  -1.4468],
-        [ -4.5395,  -6.2269,  -1.5667],
-        [  4.1757,   5.0358,   3.5159],
-        [  9.4264,  10.1879,   6.3353],
-        [  2.4409,   3.1058,   4.5491],
-        [-12.3230, -13.7355, -13.4632],
-        [  1.1520,   1.1687,  -1.9647],
-    ]),
-    "siglip2-so400m-patch16-naflex": torch.tensor([
-        [  0.9422,   0.5540,  -2.4405],
-        [ -7.3522,  -9.4931,  -6.3499],
-        [  5.7852,   6.7288,   7.7893],
-        [  9.9881,  10.8136,   9.2121],
-        [  5.3660,   5.7746,   8.4130],
-        [-12.7218, -14.2631, -13.6442],
-        [  0.6384,   0.4278,  -0.9022],
-    ]),
-}
-# fmt: on
-
-# fmt: off
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    # Vision embeddings
-    r"params/img/embedding/kernel":                                                                         r"vision_model.embeddings.patch_embedding.weight",
-    r"params/img/embedding/bias":                                                                           r"vision_model.embeddings.patch_embedding.bias",
-    r"params/img/pos_embedding":                                                                            r"vision_model.embeddings.position_embedding.weight",
-    # Vision encoder
-    r"params/img/Transformer/encoderblock_(\d+)/LayerNorm_0/scale":                                         r"vision_model.encoder.layers.\1.layer_norm1.weight",
-    r"params/img/Transformer/encoderblock_(\d+)/LayerNorm_0/bias":                                          r"vision_model.encoder.layers.\1.layer_norm1.bias",
-    r"params/img/Transformer/encoderblock_(\d+)/LayerNorm_1/scale":                                         r"vision_model.encoder.layers.\1.layer_norm2.weight",
-    r"params/img/Transformer/encoderblock_(\d+)/LayerNorm_1/bias":                                          r"vision_model.encoder.layers.\1.layer_norm2.bias",
-    r"params/img/Transformer/encoderblock_(\d+)/MlpBlock_0/Dense_0/kernel":                                 r"vision_model.encoder.layers.\1.mlp.fc1.weight",
-    r"params/img/Transformer/encoderblock_(\d+)/MlpBlock_0/Dense_0/bias":                                   r"vision_model.encoder.layers.\1.mlp.fc1.bias",
-    r"params/img/Transformer/encoderblock_(\d+)/MlpBlock_0/Dense_1/kernel":                                 r"vision_model.encoder.layers.\1.mlp.fc2.weight",
-    r"params/img/Transformer/encoderblock_(\d+)/MlpBlock_0/Dense_1/bias":                                   r"vision_model.encoder.layers.\1.mlp.fc2.bias",
-    r"params/img/Transformer/encoderblock_(\d+)/MultiHeadDotProductAttention_0/(q|k|v|out)[a-z]*/kernel":   r"vision_model.encoder.layers.\1.self_attn.\2_proj.weight",
-    r"params/img/Transformer/encoderblock_(\d+)/MultiHeadDotProductAttention_0/(q|k|v|out)[a-z]*/bias":     r"vision_model.encoder.layers.\1.self_attn.\2_proj.bias",
-    # Vision norm
-    r"params/img/Transformer/encoder_norm/scale":                                                           r"vision_model.post_layernorm.weight",
-    r"params/img/Transformer/encoder_norm/bias":                                                            r"vision_model.post_layernorm.bias",
-    # Vision head
-    r"params/img/MAPHead_0/probe":                                                                          r"vision_model.head.probe",
-    r"params/img/MAPHead_0/LayerNorm_0/scale":                                                              r"vision_model.head.layernorm.weight",
-    r"params/img/MAPHead_0/LayerNorm_0/bias":                                                               r"vision_model.head.layernorm.bias",
-    r"params/img/MAPHead_0/MlpBlock_0/Dense_0/kernel":                                                      r"vision_model.head.mlp.fc1.weight",
-    r"params/img/MAPHead_0/MlpBlock_0/Dense_0/bias":                                                        r"vision_model.head.mlp.fc1.bias",
-    r"params/img/MAPHead_0/MlpBlock_0/Dense_1/kernel":                                                      r"vision_model.head.mlp.fc2.weight",
-    r"params/img/MAPHead_0/MlpBlock_0/Dense_1/bias":                                                        r"vision_model.head.mlp.fc2.bias",
-    r"params/img/MAPHead_0/MultiHeadDotProductAttention_0/out/kernel":                                      r"vision_model.head.attention.out_proj.weight",
-    r"params/img/MAPHead_0/MultiHeadDotProductAttention_0/out/bias":                                        r"vision_model.head.attention.out_proj.bias",
-    r"params/img/MAPHead_0/MultiHeadDotProductAttention_0/qkv/kernel":                                      r"vision_model.head.attention.in_proj_weight",
-    r"params/img/MAPHead_0/MultiHeadDotProductAttention_0/qkv/bias":                                        r"vision_model.head.attention.in_proj_bias",
-    # Text embeddings
-    r"params/txt/Embed_0/embedding":                                                                        r"text_model.embeddings.token_embedding.weight",
-    r"params/txt/pos_embedding":                                                                            r"text_model.embeddings.position_embedding.weight",
-    # Text encoder
-    r"params/txt/Encoder_0/encoderblock_(\d+)/LayerNorm_0/scale":                                           r"text_model.encoder.layers.\1.layer_norm1.weight",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/LayerNorm_0/bias":                                            r"text_model.encoder.layers.\1.layer_norm1.bias",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/LayerNorm_1/scale":                                           r"text_model.encoder.layers.\1.layer_norm2.weight",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/LayerNorm_1/bias":                                            r"text_model.encoder.layers.\1.layer_norm2.bias",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/MlpBlock_0/Dense_0/kernel":                                   r"text_model.encoder.layers.\1.mlp.fc1.weight",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/MlpBlock_0/Dense_0/bias":                                     r"text_model.encoder.layers.\1.mlp.fc1.bias",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/MlpBlock_0/Dense_1/kernel":                                   r"text_model.encoder.layers.\1.mlp.fc2.weight",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/MlpBlock_0/Dense_1/bias":                                     r"text_model.encoder.layers.\1.mlp.fc2.bias",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/MultiHeadDotProductAttention_0/(q|k|v|out)[a-z]*/kernel":     r"text_model.encoder.layers.\1.self_attn.\2_proj.weight",
-    r"params/txt/Encoder_0/encoderblock_(\d+)/MultiHeadDotProductAttention_0/(q|k|v|out)[a-z]*/bias":       r"text_model.encoder.layers.\1.self_attn.\2_proj.bias",
-    # Text encoder norm and head
-    r"params/txt/Encoder_0/encoder_norm/scale":                                                             r"text_model.final_layer_norm.weight",
-    r"params/txt/Encoder_0/encoder_norm/bias":                                                              r"text_model.final_layer_norm.bias",
-    r"params/txt/head/kernel":                                                                              r"text_model.head.weight",
-    r"params/txt/head/bias":                                                                                r"text_model.head.bias",
-    # learned temperature and bias
-    r"params/t":                                                                                            r"logit_scale",
-    r"params/b":                                                                                            r"logit_bias",
-}
-# fmt: on
-
-
-# --------------------------------------------------------------------------------------------
-# Model objects: configuration, tokenizer, image processor
-# --------------------------------------------------------------------------------------------
-
-
-def get_siglip2_config(model_name: str) -> Siglip2Config:
-    """
-    Create a configuration for the Siglip2 model based on the model name.
-    """
-
-    _, variant, patch, _ = model_name.split("-")
-    patch_size = int(patch[-2:])
-    num_patches = 256
-
-    common_options = COMMON_CONFIG_PARAMS[variant]
-    vision_config = {
-        "patch_size": patch_size,
-        "num_patches": num_patches,
-        **common_options,
-    }
-    text_config = {
-        "vocab_size": 256_000,
-        **common_options,
-    }
-    config = Siglip2Config(
-        vision_config=vision_config,
-        text_config=text_config,
-    )
-    return config
-
-
-def get_siglip2_tokenizer() -> GemmaTokenizerFast:
-    # Load pretrained tokenizer
-    gemma_checkpoint = "google/gemma-7b"
-    tokenizer = GemmaTokenizerFast.from_pretrained(
-        gemma_checkpoint,
-        add_bos_token=False,
-        add_eos_token=True,
-        padding_side="right",
-        do_lower_case=True,
-        # important: make tokenizer NOT return attention_mask since original one doesn't require it
-        model_input_names=["input_ids"],
-    )
-    return tokenizer
-
-
-def get_siglip2_image_processor(patch_size: int, max_num_patches: int) -> Siglip2ImageProcessorFast:
-    image_processor = Siglip2ImageProcessorFast(
-        patch_size=patch_size,
-        max_num_patches=max_num_patches,
-        do_resize=True,
-        do_normalize=True,
-        image_mean=[0.5, 0.5, 0.5],
-        image_std=[0.5, 0.5, 0.5],
-        do_rescale=True,
-        rescale_factor=1 / 255,
-        resample=Image.Resampling.BILINEAR,
-    )
-    return image_processor
-
-
-# --------------------------------------------------------------------------------------------
-# Helper functions for state dict conversion
-# --------------------------------------------------------------------------------------------
-
-
-def flatten_nested_dict(params: dict, parent_key: str = "", sep: str = "/") -> dict:
-    """
-    Flatten a nested original checkpoint dictionary into a flat dictionary.
-    """
-    items = []
-    for k, v in params.items():
-        new_key = parent_key + sep + k if parent_key else k
-        if isinstance(v, collections.abc.MutableMapping):
-            items.extend(flatten_nested_dict(v, new_key, sep=sep).items())
-        else:
-            items.append((new_key, v))
-    return dict(items)
-
-
-def split_encoderblock_layers(state_dict: dict) -> dict:
-    """
-    Split the encoderblock weight into layers. In some cases they are concatenated in
-    the original checkpoints.
-    """
-    # Make shallow copy
-    state_dict = state_dict.copy()
-    # Split encoderblock weight into layers
-    keys = list(state_dict.keys())
-    for key in keys:
-        if "/encoderblock/" in key:
-            weight = state_dict.pop(key)
-            for i, weight_i in enumerate(weight):
-                new_name = key.replace("encoderblock", f"encoderblock_{i}")
-                state_dict[new_name] = weight_i
-    return state_dict
-
-
-def merge_qkv_for_head(state_dict: dict, config: Siglip2Config) -> dict:
-    """
-    Merge the q/k/v weights and biases for the attention head.
-    """
-    # Make shallow copy
-    state_dict = state_dict.copy()
-    # Read and process q/k/v weights and biases
-    qkv_weights, qkv_biases = [], []
-    for name in ["query", "key", "value"]:
-        prefix = f"params/img/MAPHead_0/MultiHeadDotProductAttention_0/{name}"
-        weight = state_dict.pop(f"{prefix}/kernel").reshape(-1, config.vision_config.hidden_size)
-        bias = state_dict.pop(f"{prefix}/bias").reshape(-1)
-        qkv_weights.append(weight)
-        qkv_biases.append(bias)
-
-    # Combine into single tensors
-    state_dict["params/img/MAPHead_0/MultiHeadDotProductAttention_0/qkv/kernel"] = np.concatenate(qkv_weights, axis=1)
-    state_dict["params/img/MAPHead_0/MultiHeadDotProductAttention_0/qkv/bias"] = np.concatenate(qkv_biases, axis=0)
-    return state_dict
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: list) -> dict:
-    """
-    This function should be applied only once, on the concatenated keys to efficiently rename using
-    the key mappings.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-        for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-            if replacement is None:
-                new_text = re.sub(pattern, "", new_text)  # an empty line
-                continue
-            new_text = re.sub(pattern, replacement, new_text)
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-    return output_dict
-
-
-# --------------------------------------------------------------------------------------------
-# Helper functions for model verification
-# --------------------------------------------------------------------------------------------
-
-
-def create_image(width, height):
-    """
-    Helper function to create an image with a blue circle on a red background.
-    """
-    image = Image.new("RGB", (width, height), color="red")
-    draw = ImageDraw.Draw(image)
-    center_x = image.width // 2
-    center_y = image.height // 2
-    radius = min(center_x, center_y) // 8 * 7
-    draw.ellipse(
-        (center_x - radius, center_y - radius, center_x + radius, center_y + radius),
-        fill="blue",
-        outline="green",
-        width=image.width // 20,
-    )
-    return image
-
-
-def prepare_inputs():
-    """
-    Prepare inputs for the model.
-    """
-    text = [
-        "circle",
-        "ellipsoid",
-        "blue circle on red background",
-        "blue circle with green border on red background",
-        "green circle on red background",
-        "a dog",
-        "a blue dog with a green border on a red background",
-    ]
-    img224 = create_image(224, 224)
-    img1024 = create_image(1024, 1024)
-    img224_1024 = create_image(1024, 224)
-
-    images = [img224, img1024, img224_1024]
-    return text, images
-
-
-# --------------------------------------------------------------------------------------------
-# Convert model
-# --------------------------------------------------------------------------------------------
-
-
-@torch.no_grad()
-def convert_siglip2_checkpoint(model_name, pytorch_dump_folder_path, verify_logits=True, push_to_hub=False):
-    """
-    Copy/paste/tweak model's weights to our Siglip2 structure.
-    """
-
-    # Define Siglip2 configuration
-    config = get_siglip2_config(model_name)
-
-    checkpoint = MODEL_NAME_TO_CHECKPOINT_PATH[model_name]
-    if not os.path.exists(checkpoint):
-        org, repo_id, *filepath = checkpoint.split("/")
-        checkpoint = hf_hub_download(repo_id=f"{org}/{repo_id}", filename="/".join(filepath))
-
-    print(f"Loading checkpoint from {checkpoint}...")
-    data = np.load(checkpoint)
-    state_dict = flatten_nested_dict(data)
-    state_dict = split_encoderblock_layers(state_dict)
-    state_dict = merge_qkv_for_head(state_dict, config)
-
-    # Rename and transform weights
-    print("Renaming and transforming weights...")
-
-    original_keys = list(state_dict.keys())
-    hf_keys = convert_old_keys_to_new_keys(original_keys)
-
-    new_state_dict = {}
-    for original_key in original_keys:
-        new_key = hf_keys[original_key]
-        parameter = state_dict.pop(original_key)
-
-        hidden_size = config.vision_config.hidden_size if "vision" in new_key else config.text_config.hidden_size
-
-        if any(k in new_key for k in ("out_proj", "q_proj", "k_proj", "v_proj", "position_embedding")):
-            parameter = parameter.reshape(-1, hidden_size)
-
-        # Transpose every weight except for position_embedding and token_embedding
-        if new_key.endswith("weight") and "position_embedding" not in new_key and "token_embedding" not in new_key:
-            parameter = parameter.T
-
-        # Reshape every bias
-        if new_key.endswith("bias"):
-            parameter = parameter.reshape(-1)
-
-        new_state_dict[new_key] = torch.from_numpy(parameter)
-
-    # load HuggingFace model
-    print("Loading HuggingFace model...")
-    model = Siglip2Model(config).eval()
-    model.load_state_dict(new_state_dict)
-
-    # Create processor
-    print("Creating processor...")
-    # TODO: update with more checkpoints
-    tokenizer = get_siglip2_tokenizer()
-    image_processor = get_siglip2_image_processor(config.vision_config.patch_size, max_num_patches=256)
-    processor = Siglip2Processor(image_processor=image_processor, tokenizer=tokenizer)
-
-    # Verify logits
-    if verify_logits:
-        print(f"Verifying logits for {model_name}...")
-        text, images = prepare_inputs()
-        inputs = processor(text=text, images=images, padding="max_length", max_length=64, return_tensors="pt")
-        outputs = model(**inputs)
-        torch.testing.assert_close(outputs.logits_per_text, EXPECTED_OUTPUTS[model_name], atol=1e-3, rtol=1e-3)
-
-    # Save model
-    if pytorch_dump_folder_path is not None:
-        dst_dir = os.path.join(pytorch_dump_folder_path, model_name)
-        print(f"Saving model {model_name} to {dst_dir}...")
-        model.save_pretrained(dst_dir)
-        print(f"Saving processor to {dst_dir}...")
-        processor.save_pretrained(dst_dir)
-
-    if push_to_hub:
-        print(f"Pushing model and processor for {model_name} to the HuggingFace Hub...")
-        model.push_to_hub(f"qubvel-hf/{model_name}", private=True)
-        processor.push_to_hub(f"qubvel-hf/{model_name}", private=True)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="siglip2-base-patch16-naflex",
-        type=str,
-        choices=MODEL_NAME_TO_CHECKPOINT_PATH.keys(),
-        help="Name of the model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="checkpoints/",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--verify_logits",
-        action="store_true",
-        help="Whether to verify logits against the original implementation.",
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_siglip2_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.verify_logits, args.push_to_hub)
diff --git a/src/transformers/models/speech_encoder_decoder/convert_mbart_wav2vec2_seq2seq_original_to_pytorch.py b/src/transformers/models/speech_encoder_decoder/convert_mbart_wav2vec2_seq2seq_original_to_pytorch.py
deleted file mode 100644
index bdd57c84f544..000000000000
--- a/src/transformers/models/speech_encoder_decoder/convert_mbart_wav2vec2_seq2seq_original_to_pytorch.py
+++ /dev/null
@@ -1,357 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Wav2Vec2 checkpoint."""
-
-import argparse
-
-import fairseq
-import torch
-from torch import nn
-
-from transformers import (
-    MBart50Tokenizer,
-    MBartConfig,
-    MBartForCausalLM,
-    SpeechEncoderDecoderConfig,
-    SpeechEncoderDecoderModel,
-    Wav2Vec2Config,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2Model,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "quantizer.weight_proj": "quantizer.weight_proj",
-    "quantizer.vars": "quantizer.codevectors",
-    "project_q": "project_q",
-    "final_proj": "project_hid",
-    "w2v_encoder.proj": "lm_head",
-    "mask_emb": "masked_spec_embed",
-}
-TOP_LEVEL_KEYS = [
-    "lm_head",
-    "quantizer.weight_proj",
-    "quantizer.codevectors",
-    "project_q",
-    "project_hid",
-]
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    assert hf_shape == value.shape, (
-        f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-        f" {value.shape} for {full_name}"
-    )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights_wav2vec2(fairseq_model, hf_model):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.feature_extractor
-    adapter = hf_model.adapter
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        elif any(x in name for x in ["adaptor", "w2v_encoder.proj.", "w2v_proj_ln."]):
-            load_adapter(name, value, adapter, unused_weights)
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    elif "weight" in name:
-                        weight_type = "weight"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
-                " found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-def load_adapter(full_name, value, adapter, unused_weights):
-    name = full_name.split("adaptor.")[-1]
-    items = name.split(".")
-
-    if items[1].isdigit():
-        layer_id = int(items[1])
-    else:
-        layer_id = None
-
-    if "adaptor" not in full_name:
-        if "proj_ln" in full_name:
-            # has to be layer norm
-            if "bias" in name:
-                assert value.shape == adapter.proj_layer_norm.bias.data.shape, (
-                    f"{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found."
-                )
-                adapter.proj_layer_norm.bias.data = value
-                logger.info(f"Adapter proj layer norm bias was initialized from {full_name}.")
-            if "weight" in name:
-                assert value.shape == adapter.proj_layer_norm.weight.data.shape, (
-                    f"{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found."
-                )
-                adapter.proj_layer_norm.weight.data = value
-        else:
-            # has to be projection layer
-            if "bias" in name:
-                assert value.shape == adapter.proj.bias.data.shape, (
-                    f"{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found."
-                )
-                adapter.proj.bias.data = value
-                logger.info(f"Adapter proj layer bias was initialized from {full_name}.")
-            if "weight" in name:
-                assert value.shape == adapter.proj.weight.data.shape, (
-                    f"{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found."
-                )
-                adapter.proj.weight.data = value
-                logger.info(f"Adapter proj layer weight was initialized from {full_name}.")
-    elif isinstance(layer_id, int):
-        if "bias" in name:
-            assert value.shape == adapter.layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found."
-            )
-            adapter.layers[layer_id].conv.bias.data = value
-            logger.info(f"Adapter layer {layer_id} bias was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == adapter.layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found."
-            )
-            adapter.layers[layer_id].conv.weight.data = value
-            logger.info(f"Adapter layer {layer_id} bias was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-@torch.no_grad()
-def convert_wav2vec2_checkpoint(
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    dict_path,
-    config_yaml_path,
-    encoder_config_path,
-    decoder_config_path,
-    add_adapter,
-    adapter_kernel_size,
-    adapter_stride,
-    decoder_start_token_id,
-    encoder_output_dim,
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    # load configs
-    encoder_config = Wav2Vec2Config.from_pretrained(
-        encoder_config_path,
-        add_adapter=True,
-        adapter_stride=adapter_stride,
-        adapter_kernel_size=adapter_kernel_size,
-        token_token=True,
-        output_hidden_size=encoder_output_dim,
-    )
-    decoder_config = MBartConfig.from_pretrained(decoder_config_path)
-
-    # load model
-    model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-        [checkpoint_path],
-        arg_overrides={
-            "config_yaml": config_yaml_path,
-            "data": "/".join(dict_path.split("/")[:-1]),
-            "w2v_path": checkpoint_path,
-            "load_pretrained_decoder_from": None,
-        },
-    )
-    model = model[0].eval()
-
-    # load feature extractor
-    feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(encoder_config_path, token_token=True)
-
-    # set weights for wav2vec2 encoder
-    hf_encoder = Wav2Vec2Model(encoder_config)
-
-    recursively_load_weights_wav2vec2(model.encoder, hf_encoder)
-
-    # load decoder weights
-    hf_decoder = MBartForCausalLM(decoder_config)
-    missing_keys, unexpected_keys = hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict(), strict=False)
-    logger.warning(f"The following keys are missing when loading the decoder weights: {missing_keys}")
-    logger.warning(f"The following keys are unexpected when loading the decoder weights: {unexpected_keys}")
-
-    hf_wav2vec = SpeechEncoderDecoderModel(encoder=hf_encoder, decoder=hf_decoder)
-    hf_wav2vec.config.tie_word_embeddings = False
-
-    tokenizer = MBart50Tokenizer(dict_path)
-    tokenizer.save_pretrained(pytorch_dump_folder_path)
-
-    config = hf_wav2vec.config.to_dict()
-    config["pad_token_id"] = tokenizer.pad_token_id
-    config["bos_token_id"] = tokenizer.bos_token_id
-    config["eos_token_id"] = tokenizer.eos_token_id
-    config["tokenizer_class"] = "mbart50"
-    config["feature_extractor_type"] = "wav2vec2"
-
-    config["decoder_start_token_id"] = tokenizer.eos_token_id
-    config["forced_bos_token_id"] = 250004
-    config["forced_eos_token_id"] = tokenizer.eos_token_id
-
-    hf_wav2vec.config = SpeechEncoderDecoderConfig.from_dict(config)
-
-    hf_wav2vec.save_pretrained(pytorch_dump_folder_path)
-    feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_yaml_path", default=None, type=str, help="Path to yaml file of fine-tuned model")
-    parser.add_argument(
-        "--encoder_config_path",
-        default="facebook/wav2vec2-xls-r-1b",
-        type=str,
-        help="Path to hf encoder wav2vec2 checkpoint config",
-    )
-    parser.add_argument(
-        "--decoder_config_path",
-        default="facebook/mbart-large-50-one-to-many-mmt",
-        type=str,
-        help="Path to hf decoder checkpoint config",
-    )
-    parser.add_argument("--add_adapter", default=True, type=bool, help="whethere to add model adapter layers")
-    parser.add_argument("--adapter_stride", default=2, type=int, help="stride of adapter layers")
-    parser.add_argument("--adapter_kernel_size", default=3, type=int, help="kernel size of adapter layers")
-    parser.add_argument("--encoder_output_dim", default=1024, type=int, help="encoder output dim")
-    parser.add_argument("--start_token_id", default=250004, type=int, help="`decoder_start_token_id` of model config")
-
-    args = parser.parse_args()
-    convert_wav2vec2_checkpoint(
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.dict_path,
-        args.config_yaml_path,
-        encoder_config_path=args.encoder_config_path,
-        decoder_config_path=args.decoder_config_path,
-        add_adapter=args.add_adapter,
-        adapter_kernel_size=args.adapter_kernel_size,
-        adapter_stride=args.adapter_stride,
-        decoder_start_token_id=args.start_token_id,
-        encoder_output_dim=args.encoder_output_dim,
-    )
diff --git a/src/transformers/models/speech_encoder_decoder/convert_speech_to_text_wav2vec2_seq2seq_original_to_pytorch.py b/src/transformers/models/speech_encoder_decoder/convert_speech_to_text_wav2vec2_seq2seq_original_to_pytorch.py
deleted file mode 100644
index 377288982087..000000000000
--- a/src/transformers/models/speech_encoder_decoder/convert_speech_to_text_wav2vec2_seq2seq_original_to_pytorch.py
+++ /dev/null
@@ -1,316 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Wav2Vec2 checkpoint."""
-
-import argparse
-import json
-import os
-
-import fairseq
-import torch
-from torch import nn
-
-from transformers import (
-    Speech2Text2Config,
-    Speech2Text2ForCausalLM,
-    Speech2Text2Tokenizer,
-    SpeechEncoderDecoderConfig,
-    SpeechEncoderDecoderModel,
-    Wav2Vec2Config,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2Model,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "quantizer.weight_proj": "quantizer.weight_proj",
-    "quantizer.vars": "quantizer.codevectors",
-    "project_q": "project_q",
-    "final_proj": "project_hid",
-    "w2v_encoder.proj": "lm_head",
-    "mask_emb": "masked_spec_embed",
-}
-TOP_LEVEL_KEYS = [
-    "lm_head",
-    "quantizer.weight_proj",
-    "quantizer.codevectors",
-    "project_q",
-    "project_hid",
-]
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    assert hf_shape == value.shape, (
-        f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-        f" {value.shape} for {full_name}"
-    )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights_wav2vec2(fairseq_model, hf_model):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.feature_extractor
-
-    # if encoder has different dim to decoder -> use proj_weight
-    proj_weight = None
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        elif name.split(".")[0] == "proj":
-            proj_weight = fairseq_model.proj
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    elif "weight" in name:
-                        weight_type = "weight"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-    return proj_weight
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
-                " found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-def create_vocab_dict(dict_path):
-    with open(dict_path, "r", encoding="utf-8") as f:
-        lines = f.readlines()
-        words = [line.split(" ")[0] for line in lines]
-
-    num_words = len(words)
-
-    vocab_dict = {
-        "<s>": 0,
-        "<pad>": 1,
-        "</s>": 2,
-        "<unk>": 3,
-    }
-
-    vocab_dict.update(dict(zip(words, range(4, num_words + 4))))
-    return vocab_dict
-
-
-@torch.no_grad()
-def convert_wav2vec2_checkpoint(
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    dict_path,
-    encoder_config_path,
-    decoder_config_path,
-    vocab_size,
-    num_decoder_layers,
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    encoder_config = Wav2Vec2Config.from_pretrained(encoder_config_path)
-    decoder_config = Speech2Text2Config.from_pretrained(
-        decoder_config_path, vocab_size=vocab_size, decoder_layers=num_decoder_layers, do_stable_layer_norm=True
-    )
-
-    feature_extractor = Wav2Vec2FeatureExtractor(
-        feature_size=1,
-        sampling_rate=16000,
-        padding_value=0,
-        do_normalize=True,
-        return_attention_mask=True,
-    )
-
-    model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-        [checkpoint_path], arg_overrides={"data": "/".join(dict_path.split("/")[:-1])}
-    )
-    model = model[0].eval()
-
-    # set weights for wav2vec2 encoder
-    hf_encoder = Wav2Vec2Model(encoder_config)
-    projection_layer = recursively_load_weights_wav2vec2(model.encoder, hf_encoder)
-
-    hf_decoder = Speech2Text2ForCausalLM(decoder_config)
-    missing_keys, unexpected_keys = hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict(), strict=False)
-
-    # set output linear layer
-    unexpected_keys.remove("embed_out")
-    hf_decoder.lm_head.weight = nn.Parameter(model.decoder.embed_out.detach())
-
-    # layer norm is init to identity matrix so leaving it is fine
-    logger.warning(f"The following keys are missing when loading the decoder weights: {missing_keys}")
-    logger.warning(f"The following keys are unexpected when loading the decoder weights: {unexpected_keys}")
-
-    hf_wav2vec = SpeechEncoderDecoderModel(encoder=hf_encoder, decoder=hf_decoder)
-    hf_wav2vec.config.tie_word_embeddings = False
-
-    # add projection layer
-    hf_wav2vec.enc_to_dec_proj.weight = nn.Parameter(projection_layer.weight)
-    hf_wav2vec.enc_to_dec_proj.bias = nn.Parameter(projection_layer.bias)
-
-    vocab_dict = create_vocab_dict(dict_path)
-
-    with open(os.path.join(pytorch_dump_folder_path, "vocab.json"), "w") as fp:
-        json.dump(vocab_dict, fp)
-
-    tokenizer = Speech2Text2Tokenizer(os.path.join(pytorch_dump_folder_path, "vocab.json"))
-    tokenizer.save_pretrained(pytorch_dump_folder_path)
-
-    config = hf_wav2vec.config.to_dict()
-    config["pad_token_id"] = tokenizer.pad_token_id
-    config["bos_token_id"] = tokenizer.bos_token_id
-    config["eos_token_id"] = tokenizer.eos_token_id
-    config["tokenizer_class"] = "speech_to_text_2"
-    config["feature_extractor_type"] = "wav2vec2"
-
-    hf_wav2vec.config = SpeechEncoderDecoderConfig.from_dict(config)
-
-    hf_wav2vec.save_pretrained(pytorch_dump_folder_path)
-    feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument(
-        "--encoder_config_path",
-        default="facebook/wav2vec2-large-lv60",
-        type=str,
-        help="Path to hf encoder wav2vec2 checkpoint config",
-    )
-    parser.add_argument(
-        "--decoder_config_path",
-        default="facebook/s2t-small-mustc-en-fr-st",
-        type=str,
-        help="Path to hf decoder s2t checkpoint config",
-    )
-    parser.add_argument("--vocab_size", default=10224, type=int, help="Vocab size of decoder")
-    parser.add_argument("--num_decoder_layers", default=7, type=int, help="Number of decoder layers")
-
-    args = parser.parse_args()
-    convert_wav2vec2_checkpoint(
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.dict_path,
-        encoder_config_path=args.encoder_config_path,
-        decoder_config_path=args.decoder_config_path,
-        vocab_size=args.vocab_size,
-        num_decoder_layers=args.num_decoder_layers,
-    )
diff --git a/src/transformers/models/speech_to_text/convert_s2t_fairseq_to_tfms.py b/src/transformers/models/speech_to_text/convert_s2t_fairseq_to_tfms.py
deleted file mode 100644
index eb4d85262479..000000000000
--- a/src/transformers/models/speech_to_text/convert_s2t_fairseq_to_tfms.py
+++ /dev/null
@@ -1,121 +0,0 @@
-# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import torch
-from torch import nn
-
-from transformers import Speech2TextConfig, Speech2TextForConditionalGeneration
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = [
-        "encoder.version",
-        "decoder.version",
-        "model.encoder.version",
-        "model.decoder.version",
-        "decoder.output_projection.weight",
-        "_float_tensor",
-        "encoder.embed_positions._float_tensor",
-        "decoder.embed_positions._float_tensor",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_keys(s_dict):
-    keys = list(s_dict.keys())
-    for key in keys:
-        if "transformer_layers" in key:
-            s_dict[key.replace("transformer_layers", "layers")] = s_dict.pop(key)
-        elif "subsample" in key:
-            s_dict[key.replace("subsample", "conv")] = s_dict.pop(key)
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-def convert_fairseq_s2t_checkpoint_to_tfms(checkpoint_path, pytorch_dump_folder_path):
-    m2m_100 = torch.load(checkpoint_path, map_location="cpu")
-    args = m2m_100["args"]
-    state_dict = m2m_100["model"]
-    lm_head_weights = state_dict["decoder.output_projection.weight"]
-
-    remove_ignore_keys_(state_dict)
-    rename_keys(state_dict)
-
-    vocab_size = state_dict["decoder.embed_tokens.weight"].shape[0]
-
-    tie_embeds = args.share_decoder_input_output_embed
-
-    conv_kernel_sizes = [int(i) for i in args.conv_kernel_sizes.split(",")]
-    config = Speech2TextConfig(
-        vocab_size=vocab_size,
-        max_source_positions=args.max_source_positions,
-        max_target_positions=args.max_target_positions,
-        encoder_layers=args.encoder_layers,
-        decoder_layers=args.decoder_layers,
-        encoder_attention_heads=args.encoder_attention_heads,
-        decoder_attention_heads=args.decoder_attention_heads,
-        encoder_ffn_dim=args.encoder_ffn_embed_dim,
-        decoder_ffn_dim=args.decoder_ffn_embed_dim,
-        d_model=args.encoder_embed_dim,
-        dropout=args.dropout,
-        attention_dropout=args.attention_dropout,
-        activation_dropout=args.activation_dropout,
-        activation_function="relu",
-        num_conv_layers=len(conv_kernel_sizes),
-        conv_channels=args.conv_channels,
-        conv_kernel_sizes=conv_kernel_sizes,
-        input_feat_per_channel=args.input_feat_per_channel,
-        input_channels=args.input_channels,
-        tie_word_embeddings=tie_embeds,
-        num_beams=5,
-        max_length=200,
-        use_cache=True,
-        decoder_start_token_id=2,
-        early_stopping=True,
-    )
-
-    model = Speech2TextForConditionalGeneration(config)
-    missing, unexpected = model.model.load_state_dict(state_dict, strict=False)
-    if len(missing) > 0 and not set(missing) <= {
-        "encoder.embed_positions.weights",
-        "decoder.embed_positions.weights",
-    }:
-        raise ValueError(
-            "Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,"
-            f" but all the following weights are missing {missing}"
-        )
-
-    if tie_embeds:
-        model.lm_head = make_linear_from_emb(model.model.decoder.embed_tokens)
-    else:
-        model.lm_head.weight.data = lm_head_weights
-
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("--fairseq_path", type=str, help="Path to the fairseq model (.pt) file.")
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    args = parser.parse_args()
-    convert_fairseq_s2t_checkpoint_to_tfms(args.fairseq_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/speecht5/convert_hifigan.py b/src/transformers/models/speecht5/convert_hifigan.py
deleted file mode 100644
index 4d78bb73af30..000000000000
--- a/src/transformers/models/speecht5/convert_hifigan.py
+++ /dev/null
@@ -1,108 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert SpeechT5 HiFi-GAN checkpoint."""
-
-import argparse
-
-import numpy as np
-import torch
-
-from transformers import SpeechT5HifiGan, SpeechT5HifiGanConfig, logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.speecht5")
-
-
-def load_weights(checkpoint, hf_model, config):
-    hf_model.apply_weight_norm()
-
-    hf_model.conv_pre.weight_g.data = checkpoint["input_conv.weight_g"]
-    hf_model.conv_pre.weight_v.data = checkpoint["input_conv.weight_v"]
-    hf_model.conv_pre.bias.data = checkpoint["input_conv.bias"]
-
-    for i in range(len(config.upsample_rates)):
-        hf_model.upsampler[i].weight_g.data = checkpoint[f"upsamples.{i}.1.weight_g"]
-        hf_model.upsampler[i].weight_v.data = checkpoint[f"upsamples.{i}.1.weight_v"]
-        hf_model.upsampler[i].bias.data = checkpoint[f"upsamples.{i}.1.bias"]
-
-    for i in range(len(config.upsample_rates) * len(config.resblock_kernel_sizes)):
-        for j in range(len(config.resblock_dilation_sizes)):
-            hf_model.resblocks[i].convs1[j].weight_g.data = checkpoint[f"blocks.{i}.convs1.{j}.1.weight_g"]
-            hf_model.resblocks[i].convs1[j].weight_v.data = checkpoint[f"blocks.{i}.convs1.{j}.1.weight_v"]
-            hf_model.resblocks[i].convs1[j].bias.data = checkpoint[f"blocks.{i}.convs1.{j}.1.bias"]
-
-            hf_model.resblocks[i].convs2[j].weight_g.data = checkpoint[f"blocks.{i}.convs2.{j}.1.weight_g"]
-            hf_model.resblocks[i].convs2[j].weight_v.data = checkpoint[f"blocks.{i}.convs2.{j}.1.weight_v"]
-            hf_model.resblocks[i].convs2[j].bias.data = checkpoint[f"blocks.{i}.convs2.{j}.1.bias"]
-
-    hf_model.conv_post.weight_g.data = checkpoint["output_conv.1.weight_g"]
-    hf_model.conv_post.weight_v.data = checkpoint["output_conv.1.weight_v"]
-    hf_model.conv_post.bias.data = checkpoint["output_conv.1.bias"]
-
-    hf_model.remove_weight_norm()
-
-
-@torch.no_grad()
-def convert_hifigan_checkpoint(
-    checkpoint_path,
-    stats_path,
-    pytorch_dump_folder_path,
-    config_path=None,
-    repo_id=None,
-):
-    if config_path is not None:
-        config = SpeechT5HifiGanConfig.from_pretrained(config_path)
-    else:
-        config = SpeechT5HifiGanConfig()
-
-    model = SpeechT5HifiGan(config)
-
-    orig_checkpoint = torch.load(checkpoint_path)
-    load_weights(orig_checkpoint["model"]["generator"], model, config)
-
-    stats = np.load(stats_path)
-    mean = stats[0].reshape(-1)
-    scale = stats[1].reshape(-1)
-    model.mean = torch.from_numpy(mean).float()
-    model.scale = torch.from_numpy(scale).float()
-
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument("--stats_path", required=True, default=None, type=str, help="Path to stats.npy file")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_hifigan_checkpoint(
-        args.checkpoint_path,
-        args.stats_path,
-        args.pytorch_dump_folder_path,
-        args.config_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/speecht5/convert_speecht5_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/speecht5/convert_speecht5_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 20dea800d9d1..000000000000
--- a/src/transformers/models/speecht5/convert_speecht5_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,401 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert SpeechT5 checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import (
-    SpeechT5Config,
-    SpeechT5FeatureExtractor,
-    SpeechT5ForSpeechToSpeech,
-    SpeechT5ForSpeechToText,
-    SpeechT5ForTextToSpeech,
-    SpeechT5Processor,
-    SpeechT5Tokenizer,
-    logging,
-)
-from transformers.tokenization_utils import AddedToken
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.speecht5")
-
-MAPPING_SPEECH_ENCODER_PRENET = {
-    "speech_encoder_prenet.layer_norm": "speecht5.encoder.prenet.feature_projection.layer_norm",
-    "speech_encoder_prenet.post_extract_proj": "speecht5.encoder.prenet.feature_projection.projection",
-    "speech_encoder_prenet.pos_conv.0": "speecht5.encoder.prenet.pos_conv_embed.conv",
-    "speech_encoder_prenet.mask_emb": "speecht5.encoder.prenet.masked_spec_embed",
-}
-MAPPING_TEXT_ENCODER_PRENET = {
-    "text_encoder_prenet.encoder_prenet.0": "speecht5.encoder.prenet.embed_tokens",
-    "text_encoder_prenet.encoder_prenet.1.alpha": "speecht5.encoder.prenet.encode_positions.alpha",
-}
-MAPPING_SPEECH_DECODER_PRENET = {
-    "speech_decoder_prenet.decoder_prenet.0.0.prenet.0.0": "speecht5.decoder.prenet.layers.0",
-    "speech_decoder_prenet.decoder_prenet.0.0.prenet.1.0": "speecht5.decoder.prenet.layers.1",
-    "speech_decoder_prenet.decoder_prenet.0.1": "speecht5.decoder.prenet.final_layer",
-    "speech_decoder_prenet.decoder_prenet.1.alpha": "speecht5.decoder.prenet.encode_positions.alpha",
-    "speech_decoder_prenet.spkembs_layer.0": "speecht5.decoder.prenet.speaker_embeds_layer",
-}
-MAPPING_SPEECH_DECODER_POSTNET = {
-    "speech_decoder_postnet.feat_out": "speech_decoder_postnet.feat_out",
-    "speech_decoder_postnet.prob_out": "speech_decoder_postnet.prob_out",
-    "speech_decoder_postnet.postnet.postnet.0.0": "speech_decoder_postnet.layers.0.conv",
-    "speech_decoder_postnet.postnet.postnet.0.1": "speech_decoder_postnet.layers.0.batch_norm",
-    "speech_decoder_postnet.postnet.postnet.1.0": "speech_decoder_postnet.layers.1.conv",
-    "speech_decoder_postnet.postnet.postnet.1.1": "speech_decoder_postnet.layers.1.batch_norm",
-    "speech_decoder_postnet.postnet.postnet.2.0": "speech_decoder_postnet.layers.2.conv",
-    "speech_decoder_postnet.postnet.postnet.2.1": "speech_decoder_postnet.layers.2.batch_norm",
-    "speech_decoder_postnet.postnet.postnet.3.0": "speech_decoder_postnet.layers.3.conv",
-    "speech_decoder_postnet.postnet.postnet.3.1": "speech_decoder_postnet.layers.3.batch_norm",
-    "speech_decoder_postnet.postnet.postnet.4.0": "speech_decoder_postnet.layers.4.conv",
-    "speech_decoder_postnet.postnet.postnet.4.1": "speech_decoder_postnet.layers.4.batch_norm",
-}
-MAPPING_TEXT_DECODER_PRENET = {
-    "text_decoder_prenet.embed_tokens": "speecht5.decoder.prenet.embed_tokens",
-}
-MAPPING_TEXT_DECODER_POSTNET = {
-    "text_decoder_postnet.output_projection": "text_decoder_postnet.lm_head",
-}
-MAPPING_ENCODER = {
-    "encoder.layers.*.self_attn.k_proj": "speecht5.encoder.wrapped_encoder.layers.*.attention.k_proj",
-    "encoder.layers.*.self_attn.v_proj": "speecht5.encoder.wrapped_encoder.layers.*.attention.v_proj",
-    "encoder.layers.*.self_attn.q_proj": "speecht5.encoder.wrapped_encoder.layers.*.attention.q_proj",
-    "encoder.layers.*.self_attn.out_proj": "speecht5.encoder.wrapped_encoder.layers.*.attention.out_proj",
-    "encoder.layers.*.self_attn_layer_norm": "speecht5.encoder.wrapped_encoder.layers.*.layer_norm",
-    "encoder.layers.*.fc1": "speecht5.encoder.wrapped_encoder.layers.*.feed_forward.intermediate_dense",
-    "encoder.layers.*.fc2": "speecht5.encoder.wrapped_encoder.layers.*.feed_forward.output_dense",
-    "encoder.layers.*.final_layer_norm": "speecht5.encoder.wrapped_encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "speecht5.encoder.wrapped_encoder.layer_norm",
-    "encoder.pos_emb.pe_k": "speecht5.encoder.wrapped_encoder.embed_positions.pe_k",
-}
-MAPPING_DECODER = {
-    "decoder.layers.*.self_attn.k_proj": "speecht5.decoder.wrapped_decoder.layers.*.self_attn.k_proj",
-    "decoder.layers.*.self_attn.v_proj": "speecht5.decoder.wrapped_decoder.layers.*.self_attn.v_proj",
-    "decoder.layers.*.self_attn.q_proj": "speecht5.decoder.wrapped_decoder.layers.*.self_attn.q_proj",
-    "decoder.layers.*.self_attn.out_proj": "speecht5.decoder.wrapped_decoder.layers.*.self_attn.out_proj",
-    "decoder.layers.*.self_attn_layer_norm": "speecht5.decoder.wrapped_decoder.layers.*.self_attn_layer_norm",
-    "decoder.layers.*.encoder_attn.k_proj": "speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.k_proj",
-    "decoder.layers.*.encoder_attn.v_proj": "speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.v_proj",
-    "decoder.layers.*.encoder_attn.q_proj": "speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.q_proj",
-    "decoder.layers.*.encoder_attn.out_proj": "speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.out_proj",
-    "decoder.layers.*.encoder_attn_layer_norm": "speecht5.decoder.wrapped_decoder.layers.*.encoder_attn_layer_norm",
-    "decoder.layers.*.fc1": "speecht5.decoder.wrapped_decoder.layers.*.feed_forward.intermediate_dense",
-    "decoder.layers.*.fc2": "speecht5.decoder.wrapped_decoder.layers.*.feed_forward.output_dense",
-    "decoder.layers.*.final_layer_norm": "speecht5.decoder.wrapped_decoder.layers.*.final_layer_norm",
-}
-MAPPING_S2T = {
-    **MAPPING_SPEECH_ENCODER_PRENET,
-    **MAPPING_ENCODER,
-    **MAPPING_DECODER,
-    **MAPPING_TEXT_DECODER_PRENET,
-    **MAPPING_TEXT_DECODER_POSTNET,
-}
-MAPPING_T2S = {
-    **MAPPING_TEXT_ENCODER_PRENET,
-    **MAPPING_ENCODER,
-    **MAPPING_DECODER,
-    **MAPPING_SPEECH_DECODER_PRENET,
-    **MAPPING_SPEECH_DECODER_POSTNET,
-}
-MAPPING_S2S = {
-    **MAPPING_SPEECH_ENCODER_PRENET,
-    **MAPPING_ENCODER,
-    **MAPPING_DECODER,
-    **MAPPING_SPEECH_DECODER_PRENET,
-    **MAPPING_SPEECH_DECODER_POSTNET,
-}
-TOP_LEVEL_KEYS = []
-IGNORE_KEYS = [
-    "encoder.version",
-    "encoder.layers.*.norm_k.weight",
-    "encoder.layers.*.norm_k.bias",
-    "decoder.version",
-    "decoder.layers.*.norm_k.weight",
-    "decoder.layers.*.norm_k.bias",
-    "decoder.pos_emb.pe_k",
-    "speech_encoder_prenet.embed_positions._float_tensor",
-    "text_decoder_prenet.embed_positions._float_tensor",
-]
-IGNORE_KEYS_S2T = IGNORE_KEYS + [
-    "encoder.proj",
-    "text_encoder_prenet.*",
-    "speech_decoder_prenet.*",
-    "speech_decoder_postnet.*",
-]
-IGNORE_KEYS_T2S = IGNORE_KEYS + [
-    "encoder.proj",
-    "speech_encoder_prenet.*",
-    "text_decoder_prenet.*",
-    "text_decoder_postnet.*",
-]
-IGNORE_KEYS_S2S = IGNORE_KEYS + [
-    "encoder.proj",
-    "text_encoder_prenet.*",
-    "text_decoder_prenet.*",
-    "text_decoder_postnet.*",
-]
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    if hf_shape != value.shape:
-        raise ValueError(
-            f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-            f" {value.shape} for {full_name}"
-        )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    elif weight_type == "running_mean":
-        hf_pointer.running_mean.data = value
-    elif weight_type == "running_var":
-        hf_pointer.running_var.data = value
-    elif weight_type == "num_batches_tracked":
-        hf_pointer.num_batches_tracked.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}.")
-
-
-def should_ignore(name, ignore_keys):
-    for key in ignore_keys:
-        if key.endswith(".*"):
-            if name.startswith(key[:-1]):
-                return True
-        elif ".*." in key:
-            prefix, suffix = key.split(".*.")
-            if prefix in name and suffix in name:
-                return True
-        elif key in name:
-            return True
-    return False
-
-
-def recursively_load_weights(fairseq_dict, hf_model, task):
-    unused_weights = []
-
-    if task == "s2t":
-        feature_encoder = hf_model.speecht5.encoder.prenet.feature_encoder
-        MAPPING = MAPPING_S2T
-        IGNORE_KEYS = IGNORE_KEYS_S2T
-    elif task == "t2s":
-        feature_encoder = None
-        MAPPING = MAPPING_T2S
-        IGNORE_KEYS = IGNORE_KEYS_T2S
-    elif task == "s2s":
-        feature_encoder = hf_model.speecht5.encoder.prenet.feature_encoder
-        MAPPING = MAPPING_S2S
-        IGNORE_KEYS = IGNORE_KEYS_S2S
-    else:
-        raise ValueError(f"Unsupported task: {task}")
-
-    for name, value in fairseq_dict.items():
-        if should_ignore(name, IGNORE_KEYS):
-            logger.info(f"{name} was ignored")
-            continue
-
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_encoder,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                # mapped_key = "speecht5." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
-
-                if "*" in key:
-                    prefix, suffix = key.split(".*.")
-                    if prefix in name and suffix in name:
-                        key = suffix
-
-                # if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                if key in name:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    elif "weight" in name:
-                        weight_type = "weight"
-                    elif "running_mean" in name:
-                        weight_type = "running_mean"
-                    elif "running_var" in name:
-                        weight_type = "running_var"
-                    elif "num_batches_tracked" in name:
-                        weight_type = "num_batches_tracked"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-@torch.no_grad()
-def convert_speecht5_checkpoint(
-    task,
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    config_path=None,
-    vocab_path=None,
-    repo_id=None,
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = SpeechT5Config.from_pretrained(config_path)
-    else:
-        config = SpeechT5Config()
-
-    if task == "s2t":
-        config.max_length = config.max_text_positions
-        model = SpeechT5ForSpeechToText(config)
-    elif task == "t2s":
-        config.max_speech_positions = 1876
-        config.max_text_positions = 600
-        config.max_length = config.max_speech_positions
-        model = SpeechT5ForTextToSpeech(config)
-    elif task == "s2s":
-        config.max_speech_positions = 1876
-        config.max_length = config.max_speech_positions
-        model = SpeechT5ForSpeechToSpeech(config)
-    else:
-        raise ValueError(f"Unknown task name: {task}")
-
-    if vocab_path:
-        tokenizer = SpeechT5Tokenizer(vocab_path, model_max_length=config.max_text_positions)
-
-        # Mask token behaves like a normal word, i.e. include the space before it
-        mask_token = AddedToken("<mask>", lstrip=True, rstrip=False)
-        tokenizer.mask_token = mask_token
-        tokenizer.add_special_tokens({"mask_token": mask_token})
-        tokenizer.add_tokens(["<ctc_blank>"])
-
-    feature_extractor = SpeechT5FeatureExtractor()
-    processor = SpeechT5Processor(tokenizer=tokenizer, feature_extractor=feature_extractor)
-    processor.save_pretrained(pytorch_dump_folder_path)
-
-    fairseq_checkpoint = torch.load(checkpoint_path)
-    recursively_load_weights(fairseq_checkpoint["model"], model, task)
-
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        processor.push_to_hub(repo_id)
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--task",
-        default="s2t",
-        type=str,
-        help="Type of the SpeechT5 model you'd like to convert. Should be one of 's2t', 't2s', 's2s'.",
-    )
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--vocab_path", default=None, type=str, help="Path to SentencePiece model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_speecht5_checkpoint(
-        args.task,
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.config_path,
-        args.vocab_path,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/superglue/convert_superglue_to_hf.py b/src/transformers/models/superglue/convert_superglue_to_hf.py
deleted file mode 100644
index cfff39acdfd8..000000000000
--- a/src/transformers/models/superglue/convert_superglue_to_hf.py
+++ /dev/null
@@ -1,342 +0,0 @@
-# Copyright 2024 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import gc
-import os
-import re
-from typing import List
-
-import torch
-from datasets import load_dataset
-
-from transformers import (
-    AutoModelForKeypointDetection,
-    SuperGlueConfig,
-    SuperGlueForKeypointMatching,
-    SuperGlueImageProcessor,
-)
-
-
-def prepare_imgs():
-    dataset = load_dataset("hf-internal-testing/image-matching-test-dataset", split="train")
-    image1 = dataset[0]["image"]
-    image2 = dataset[1]["image"]
-    image3 = dataset[2]["image"]
-    return [[image1, image2], [image3, image2]]
-
-
-def verify_model_outputs(model, model_name, device):
-    images = prepare_imgs()
-    preprocessor = SuperGlueImageProcessor()
-    inputs = preprocessor(images=images, return_tensors="pt").to(device)
-    model.to(device)
-    with torch.no_grad():
-        outputs = model(**inputs, output_hidden_states=True, output_attentions=True)
-
-    predicted_matches_values = outputs.matches[0, 0, :10]
-    predicted_matching_scores_values = outputs.matching_scores[0, 0, :10]
-
-    predicted_number_of_matches = torch.sum(outputs.matches[0][0] != -1).item()
-
-    if "outdoor" in model_name:
-        expected_max_number_keypoints = 865
-        expected_matches_shape = torch.Size((len(images), 2, expected_max_number_keypoints))
-        expected_matching_scores_shape = torch.Size((len(images), 2, expected_max_number_keypoints))
-
-        expected_matches_values = torch.tensor(
-            [125, 630, 137, 138, 136, 143, 135, -1, -1, 153], dtype=torch.int64, device=device
-        )
-        expected_matching_scores_values = torch.tensor(
-            [0.9899, 0.0033, 0.9897, 0.9889, 0.9879, 0.7464, 0.7109, 0, 0, 0.9841], device=device
-        )
-
-        expected_number_of_matches = 281
-    elif "indoor" in model_name:
-        expected_max_number_keypoints = 865
-        expected_matches_shape = torch.Size((len(images), 2, expected_max_number_keypoints))
-        expected_matching_scores_shape = torch.Size((len(images), 2, expected_max_number_keypoints))
-
-        expected_matches_values = torch.tensor(
-            [125, 144, 137, 138, 136, 155, 135, -1, -1, 153], dtype=torch.int64, device=device
-        )
-        expected_matching_scores_values = torch.tensor(
-            [0.9694, 0.0010, 0.9006, 0.8753, 0.8521, 0.5688, 0.6321, 0.0, 0.0, 0.7235], device=device
-        )
-
-        expected_number_of_matches = 282
-
-    assert outputs.matches.shape == expected_matches_shape
-    assert outputs.matching_scores.shape == expected_matching_scores_shape
-
-    assert torch.allclose(predicted_matches_values, expected_matches_values, atol=1e-4)
-    assert torch.allclose(predicted_matching_scores_values, expected_matching_scores_values, atol=1e-4)
-
-    assert predicted_number_of_matches == expected_number_of_matches
-
-
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    r"kenc.encoder.(\d+)": r"keypoint_encoder.encoder.\1.old",
-    r"gnn.layers.(\d+).attn.proj.0": r"gnn.layers.\1.attention.self.query",
-    r"gnn.layers.(\d+).attn.proj.1": r"gnn.layers.\1.attention.self.key",
-    r"gnn.layers.(\d+).attn.proj.2": r"gnn.layers.\1.attention.self.value",
-    r"gnn.layers.(\d+).attn.merge": r"gnn.layers.\1.attention.output.dense",
-    r"gnn.layers.(\d+).mlp.0": r"gnn.layers.\1.mlp.0.linear",
-    r"gnn.layers.(\d+).mlp.1": r"gnn.layers.\1.mlp.0.batch_norm",
-    r"gnn.layers.(\d+).mlp.3": r"gnn.layers.\1.mlp.1",
-    r"final_proj": r"final_projection.final_proj",
-}
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: List[str], conversion_mapping=ORIGINAL_TO_CONVERTED_KEY_MAPPING):
-    """
-    This function should be applied only once, on the concatenated keys to efficiently rename using
-    the key mappings.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-        for pattern, replacement in conversion_mapping.items():
-            if replacement is None:
-                new_text = re.sub(pattern, "", new_text)  # an empty line
-                continue
-            new_text = re.sub(pattern, replacement, new_text)
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-    return output_dict
-
-
-def replace_state_dict_keys(all_keys, new_keys, original_state_dict):
-    state_dict = {}
-    for key in all_keys:
-        new_key = new_keys[key]
-        state_dict[new_key] = original_state_dict.pop(key).contiguous().clone()
-    return state_dict
-
-
-def convert_state_dict(state_dict, config):
-    converted_to_final_key_mapping = {}
-
-    def convert_conv_to_linear(keys):
-        for key in keys:
-            state_dict[key] = state_dict[key].squeeze(-1)
-
-    def qkv_permute_weights_and_biases(keys, num_heads=4):
-        for key in keys:
-            tensor = state_dict[key]
-            shape = tensor.shape
-            dim_out = shape[0]
-            if len(shape) == 2:
-                dim_in = shape[1]
-                tensor = (
-                    tensor.reshape(dim_out // num_heads, num_heads, dim_in).permute(1, 0, 2).reshape(dim_out, dim_in)
-                )
-            if len(shape) == 1:
-                tensor = tensor.reshape(dim_out // num_heads, num_heads).permute(1, 0).reshape(dim_out)
-            state_dict[key] = tensor
-
-    def output_permute_weights(keys, num_heads=4):
-        for key in keys:
-            tensor = state_dict[key]
-            dim_in = tensor.shape[1]
-            dim_out = tensor.shape[0]
-            tensor = tensor.reshape(dim_out, dim_in // num_heads, num_heads).permute(0, 2, 1).reshape(dim_out, dim_in)
-            state_dict[key] = tensor
-
-    conv_keys = []
-    qkv_permute_keys = []
-    output_permute_keys = []
-    # Keypoint Encoder
-    keypoint_encoder_key = "keypoint_encoder.encoder"
-    for i in range(1, len(config.keypoint_encoder_sizes) + 2):
-        old_conv_key = f"{keypoint_encoder_key}.{(i - 1) * 3}.old"
-        new_index = i - 1
-        new_conv_key = f"{keypoint_encoder_key}.{new_index}."
-        if i < len(config.keypoint_encoder_sizes) + 1:
-            new_conv_key = f"{new_conv_key}linear."
-        converted_to_final_key_mapping[rf"{old_conv_key}\."] = new_conv_key
-        if i < len(config.keypoint_encoder_sizes) + 1:
-            old_batch_norm_key = f"{keypoint_encoder_key}.{(i - 1) * 3 + 1}.old"
-            new_batch_norm_key = f"{keypoint_encoder_key}.{new_index}.batch_norm."
-            converted_to_final_key_mapping[rf"{old_batch_norm_key}\."] = new_batch_norm_key
-
-        conv_keys.append(f"{old_conv_key}.weight")
-
-    # Attentional GNN
-    for i in range(len(config.gnn_layers_types)):
-        gnn_layer_key = f"gnn.layers.{i}"
-        ## Attention
-        attention_key = f"{gnn_layer_key}.attention"
-        conv_keys.extend(
-            [
-                f"{attention_key}.self.query.weight",
-                f"{attention_key}.self.key.weight",
-                f"{attention_key}.self.value.weight",
-                f"{attention_key}.output.dense.weight",
-            ]
-        )
-        qkv_permute_keys.extend(
-            [
-                f"{attention_key}.self.query.weight",
-                f"{attention_key}.self.key.weight",
-                f"{attention_key}.self.value.weight",
-                f"{attention_key}.self.query.bias",
-                f"{attention_key}.self.key.bias",
-                f"{attention_key}.self.value.bias",
-            ]
-        )
-        output_permute_keys.append(f"{attention_key}.output.dense.weight")
-
-        ## MLP
-        conv_keys.extend([f"{gnn_layer_key}.mlp.0.linear.weight", f"{gnn_layer_key}.mlp.1.weight"])
-
-    # Final Projection
-    conv_keys.append("final_projection.final_proj.weight")
-
-    convert_conv_to_linear(conv_keys)
-    qkv_permute_weights_and_biases(qkv_permute_keys)
-    output_permute_weights(output_permute_keys)
-    all_keys = list(state_dict.keys())
-    new_keys = convert_old_keys_to_new_keys(all_keys, converted_to_final_key_mapping)
-    state_dict = replace_state_dict_keys(all_keys, new_keys, state_dict)
-    return state_dict
-
-
-def add_keypoint_detector_state_dict(superglue_state_dict):
-    keypoint_detector = AutoModelForKeypointDetection.from_pretrained("magic-leap-community/superpoint")
-    keypoint_detector_state_dict = keypoint_detector.state_dict()
-    for k, v in keypoint_detector_state_dict.items():
-        superglue_state_dict[f"keypoint_detector.{k}"] = v
-    return superglue_state_dict
-
-
-@torch.no_grad()
-def write_model(
-    model_path,
-    checkpoint_url,
-    safe_serialization=True,
-    push_to_hub=False,
-):
-    os.makedirs(model_path, exist_ok=True)
-
-    # ------------------------------------------------------------
-    # SuperGlue config
-    # ------------------------------------------------------------
-
-    config = SuperGlueConfig(
-        hidden_size=256,
-        keypoint_encoder_sizes=[32, 64, 128, 256],
-        gnn_layers_types=["self", "cross"] * 9,
-        sinkhorn_iterations=100,
-        matching_threshold=0.0,
-    )
-    config.architectures = ["SuperGlueForKeypointMatching"]
-    config.save_pretrained(model_path, push_to_hub=push_to_hub)
-    print("Model config saved successfully...")
-
-    # ------------------------------------------------------------
-    # Convert weights
-    # ------------------------------------------------------------
-
-    print(f"Fetching all parameters from the checkpoint at {checkpoint_url}...")
-    original_state_dict = torch.hub.load_state_dict_from_url(checkpoint_url)
-
-    print("Converting model...")
-    all_keys = list(original_state_dict.keys())
-    new_keys = convert_old_keys_to_new_keys(all_keys)
-
-    state_dict = replace_state_dict_keys(all_keys, new_keys, original_state_dict)
-    state_dict = convert_state_dict(state_dict, config)
-
-    del original_state_dict
-    gc.collect()
-    state_dict = add_keypoint_detector_state_dict(state_dict)
-
-    print("Loading the checkpoint in a SuperGlue model...")
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    with torch.device(device):
-        model = SuperGlueForKeypointMatching(config)
-    model.load_state_dict(state_dict, strict=True)
-    print("Checkpoint loaded successfully...")
-    del model.config._name_or_path
-
-    print("Saving the model...")
-    model.save_pretrained(model_path, safe_serialization=safe_serialization)
-    del state_dict, model
-
-    # Safety check: reload the converted model
-    gc.collect()
-    print("Reloading the model to check if it's saved correctly.")
-    model = SuperGlueForKeypointMatching.from_pretrained(model_path)
-    print("Model reloaded successfully.")
-
-    model_name = "superglue"
-    if "superglue_outdoor.pth" in checkpoint_url:
-        model_name += "_outdoor"
-    elif "superglue_indoor.pth" in checkpoint_url:
-        model_name += "_indoor"
-
-    print("Checking the model outputs...")
-    verify_model_outputs(model, model_name, device)
-    print("Model outputs verified successfully.")
-
-    organization = "magic-leap-community"
-    if push_to_hub:
-        print("Pushing model to the hub...")
-        model.push_to_hub(
-            repo_id=f"{organization}/{model_name}",
-            commit_message="Add model",
-        )
-
-    write_image_processor(model_path, model_name, organization, push_to_hub=push_to_hub)
-
-
-def write_image_processor(save_dir, model_name, organization, push_to_hub=False):
-    image_processor = SuperGlueImageProcessor()
-    image_processor.save_pretrained(save_dir)
-
-    if push_to_hub:
-        print("Pushing image processor to the hub...")
-        image_processor.push_to_hub(
-            repo_id=f"{organization}/{model_name}",
-            commit_message="Add image processor",
-        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://raw.githubusercontent.com/magicleap/SuperGluePretrainedNetwork/master/models/weights/superglue_indoor.pth",
-        type=str,
-        help="URL of the original SuperGlue checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--save_model", action="store_true", help="Save model to local")
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-        help="Push model and image preprocessor to the hub",
-    )
-
-    args = parser.parse_args()
-    write_model(
-        args.pytorch_dump_folder_path, args.checkpoint_url, safe_serialization=True, push_to_hub=args.push_to_hub
-    )
diff --git a/src/transformers/models/superpoint/convert_superpoint_to_pytorch.py b/src/transformers/models/superpoint/convert_superpoint_to_pytorch.py
deleted file mode 100644
index 007966a0557a..000000000000
--- a/src/transformers/models/superpoint/convert_superpoint_to_pytorch.py
+++ /dev/null
@@ -1,175 +0,0 @@
-# Copyright 2024 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-import os
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import SuperPointConfig, SuperPointForKeypointDetection, SuperPointImageProcessor
-
-
-def get_superpoint_config():
-    config = SuperPointConfig(
-        encoder_hidden_sizes=[64, 64, 128, 128],
-        decoder_hidden_size=256,
-        keypoint_decoder_dim=65,
-        descriptor_decoder_dim=256,
-        keypoint_threshold=0.005,
-        max_keypoints=-1,
-        nms_radius=4,
-        border_removal_distance=4,
-        initializer_range=0.02,
-    )
-
-    return config
-
-
-def create_rename_keys(config, state_dict):
-    rename_keys = []
-
-    # Encoder weights
-    rename_keys.append(("conv1a.weight", "encoder.conv_blocks.0.conv_a.weight"))
-    rename_keys.append(("conv1b.weight", "encoder.conv_blocks.0.conv_b.weight"))
-    rename_keys.append(("conv2a.weight", "encoder.conv_blocks.1.conv_a.weight"))
-    rename_keys.append(("conv2b.weight", "encoder.conv_blocks.1.conv_b.weight"))
-    rename_keys.append(("conv3a.weight", "encoder.conv_blocks.2.conv_a.weight"))
-    rename_keys.append(("conv3b.weight", "encoder.conv_blocks.2.conv_b.weight"))
-    rename_keys.append(("conv4a.weight", "encoder.conv_blocks.3.conv_a.weight"))
-    rename_keys.append(("conv4b.weight", "encoder.conv_blocks.3.conv_b.weight"))
-    rename_keys.append(("conv1a.bias", "encoder.conv_blocks.0.conv_a.bias"))
-    rename_keys.append(("conv1b.bias", "encoder.conv_blocks.0.conv_b.bias"))
-    rename_keys.append(("conv2a.bias", "encoder.conv_blocks.1.conv_a.bias"))
-    rename_keys.append(("conv2b.bias", "encoder.conv_blocks.1.conv_b.bias"))
-    rename_keys.append(("conv3a.bias", "encoder.conv_blocks.2.conv_a.bias"))
-    rename_keys.append(("conv3b.bias", "encoder.conv_blocks.2.conv_b.bias"))
-    rename_keys.append(("conv4a.bias", "encoder.conv_blocks.3.conv_a.bias"))
-    rename_keys.append(("conv4b.bias", "encoder.conv_blocks.3.conv_b.bias"))
-
-    # Keypoint Decoder weights
-    rename_keys.append(("convPa.weight", "keypoint_decoder.conv_score_a.weight"))
-    rename_keys.append(("convPb.weight", "keypoint_decoder.conv_score_b.weight"))
-    rename_keys.append(("convPa.bias", "keypoint_decoder.conv_score_a.bias"))
-    rename_keys.append(("convPb.bias", "keypoint_decoder.conv_score_b.bias"))
-
-    # Descriptor Decoder weights
-    rename_keys.append(("convDa.weight", "descriptor_decoder.conv_descriptor_a.weight"))
-    rename_keys.append(("convDb.weight", "descriptor_decoder.conv_descriptor_b.weight"))
-    rename_keys.append(("convDa.bias", "descriptor_decoder.conv_descriptor_a.bias"))
-    rename_keys.append(("convDb.bias", "descriptor_decoder.conv_descriptor_b.bias"))
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def prepare_imgs():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im1 = Image.open(requests.get(url, stream=True).raw)
-    url = "http://images.cocodataset.org/test-stuff2017/000000004016.jpg"
-    im2 = Image.open(requests.get(url, stream=True).raw)
-    return [im1, im2]
-
-
-@torch.no_grad()
-def convert_superpoint_checkpoint(checkpoint_url, pytorch_dump_folder_path, save_model, push_to_hub, test_mode=False):
-    """
-    Copy/paste/tweak model's weights to our SuperPoint structure.
-    """
-
-    print("Downloading original model from checkpoint...")
-    config = get_superpoint_config()
-
-    # load original state_dict from URL
-    original_state_dict = torch.hub.load_state_dict_from_url(checkpoint_url)
-
-    print("Converting model parameters...")
-    # rename keys
-    rename_keys = create_rename_keys(config, original_state_dict)
-    new_state_dict = original_state_dict.copy()
-    for src, dest in rename_keys:
-        rename_key(new_state_dict, src, dest)
-
-    # Load HuggingFace model
-    model = SuperPointForKeypointDetection(config)
-    model.load_state_dict(new_state_dict)
-    model.eval()
-    print("Successfully loaded weights in the model")
-
-    # Check model outputs
-    preprocessor = SuperPointImageProcessor()
-    inputs = preprocessor(images=prepare_imgs(), return_tensors="pt")
-    outputs = model(**inputs)
-
-    # If test_mode is True, we check that the model outputs match the original results
-    if test_mode:
-        torch.count_nonzero(outputs.mask[0])
-        expected_keypoints_shape = (2, 830, 2)
-        expected_scores_shape = (2, 830)
-        expected_descriptors_shape = (2, 830, 256)
-
-        expected_keypoints_values = torch.tensor([[480.0, 9.0], [494.0, 9.0], [489.0, 16.0]])
-        expected_scores_values = torch.tensor([0.0064, 0.0140, 0.0595, 0.0728, 0.5170, 0.0175, 0.1523, 0.2055, 0.0336])
-        expected_descriptors_value = torch.tensor(-0.1096)
-        assert outputs.keypoints.shape == expected_keypoints_shape
-        assert outputs.scores.shape == expected_scores_shape
-        assert outputs.descriptors.shape == expected_descriptors_shape
-
-        assert torch.allclose(outputs.keypoints[0, :3], expected_keypoints_values, atol=1e-3)
-        assert torch.allclose(outputs.scores[0, :9], expected_scores_values, atol=1e-3)
-        assert torch.allclose(outputs.descriptors[0, 0, 0], expected_descriptors_value, atol=1e-3)
-        print("Model outputs match the original results!")
-
-    if save_model:
-        print("Saving model to local...")
-        # Create folder to save model
-        if not os.path.isdir(pytorch_dump_folder_path):
-            os.mkdir(pytorch_dump_folder_path)
-
-        model.save_pretrained(pytorch_dump_folder_path)
-        preprocessor.save_pretrained(pytorch_dump_folder_path)
-
-        model_name = "magic-leap-community/superpoint"
-        if push_to_hub:
-            print(f"Pushing {model_name} to the hub...")
-        model.push_to_hub(model_name)
-        preprocessor.push_to_hub(model_name)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://github.com/magicleap/SuperPointPretrainedNetwork/raw/master/superpoint_v1.pth",
-        type=str,
-        help="URL of the original SuperPoint checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="model",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--save_model", action="store_true", help="Save model to local")
-    parser.add_argument("--push_to_hub", action="store_true", help="Push model and image preprocessor to the hub")
-
-    args = parser.parse_args()
-    convert_superpoint_checkpoint(
-        args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
-    )
diff --git a/src/transformers/models/swiftformer/convert_swiftformer_original_to_hf.py b/src/transformers/models/swiftformer/convert_swiftformer_original_to_hf.py
deleted file mode 100644
index 21ecebebe241..000000000000
--- a/src/transformers/models/swiftformer/convert_swiftformer_original_to_hf.py
+++ /dev/null
@@ -1,175 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert SwiftFormer checkpoints from the original implementation."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    SwiftFormerConfig,
-    SwiftFormerForImageClassification,
-    ViTImageProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-device = torch.device("cpu")
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-def get_expected_output(swiftformer_name):
-    if swiftformer_name == "swiftformer_xs":
-        return torch.tensor([-2.1703e00, 2.1107e00, -2.0811e00, 8.8685e-01, 2.4360e-01])
-
-    elif swiftformer_name == "swiftformer_s":
-        return torch.tensor([3.9636e-01, 2.3478e-01, -1.6963e00, -1.7381e00, -8.6337e-01])
-
-    elif swiftformer_name == "swiftformer_l1":
-        return torch.tensor([-4.2768e-01, -4.7429e-01, -1.0897e00, -1.0248e00, 3.5523e-02])
-
-    elif swiftformer_name == "swiftformer_l3":
-        return torch.tensor([-2.5330e-01, 2.4211e-01, -6.0185e-01, -8.2789e-01, -6.0446e-02])
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def create_rename_keys(state_dict):
-    rename_keys = []
-    for k in state_dict.keys():
-        k_new = k
-        if ".pwconv" in k:
-            k_new = k_new.replace(".pwconv", ".point_wise_conv")
-        if ".dwconv" in k:
-            k_new = k_new.replace(".dwconv", ".depth_wise_conv")
-        if ".Proj." in k:
-            k_new = k_new.replace(".Proj.", ".proj.")
-        if "patch_embed" in k_new:
-            k_new = k_new.replace("patch_embed", "swiftformer.patch_embed.patch_embedding")
-        if "network" in k_new:
-            ls = k_new.split(".")
-            if ls[2].isdigit():
-                k_new = "swiftformer.encoder.network." + ls[1] + ".blocks." + ls[2] + "." + ".".join(ls[3:])
-            else:
-                k_new = k_new.replace("network", "swiftformer.encoder.network")
-        rename_keys.append((k, k_new))
-    return rename_keys
-
-
-@torch.no_grad()
-def convert_swiftformer_checkpoint(swiftformer_name, pytorch_dump_folder_path, original_ckpt):
-    """
-    Copy/paste/tweak model's weights to our SwiftFormer structure.
-    """
-
-    # define default SwiftFormer configuration
-    config = SwiftFormerConfig()
-
-    # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
-    config.num_labels = 1000
-    repo_id = "huggingface/label-files"
-    filename = "imagenet-1k-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    # size of the architecture
-    if swiftformer_name == "swiftformer_xs":
-        config.depths = [3, 3, 6, 4]
-        config.embed_dims = [48, 56, 112, 220]
-
-    elif swiftformer_name == "swiftformer_s":
-        config.depths = [3, 3, 9, 6]
-        config.embed_dims = [48, 64, 168, 224]
-
-    elif swiftformer_name == "swiftformer_l1":
-        config.depths = [4, 3, 10, 5]
-        config.embed_dims = [48, 96, 192, 384]
-
-    elif swiftformer_name == "swiftformer_l3":
-        config.depths = [4, 4, 12, 6]
-        config.embed_dims = [64, 128, 320, 512]
-
-    # load state_dict of original model, remove and rename some keys
-    if original_ckpt:
-        if original_ckpt.startswith("https"):
-            checkpoint = torch.hub.load_state_dict_from_url(original_ckpt, map_location="cpu", check_hash=True)
-        else:
-            checkpoint = torch.load(original_ckpt, map_location="cpu")
-    state_dict = checkpoint
-
-    rename_keys = create_rename_keys(state_dict)
-    for rename_key_src, rename_key_dest in rename_keys:
-        rename_key(state_dict, rename_key_src, rename_key_dest)
-
-    # load HuggingFace model
-    hf_model = SwiftFormerForImageClassification(config).eval()
-    hf_model.load_state_dict(state_dict)
-
-    # prepare test inputs
-    image = prepare_img()
-    processor = ViTImageProcessor.from_pretrained("preprocessor_config")
-    inputs = processor(images=image, return_tensors="pt")
-
-    # compare outputs from both models
-    timm_logits = get_expected_output(swiftformer_name)
-    hf_logits = hf_model(inputs["pixel_values"]).logits
-
-    assert hf_logits.shape == torch.Size([1, 1000])
-    assert torch.allclose(hf_logits[0, 0:5], timm_logits, atol=1e-3)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {swiftformer_name} to {pytorch_dump_folder_path}")
-    hf_model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--swiftformer_name",
-        default="swiftformer_xs",
-        choices=["swiftformer_xs", "swiftformer_s", "swiftformer_l1", "swiftformer_l3"],
-        type=str,
-        help="Name of the SwiftFormer model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="./converted_outputs/",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--original_ckpt", default=None, type=str, help="Path to the original model checkpoint.")
-
-    args = parser.parse_args()
-    convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)
diff --git a/src/transformers/models/swin/convert_swin_simmim_to_pytorch.py b/src/transformers/models/swin/convert_swin_simmim_to_pytorch.py
deleted file mode 100644
index 6402346289c1..000000000000
--- a/src/transformers/models/swin/convert_swin_simmim_to_pytorch.py
+++ /dev/null
@@ -1,182 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Swin SimMIM checkpoints from the original repository.
-
-URL: https://github.com/microsoft/Swin-Transformer/blob/main/MODELHUB.md#simmim-pretrained-swin-v1-models"""
-
-import argparse
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import SwinConfig, SwinForMaskedImageModeling, ViTImageProcessor
-
-
-def get_swin_config(model_name):
-    config = SwinConfig(image_size=192)
-
-    if "base" in model_name:
-        window_size = 6
-        embed_dim = 128
-        depths = (2, 2, 18, 2)
-        num_heads = (4, 8, 16, 32)
-    elif "large" in model_name:
-        window_size = 12
-        embed_dim = 192
-        depths = (2, 2, 18, 2)
-        num_heads = (6, 12, 24, 48)
-    else:
-        raise ValueError("Model not supported, only supports base and large variants")
-
-    config.window_size = window_size
-    config.embed_dim = embed_dim
-    config.depths = depths
-    config.num_heads = num_heads
-
-    return config
-
-
-def rename_key(name):
-    if "encoder.mask_token" in name:
-        name = name.replace("encoder.mask_token", "embeddings.mask_token")
-    if "encoder.patch_embed.proj" in name:
-        name = name.replace("encoder.patch_embed.proj", "embeddings.patch_embeddings.projection")
-    if "encoder.patch_embed.norm" in name:
-        name = name.replace("encoder.patch_embed.norm", "embeddings.norm")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name:
-        name = name.replace("attn", "attention.self")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-
-    if name == "encoder.norm.weight":
-        name = "layernorm.weight"
-    if name == "encoder.norm.bias":
-        name = "layernorm.bias"
-
-    if "decoder" in name:
-        pass
-    else:
-        name = "swin." + name
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, model):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "attn_mask" in key:
-            pass
-        elif "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[2])
-            block_num = int(key_split[4])
-            dim = model.swin.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size
-
-            if "weight" in key:
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.weight"] = (
-                    val[:dim, :]
-                )
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.weight"] = val[
-                    dim : dim * 2, :
-                ]
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.weight"] = (
-                    val[-dim:, :]
-                )
-            else:
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.bias"] = val[
-                    :dim
-                ]
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.bias"] = val[
-                    dim : dim * 2
-                ]
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.bias"] = val[
-                    -dim:
-                ]
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-def convert_swin_checkpoint(model_name, checkpoint_path, pytorch_dump_folder_path, push_to_hub):
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-
-    config = get_swin_config(model_name)
-    model = SwinForMaskedImageModeling(config)
-    model.eval()
-
-    new_state_dict = convert_state_dict(state_dict, model)
-    model.load_state_dict(new_state_dict)
-
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-
-    image_processor = ViTImageProcessor(size={"height": 192, "width": 192})
-    image = Image.open(requests.get(url, stream=True).raw)
-    inputs = image_processor(images=image, return_tensors="pt")
-
-    with torch.no_grad():
-        outputs = model(**inputs).logits
-
-    print(outputs.keys())
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-
-        print(f"Saving image processor to {pytorch_dump_folder_path}")
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and image processor for {model_name} to hub")
-        model.push_to_hub(f"microsoft/{model_name}")
-        image_processor.push_to_hub(f"microsoft/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="swin-base-simmim-window6-192",
-        type=str,
-        choices=["swin-base-simmim-window6-192", "swin-large-simmim-window12-192"],
-        help="Name of the Swin SimMIM model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--checkpoint_path",
-        default="/Users/nielsrogge/Documents/SwinSimMIM/simmim_pretrain__swin_base__img192_window6__100ep.pth",
-        type=str,
-        help="Path to the original PyTorch checkpoint (.pth file).",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_swin_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/swin/convert_swin_timm_to_pytorch.py b/src/transformers/models/swin/convert_swin_timm_to_pytorch.py
deleted file mode 100644
index c91249b272ba..000000000000
--- a/src/transformers/models/swin/convert_swin_timm_to_pytorch.py
+++ /dev/null
@@ -1,173 +0,0 @@
-import argparse
-import json
-
-import requests
-import timm
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import AutoImageProcessor, SwinConfig, SwinForImageClassification
-
-
-def get_swin_config(swin_name):
-    config = SwinConfig()
-    name_split = swin_name.split("_")
-
-    model_size = name_split[1]
-    img_size = int(name_split[4])
-    window_size = int(name_split[3][-1])
-
-    if model_size == "tiny":
-        embed_dim = 96
-        depths = (2, 2, 6, 2)
-        num_heads = (3, 6, 12, 24)
-    elif model_size == "small":
-        embed_dim = 96
-        depths = (2, 2, 18, 2)
-        num_heads = (3, 6, 12, 24)
-    elif model_size == "base":
-        embed_dim = 128
-        depths = (2, 2, 18, 2)
-        num_heads = (4, 8, 16, 32)
-    else:
-        embed_dim = 192
-        depths = (2, 2, 18, 2)
-        num_heads = (6, 12, 24, 48)
-
-    if "in22k" in swin_name:
-        num_classes = 21841
-    else:
-        num_classes = 1000
-        repo_id = "huggingface/label-files"
-        filename = "imagenet-1k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    config.image_size = img_size
-    config.num_labels = num_classes
-    config.embed_dim = embed_dim
-    config.depths = depths
-    config.num_heads = num_heads
-    config.window_size = window_size
-
-    return config
-
-
-def rename_key(name):
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "embeddings.norm")
-    if "layers" in name:
-        name = "encoder." + name
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name:
-        name = name.replace("attn", "attention.self")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-
-    if name == "norm.weight":
-        name = "layernorm.weight"
-    if name == "norm.bias":
-        name = "layernorm.bias"
-
-    if "head" in name:
-        name = name.replace("head", "classifier")
-    else:
-        name = "swin." + name
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, model):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "mask" in key:
-            continue
-        elif "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[1])
-            block_num = int(key_split[3])
-            dim = model.swin.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size
-
-            if "weight" in key:
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.weight"] = (
-                    val[:dim, :]
-                )
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.weight"] = val[
-                    dim : dim * 2, :
-                ]
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.weight"] = (
-                    val[-dim:, :]
-                )
-            else:
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.bias"] = val[
-                    :dim
-                ]
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.bias"] = val[
-                    dim : dim * 2
-                ]
-                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.bias"] = val[
-                    -dim:
-                ]
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-def convert_swin_checkpoint(swin_name, pytorch_dump_folder_path):
-    timm_model = timm.create_model(swin_name, pretrained=True)
-    timm_model.eval()
-
-    config = get_swin_config(swin_name)
-    model = SwinForImageClassification(config)
-    model.eval()
-
-    new_state_dict = convert_state_dict(timm_model.state_dict(), model)
-    model.load_state_dict(new_state_dict)
-
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-
-    image_processor = AutoImageProcessor.from_pretrained("microsoft/{}".format(swin_name.replace("_", "-")))
-    image = Image.open(requests.get(url, stream=True).raw)
-    inputs = image_processor(images=image, return_tensors="pt")
-
-    timm_outs = timm_model(inputs["pixel_values"])
-    hf_outs = model(**inputs).logits
-
-    assert torch.allclose(timm_outs, hf_outs, atol=1e-3)
-
-    print(f"Saving model {swin_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--swin_name",
-        default="swin_tiny_patch4_window7_224",
-        type=str,
-        help="Name of the Swin timm model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_swin_checkpoint(args.swin_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/swin2sr/convert_swin2sr_original_to_pytorch.py b/src/transformers/models/swin2sr/convert_swin2sr_original_to_pytorch.py
deleted file mode 100644
index 29fe2e3e25de..000000000000
--- a/src/transformers/models/swin2sr/convert_swin2sr_original_to_pytorch.py
+++ /dev/null
@@ -1,278 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Swin2SR checkpoints from the original repository. URL: https://github.com/mv-lab/swin2sr"""
-
-import argparse
-
-import requests
-import torch
-from PIL import Image
-from torchvision.transforms import Compose, Normalize, Resize, ToTensor
-
-from transformers import Swin2SRConfig, Swin2SRForImageSuperResolution, Swin2SRImageProcessor
-
-
-def get_config(checkpoint_url):
-    config = Swin2SRConfig()
-
-    if "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
-        config.upscale = 4
-    elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
-        config.upscale = 4
-        config.image_size = 48
-        config.upsampler = "pixelshuffle_aux"
-    elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
-        config.depths = [6, 6, 6, 6]
-        config.embed_dim = 60
-        config.num_heads = [6, 6, 6, 6]
-        config.upsampler = "pixelshuffledirect"
-    elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
-        config.upscale = 4
-        config.upsampler = "nearest+conv"
-    elif "Swin2SR_Jpeg_dynamic" in checkpoint_url:
-        config.num_channels = 1
-        config.upscale = 1
-        config.image_size = 126
-        config.window_size = 7
-        config.img_range = 255.0
-        config.upsampler = ""
-
-    return config
-
-
-def rename_key(name, config):
-    if "patch_embed.proj" in name and "layers" not in name:
-        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "embeddings.patch_embeddings.layernorm")
-    if "layers" in name:
-        name = name.replace("layers", "encoder.stages")
-    if "residual_group.blocks" in name:
-        name = name.replace("residual_group.blocks", "layers")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name:
-        name = name.replace("attn", "attention.self")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "q_bias" in name:
-        name = name.replace("q_bias", "query.bias")
-    if "k_bias" in name:
-        name = name.replace("k_bias", "key.bias")
-    if "v_bias" in name:
-        name = name.replace("v_bias", "value.bias")
-    if "cpb_mlp" in name:
-        name = name.replace("cpb_mlp", "continuous_position_bias_mlp")
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "patch_embed.projection")
-
-    if name == "norm.weight":
-        name = "layernorm.weight"
-    if name == "norm.bias":
-        name = "layernorm.bias"
-
-    if "conv_first" in name:
-        name = name.replace("conv_first", "first_convolution")
-
-    if (
-        "upsample" in name
-        or "conv_before_upsample" in name
-        or "conv_bicubic" in name
-        or "conv_up" in name
-        or "conv_hr" in name
-        or "conv_last" in name
-        or "aux" in name
-    ):
-        # heads
-        if "conv_last" in name:
-            name = name.replace("conv_last", "final_convolution")
-        if config.upsampler in ["pixelshuffle", "pixelshuffle_aux", "nearest+conv"]:
-            if "conv_before_upsample.0" in name:
-                name = name.replace("conv_before_upsample.0", "conv_before_upsample")
-            if "upsample.0" in name:
-                name = name.replace("upsample.0", "upsample.convolution_0")
-            if "upsample.2" in name:
-                name = name.replace("upsample.2", "upsample.convolution_1")
-            name = "upsample." + name
-        elif config.upsampler == "pixelshuffledirect":
-            name = name.replace("upsample.0.weight", "upsample.conv.weight")
-            name = name.replace("upsample.0.bias", "upsample.conv.bias")
-        else:
-            pass
-    else:
-        name = "swin2sr." + name
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, config):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            stage_num = int(key_split[1])
-            block_num = int(key_split[4])
-            dim = config.embed_dim
-
-            if "weight" in key:
-                orig_state_dict[
-                    f"swin2sr.encoder.stages.{stage_num}.layers.{block_num}.attention.self.query.weight"
-                ] = val[:dim, :]
-                orig_state_dict[f"swin2sr.encoder.stages.{stage_num}.layers.{block_num}.attention.self.key.weight"] = (
-                    val[dim : dim * 2, :]
-                )
-                orig_state_dict[
-                    f"swin2sr.encoder.stages.{stage_num}.layers.{block_num}.attention.self.value.weight"
-                ] = val[-dim:, :]
-            else:
-                orig_state_dict[f"swin2sr.encoder.stages.{stage_num}.layers.{block_num}.attention.self.query.bias"] = (
-                    val[:dim]
-                )
-                orig_state_dict[f"swin2sr.encoder.stages.{stage_num}.layers.{block_num}.attention.self.key.bias"] = (
-                    val[dim : dim * 2]
-                )
-                orig_state_dict[f"swin2sr.encoder.stages.{stage_num}.layers.{block_num}.attention.self.value.bias"] = (
-                    val[-dim:]
-                )
-            pass
-        else:
-            orig_state_dict[rename_key(key, config)] = val
-
-    return orig_state_dict
-
-
-def convert_swin2sr_checkpoint(checkpoint_url, pytorch_dump_folder_path, push_to_hub):
-    config = get_config(checkpoint_url)
-    model = Swin2SRForImageSuperResolution(config)
-    model.eval()
-
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
-    new_state_dict = convert_state_dict(state_dict, config)
-    missing_keys, unexpected_keys = model.load_state_dict(new_state_dict, strict=False)
-
-    if len(missing_keys) > 0:
-        raise ValueError("Missing keys when converting: {}".format(missing_keys))
-    for key in unexpected_keys:
-        if not ("relative_position_index" in key or "relative_coords_table" in key or "self_mask" in key):
-            raise ValueError(f"Unexpected key {key} in state_dict")
-
-    # verify values
-    url = "https://github.com/mv-lab/swin2sr/blob/main/testsets/real-inputs/shanghai.jpg?raw=true"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-    processor = Swin2SRImageProcessor()
-    # pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    image_size = 126 if "Jpeg" in checkpoint_url else 256
-    transforms = Compose(
-        [
-            Resize((image_size, image_size)),
-            ToTensor(),
-            Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-        ]
-    )
-    pixel_values = transforms(image).unsqueeze(0)
-
-    if config.num_channels == 1:
-        pixel_values = pixel_values[:, 0, :, :].unsqueeze(1)
-
-    outputs = model(pixel_values)
-
-    # assert values
-    if "Swin2SR_ClassicalSR_X2_64" in checkpoint_url:
-        expected_shape = torch.Size([1, 3, 512, 512])
-        expected_slice = torch.tensor(
-            [[-0.7087, -0.7138, -0.6721], [-0.8340, -0.8095, -0.7298], [-0.9149, -0.8414, -0.7940]]
-        )
-    elif "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
-        expected_shape = torch.Size([1, 3, 1024, 1024])
-        expected_slice = torch.tensor(
-            [[-0.7775, -0.8105, -0.8933], [-0.7764, -0.8356, -0.9225], [-0.7976, -0.8686, -0.9579]]
-        )
-    elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
-        # TODO values didn't match exactly here
-        expected_shape = torch.Size([1, 3, 1024, 1024])
-        expected_slice = torch.tensor(
-            [[-0.8035, -0.7504, -0.7491], [-0.8538, -0.8124, -0.7782], [-0.8804, -0.8651, -0.8493]]
-        )
-    elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
-        expected_shape = torch.Size([1, 3, 512, 512])
-        expected_slice = torch.tensor(
-            [[-0.7669, -0.8662, -0.8767], [-0.8810, -0.9962, -0.9820], [-0.9340, -1.0322, -1.1149]]
-        )
-    elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
-        expected_shape = torch.Size([1, 3, 1024, 1024])
-        expected_slice = torch.tensor(
-            [[-0.5238, -0.5557, -0.6321], [-0.6016, -0.5903, -0.6391], [-0.6244, -0.6334, -0.6889]]
-        )
-
-    assert outputs.reconstruction.shape == expected_shape, (
-        f"Shape of reconstruction should be {expected_shape}, but is {outputs.reconstruction.shape}"
-    )
-    assert torch.allclose(outputs.reconstruction[0, 0, :3, :3], expected_slice, atol=1e-3)
-    print("Looks ok!")
-
-    url_to_name = {
-        "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X2_64.pth": (
-            "swin2SR-classical-sr-x2-64"
-        ),
-        "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X4_64.pth": (
-            "swin2SR-classical-sr-x4-64"
-        ),
-        "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_CompressedSR_X4_48.pth": (
-            "swin2SR-compressed-sr-x4-48"
-        ),
-        "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_Lightweight_X2_64.pth": (
-            "swin2SR-lightweight-x2-64"
-        ),
-        "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR.pth": (
-            "swin2SR-realworld-sr-x4-64-bsrgan-psnr"
-        ),
-    }
-    model_name = url_to_name[checkpoint_url]
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving image processor to {pytorch_dump_folder_path}")
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub(f"caidas/{model_name}")
-        processor.push_to_hub(f"caidas/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X2_64.pth",
-        type=str,
-        help="URL of the original Swin2SR checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the converted model to the hub.")
-
-    args = parser.parse_args()
-    convert_swin2sr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/swinv2/convert_swinv2_timm_to_pytorch.py b/src/transformers/models/swinv2/convert_swinv2_timm_to_pytorch.py
deleted file mode 100644
index 0e6e837a7e7e..000000000000
--- a/src/transformers/models/swinv2/convert_swinv2_timm_to_pytorch.py
+++ /dev/null
@@ -1,219 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Swinv2 checkpoints from the timm library."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import timm
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import AutoImageProcessor, Swinv2Config, Swinv2ForImageClassification
-
-
-def get_swinv2_config(swinv2_name):
-    config = Swinv2Config()
-    name_split = swinv2_name.split("_")
-
-    model_size = name_split[1]
-    if "to" in name_split[3]:
-        img_size = int(name_split[3][-3:])
-    else:
-        img_size = int(name_split[3])
-    if "to" in name_split[2]:
-        window_size = int(name_split[2][-2:])
-    else:
-        window_size = int(name_split[2][6:])
-
-    if model_size == "tiny":
-        embed_dim = 96
-        depths = (2, 2, 6, 2)
-        num_heads = (3, 6, 12, 24)
-    elif model_size == "small":
-        embed_dim = 96
-        depths = (2, 2, 18, 2)
-        num_heads = (3, 6, 12, 24)
-    elif model_size == "base":
-        embed_dim = 128
-        depths = (2, 2, 18, 2)
-        num_heads = (4, 8, 16, 32)
-    else:
-        embed_dim = 192
-        depths = (2, 2, 18, 2)
-        num_heads = (6, 12, 24, 48)
-
-    if "to" in swinv2_name:
-        config.pretrained_window_sizes = (12, 12, 12, 6)
-
-    if ("22k" in swinv2_name) and ("to" not in swinv2_name):
-        num_classes = 21841
-        repo_id = "huggingface/label-files"
-        filename = "imagenet-22k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    else:
-        num_classes = 1000
-        repo_id = "huggingface/label-files"
-        filename = "imagenet-1k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    config.image_size = img_size
-    config.num_labels = num_classes
-    config.embed_dim = embed_dim
-    config.depths = depths
-    config.num_heads = num_heads
-    config.window_size = window_size
-
-    return config
-
-
-def rename_key(name):
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "embeddings.norm")
-    if "layers" in name:
-        name = "encoder." + name
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name:
-        name = name.replace("attn", "attention.self")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "q_bias" in name:
-        name = name.replace("q_bias", "query.bias")
-    if "k_bias" in name:
-        name = name.replace("k_bias", "key.bias")
-    if "v_bias" in name:
-        name = name.replace("v_bias", "value.bias")
-    if "cpb_mlp" in name:
-        name = name.replace("cpb_mlp", "continuous_position_bias_mlp")
-    if name == "norm.weight":
-        name = "layernorm.weight"
-    if name == "norm.bias":
-        name = "layernorm.bias"
-
-    if "head" in name:
-        name = name.replace("head", "classifier")
-    else:
-        name = "swinv2." + name
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, model):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "mask" in key:
-            continue
-        elif "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[1])
-            block_num = int(key_split[3])
-            dim = model.swinv2.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size
-
-            if "weight" in key:
-                orig_state_dict[
-                    f"swinv2.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.weight"
-                ] = val[:dim, :]
-                orig_state_dict[f"swinv2.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.weight"] = (
-                    val[dim : dim * 2, :]
-                )
-                orig_state_dict[
-                    f"swinv2.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.weight"
-                ] = val[-dim:, :]
-            else:
-                orig_state_dict[f"swinv2.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.bias"] = (
-                    val[:dim]
-                )
-                orig_state_dict[f"swinv2.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.bias"] = val[
-                    dim : dim * 2
-                ]
-                orig_state_dict[f"swinv2.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.bias"] = (
-                    val[-dim:]
-                )
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-def convert_swinv2_checkpoint(swinv2_name, pytorch_dump_folder_path):
-    timm_model = timm.create_model(swinv2_name, pretrained=True)
-    timm_model.eval()
-
-    config = get_swinv2_config(swinv2_name)
-    model = Swinv2ForImageClassification(config)
-    model.eval()
-
-    new_state_dict = convert_state_dict(timm_model.state_dict(), model)
-    model.load_state_dict(new_state_dict)
-
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-
-    image_processor = AutoImageProcessor.from_pretrained("microsoft/{}".format(swinv2_name.replace("_", "-")))
-    image = Image.open(requests.get(url, stream=True).raw)
-    inputs = image_processor(images=image, return_tensors="pt")
-
-    timm_outs = timm_model(inputs["pixel_values"])
-    hf_outs = model(**inputs).logits
-
-    assert torch.allclose(timm_outs, hf_outs, atol=1e-3)
-
-    print(f"Saving model {swinv2_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    model.push_to_hub(
-        repo_path_or_name=Path(pytorch_dump_folder_path, swinv2_name),
-        organization="nandwalritik",
-        commit_message="Add model",
-    )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--swinv2_name",
-        default="swinv2_tiny_patch4_window8_256",
-        type=str,
-        help="Name of the Swinv2 timm model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_swinv2_checkpoint(args.swinv2_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/switch_transformers/convert_big_switch.py b/src/transformers/models/switch_transformers/convert_big_switch.py
deleted file mode 100644
index 6f422439fc7e..000000000000
--- a/src/transformers/models/switch_transformers/convert_big_switch.py
+++ /dev/null
@@ -1,194 +0,0 @@
-import argparse
-import json
-import os
-
-import tensorstore as ts
-import torch
-from flax import serialization
-from flax.traverse_util import flatten_dict, unflatten_dict
-from tensorflow.io import gfile
-
-from transformers.models.switch_transformers.convert_switch_transformers_original_flax_checkpoint_to_pytorch import (
-    rename_keys,
-)
-from transformers.utils import WEIGHTS_INDEX_NAME, WEIGHTS_NAME
-from transformers.utils.hub import convert_file_size_to_int
-
-
-def rename_base_flax_keys(flax_key_tuple, flax_tensor):
-    """
-    Post renaming of basic JAX keys to pytorch.
-    """
-    if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 3:
-        # expert layer
-        flax_key_tuple = flax_key_tuple[:-1] + ("weight",)
-        flax_tensor = torch.permute(flax_tensor, (0, 2, 1))
-    elif flax_key_tuple[-1] == "kernel" and ".".join(flax_key_tuple):
-        # linear layer
-        flax_key_tuple = flax_key_tuple[:-1] + ("weight",)
-        flax_tensor = flax_tensor.T
-    elif flax_key_tuple[-1] in ["scale", "embedding"]:
-        flax_key_tuple = flax_key_tuple[:-1] + ("weight",)
-
-    return flax_key_tuple, flax_tensor
-
-
-def get_key_and_tensorstore_dict(layer, checkpoint_info, switch_checkpoint_path):
-    if "metadata" in layer:
-        split_layer = layer.split("metadata")
-        curr_real_layer_name = "".join(split_layer[0])[:-1]
-        split_layer = [tuple(("metadata" + split_layer[1]).split("/"))]
-    elif "kvstore" in layer:
-        split_layer = layer.split("kvstore")
-        curr_real_layer_name = "".join(split_layer[0])[:-1]
-        split_layer = [tuple(("kvstore" + split_layer[1]).split("/"))]
-
-    else:
-        split_layer = layer.split("/")
-        curr_real_layer_name = "/".join(split_layer[:-1])
-        split_layer[-1] = (split_layer[-1],)
-
-    if "kvstore/path" in layer:
-        content = f"{switch_checkpoint_path}/{checkpoint_info[layer]}"
-    elif "kvstore/driver" in layer:
-        content = "file"
-    else:
-        content = checkpoint_info[layer]
-
-    return curr_real_layer_name, split_layer, content
-
-
-def rename_and_save_block(current_block, save_path):
-    current_block = rename_keys(current_block)
-    new_current_block = {}
-    for k, v in current_block.items():
-        new_current_block[k.replace("/", ".")] = v
-    current_block = new_current_block
-    torch.save(current_block, save_path)
-
-
-def shard_on_the_fly(switch_checkpoint_path, dump_path, max_shard_size, dtype, weights_name: str = WEIGHTS_NAME):
-    max_shard_size = convert_file_size_to_int(max_shard_size)
-    sharded_state_dicts = []
-    current_block = {}
-    current_block_size = 0
-    total_size = 0
-
-    os.makedirs(dump_path, exist_ok=True)
-    with gfile.GFile(switch_checkpoint_path + "/checkpoint", "rb") as fp:
-        checkpoint_info = serialization.msgpack_restore(fp.read())["optimizer"]["target"]
-        checkpoint_info = flatten_dict(checkpoint_info, sep="/")
-
-    all_layers = {}
-    for layer in checkpoint_info.keys():
-        curr_real_layer_name, split_layer, content = get_key_and_tensorstore_dict(
-            layer, checkpoint_info, switch_checkpoint_path
-        )
-        if curr_real_layer_name in all_layers:
-            all_layers[curr_real_layer_name][split_layer[-1]] = content
-        else:
-            all_layers[curr_real_layer_name] = {split_layer[-1]: content}
-
-    for key in all_layers.keys():
-        # open tensorstore file
-        raw_weights = ts.open(unflatten_dict(all_layers[key])).result().read().result()
-        raw_weights = torch.tensor(raw_weights)
-        weight_size = raw_weights.numel() * raw_weights.element_size()
-
-        # use the renaming pattern from the small conversion scripts
-        key, raw_weights = rename_base_flax_keys(tuple(key.split("/")), raw_weights)
-        key = "/".join(key)
-
-        # If this weight is going to tip up over the maximal size, we split.
-        if current_block_size + weight_size > max_shard_size:
-            save_path = os.path.join(
-                dump_path, weights_name.replace(".bin", f"-{len(sharded_state_dicts) + 1:05d}-of-???.bin")
-            )
-            rename_and_save_block(current_block, save_path)
-            sharded_state_dicts.append(current_block.keys())
-            del current_block
-            current_block = {}
-            current_block_size = 0
-
-        current_block[key] = raw_weights.to(getattr(torch, dtype))
-        current_block_size += weight_size
-        total_size += weight_size
-
-    # Add the last block
-    save_path = os.path.join(
-        dump_path, weights_name.replace(".bin", f"-{len(sharded_state_dicts) + 1:05d}-of-???.bin")
-    )
-    rename_and_save_block(current_block, save_path)
-    sharded_state_dicts.append(current_block.keys())
-
-    # If we only have one shard, we return it
-    if len(sharded_state_dicts) == 1:
-        return {weights_name: sharded_state_dicts[0]}, None
-
-    # Otherwise, let's build the index
-    weight_map = {}
-    shards = {}
-    for idx, shard in enumerate(sharded_state_dicts):
-        shard_file = weights_name.replace(
-            ".bin", f"-{idx + 1:05d}-of-{len(sharded_state_dicts):05d}.bin"
-        )  # len(sharded_state_dicts):05d}
-        temp_filename = os.path.join(dump_path, weights_name.replace(".bin", f"-{idx + 1:05d}-of-???.bin"))
-        os.rename(temp_filename, os.path.join(dump_path, shard_file))
-        shards[shard_file] = shard
-        for key in shard:
-            weight_map[key] = shard_file
-
-    # Add the metadata
-    metadata = {"total_size": total_size}
-    index = {"metadata": metadata, "weight_map": weight_map}
-
-    with open(os.path.join(dump_path, WEIGHTS_INDEX_NAME), "w", encoding="utf-8") as f:
-        content = json.dumps(index, indent=2, sort_keys=True) + "\n"
-        f.write(content)
-
-    return metadata, index
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--switch_t5x_checkpoint_path",
-        default="/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128/checkpoint_634600",
-        type=str,
-        required=False,
-        help="Path to a directory containing a folder per layer. Follows the original Google format.",
-    )
-    parser.add_argument("--max_shard_size", default="10GB", required=False, help="Max shard size")
-    parser.add_argument("--dtype", default="bfloat16", type=str, required=False, help="dtype of the saved model")
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128-converted",
-        type=str,
-        required=False,
-        help="Path to the output pytorch model.",
-    )
-    args = parser.parse_args()
-    shard_on_the_fly(
-        args.switch_t5x_checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.max_shard_size,
-        args.dtype,
-    )
-
-
-def sanity_check():
-    from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration, T5Tokenizer
-
-    config = SwitchTransformersConfig.from_pretrained("google/switch-base-8")
-    config.save_pretrained("/home/arthur_huggingface_co/transformers/switch_converted")
-    model = SwitchTransformersForConditionalGeneration.from_pretrained(
-        "/home/arthur_huggingface_co/transformers/switch_converted", device_map="auto"
-    )
-
-    tokenizer = T5Tokenizer.from_pretrained("google-t5/t5-small")
-    text = "A <extra_id_0> walks into a bar a orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>."
-
-    input_ids = tokenizer(text, return_tensors="pt").input_ids
-    out = model.generate(input_ids, decoder_start_token_id=0)
-    print(tokenizer.decode(out[0]))
diff --git a/src/transformers/models/switch_transformers/convert_switch_transformers_original_flax_checkpoint_to_pytorch.py b/src/transformers/models/switch_transformers/convert_switch_transformers_original_flax_checkpoint_to_pytorch.py
deleted file mode 100644
index 71d304ea96c6..000000000000
--- a/src/transformers/models/switch_transformers/convert_switch_transformers_original_flax_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,203 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert SwitchTransformersX checkpoints from the original repository to JAX/FLAX model."""
-
-import argparse
-import re
-
-from flax.traverse_util import flatten_dict, unflatten_dict
-from t5x import checkpoints
-
-from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration
-from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-# should not include what is already done by the `from_pt` argument
-MOE_LAYER_NAME_MAPPING = {
-    "/attention/": "/0/SelfAttention/",
-    "/self_attention/": "/0/SelfAttention/",
-    "/encoder_decoder_attention/": "/1/EncDecAttention/",
-    "value": "v",
-    "query": "q",
-    "key": "k",
-    "out": "o",
-    "pre_self_attention_layer_norm": "0/layer_norm",
-    "pre_cross_attention_layer_norm": "1/layer_norm",
-    "pre_attention_layer_norm": "0/layer_norm",  # previously 1, but seems wrong
-    "token_embedder": "shared",
-    "encoder_norm": "final_layer_norm",
-    "decoder_norm": "final_layer_norm",
-    "relpos_bias/rel_embedding": "block/0/layer/0/SelfAttention/relative_attention_bias/weight",
-    "router/router_weights/w/": "router/classifier/",
-    "roer/roer_weights/w/": "router/classifier/",
-    "logits_dense": "lm_head",
-}
-
-
-def rename_keys(s_dict):
-    # 1. in HF T5, we have block.{x}.layer.{y}. which corresponds to layer.{x} in
-    # the original model
-    keys = list(s_dict.keys())
-    for key in keys:
-        layer_to_block_of_layer = r".*/layers_(\d+)"
-        new_key = key
-        if re.match(layer_to_block_of_layer, key):
-            new_key = re.sub(r"layers_(\d+)", r"block/\1/layer", new_key)
-
-        layer_to_block_of_layer = r"(encoder|decoder)\/"
-
-        if re.match(layer_to_block_of_layer, key):
-            groups = re.match(layer_to_block_of_layer, new_key).groups()
-            if groups[0] == "encoder":
-                new_key = re.sub(r"/mlp/", r"/1/mlp/", new_key)
-                new_key = re.sub(r"/pre_mlp_layer_norm/", r"/1/layer_norm/", new_key)
-
-            elif groups[0] == "decoder":
-                new_key = re.sub(r"/mlp/", r"/2/mlp/", new_key)
-                new_key = re.sub(r"/pre_mlp_layer_norm/", r"/2/layer_norm/", new_key)
-
-        # 2. Convert other classic mappings
-        for old_key, temp_key in MOE_LAYER_NAME_MAPPING.items():
-            if old_key in new_key:
-                new_key = new_key.replace(old_key, temp_key)
-
-        print(f"{key} -> {new_key}")
-        s_dict[new_key] = s_dict.pop(key)
-
-    if "encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" in s_dict:
-        s_dict["encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight"] = s_dict[
-            "encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight"
-        ].T
-    if "decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" in s_dict:
-        s_dict["decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight"] = s_dict[
-            "decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight"
-        ].T
-
-    # 3. Take extra care of the EXPERTS layer
-    for key in list(s_dict.keys()):
-        if "expert" in key:
-            num_experts = s_dict[key].shape[0]
-            expert_weihts = s_dict[key]
-            for idx in range(num_experts):
-                s_dict[key.replace("expert/", f"experts/expert_{idx}/")] = expert_weihts[idx]
-                print(f"{key} -> {key.replace('expert/', f'experts/expert_{idx}/')}")
-
-            s_dict.pop(key)
-
-    return s_dict
-
-
-GIN_TO_CONFIG_MAPPING = {
-    "NUM_ENCODER_LAYERS": "num_layers",
-    "NUM_DECODER_LAYERS": "num_decoder_layers",
-    "NUM_HEADS": "num_heads",
-    "HEAD_DIM": "d_kv",
-    "EMBED_DIM": "d_model",
-    "MLP_DIM": "d_ff",
-    "NUM_SELECTED_EXPERTS": "num_selected_experts",
-    "NUM_ENCODER_SPARSE_LAYERS": "num_sparse_encoder_layers",
-    "NUM_DECODER_SPARSE_LAYERS": "num_sparse_decoder_layers",
-    "dense.MlpBlock.activations": "feed_forward_proj",
-}
-
-
-def convert_gin_to_config(gin_file, num_experts):
-    # Convert a google style config to the hugging face format
-    import regex as re
-
-    with open(gin_file, "r") as f:
-        raw_gin = f.read()
-
-    regex_match = re.findall(r"(.*) = ([0-9.]*)", raw_gin)
-    args = {}
-    for param, value in regex_match:
-        if param in GIN_TO_CONFIG_MAPPING and value != "":
-            args[GIN_TO_CONFIG_MAPPING[param]] = float(value) if "." in value else int(value)
-
-    activation = re.findall(r"(.*activations) = \(\'(.*)\',\)", raw_gin)[0]
-    args[GIN_TO_CONFIG_MAPPING[activation[0]]] = str(activation[1])
-
-    args["num_experts"] = num_experts
-    config = SwitchTransformersConfig(**args)
-    return config
-
-
-def convert_flax_checkpoint_to_pytorch(
-    flax_checkpoint_path, config_file, gin_file=None, pytorch_dump_path="./", num_experts=8
-):
-    # Initialise PyTorch model
-
-    print(f"Loading flax weights from : {flax_checkpoint_path}")
-    flax_params = checkpoints.load_t5x_checkpoint(flax_checkpoint_path)
-
-    if gin_file is not None:
-        config = convert_gin_to_config(gin_file, num_experts)
-    else:
-        config = SwitchTransformersConfig.from_pretrained(config_file)
-
-    pt_model = SwitchTransformersForConditionalGeneration(config)
-
-    flax_params = flax_params["target"]
-    flax_params = flatten_dict(flax_params, sep="/")
-    flax_params = rename_keys(flax_params)
-    flax_params = unflatten_dict(flax_params, sep="/")
-
-    # Load the flax params in the PT model
-    load_flax_weights_in_pytorch_model(pt_model, flax_params)
-
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    pt_model.save_pretrained(pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--switch_t5x_checkpoint_path",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained SwitchTransformers model. \nThis specifies the"
-            " model architecture. If not provided, a `gin_file` has to be provided."
-        ),
-    )
-    parser.add_argument(
-        "--gin_file",
-        default=None,
-        type=str,
-        required=False,
-        help="Path to the gin config file. If not provided, a `config_file` has to be passed   ",
-    )
-    parser.add_argument(
-        "--config_name", default=None, type=str, required=False, help="Config name of SwitchTransformers model."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output pytorch model."
-    )
-    parser.add_argument("--num_experts", default=8, type=int, required=False, help="Number of experts")
-    args = parser.parse_args()
-    convert_flax_checkpoint_to_pytorch(
-        args.switch_t5x_checkpoint_path,
-        args.config_name,
-        args.gin_file,
-        args.pytorch_dump_folder_path,
-        args.num_experts,
-    )
diff --git a/src/transformers/models/t5/convert_t5_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/t5/convert_t5_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index 9b1b15857cea..000000000000
--- a/src/transformers/models/t5/convert_t5_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The T5 authors and HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert T5 checkpoint."""
-
-import argparse
-
-from transformers import T5Config, T5ForConditionalGeneration, load_tf_weights_in_t5
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path):
-    # Initialise PyTorch model
-    config = T5Config.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    model = T5ForConditionalGeneration(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_t5(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/t5/convert_t5x_checkpoint_to_flax.py b/src/transformers/models/t5/convert_t5x_checkpoint_to_flax.py
deleted file mode 100644
index 12498359d21b..000000000000
--- a/src/transformers/models/t5/convert_t5x_checkpoint_to_flax.py
+++ /dev/null
@@ -1,235 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Convert T5X checkpoints from the original repository to JAX/FLAX model."""
-
-import argparse
-
-from t5x import checkpoints
-
-from transformers import FlaxT5ForConditionalGeneration, T5Config
-
-
-def convert_t5x_checkpoint_to_flax(t5x_checkpoint_path, config_name, flax_dump_folder_path):
-    config = T5Config.from_pretrained(config_name)
-    flax_model = FlaxT5ForConditionalGeneration(config=config)
-    t5x_model = checkpoints.load_t5x_checkpoint(t5x_checkpoint_path)
-
-    split_mlp_wi = "wi_0" in t5x_model["target"]["encoder"]["layers_0"]["mlp"]
-
-    # Encoder
-    for layer_index in range(config.num_layers):
-        layer_name = f"layers_{str(layer_index)}"
-
-        # Self-Attention
-        t5x_attention_key = t5x_model["target"]["encoder"][layer_name]["attention"]["key"]["kernel"]
-        t5x_attention_out = t5x_model["target"]["encoder"][layer_name]["attention"]["out"]["kernel"]
-        t5x_attention_query = t5x_model["target"]["encoder"][layer_name]["attention"]["query"]["kernel"]
-        t5x_attention_value = t5x_model["target"]["encoder"][layer_name]["attention"]["value"]["kernel"]
-
-        # Layer Normalization
-        t5x_attention_layer_norm = t5x_model["target"]["encoder"][layer_name]["pre_attention_layer_norm"]["scale"]
-
-        if split_mlp_wi:
-            t5x_mlp_wi_0 = t5x_model["target"]["encoder"][layer_name]["mlp"]["wi_0"]["kernel"]
-            t5x_mlp_wi_1 = t5x_model["target"]["encoder"][layer_name]["mlp"]["wi_1"]["kernel"]
-        else:
-            t5x_mlp_wi = t5x_model["target"]["encoder"][layer_name]["mlp"]["wi"]["kernel"]
-
-        t5x_mlp_wo = t5x_model["target"]["encoder"][layer_name]["mlp"]["wo"]["kernel"]
-
-        # Layer Normalization
-        t5x_mlp_layer_norm = t5x_model["target"]["encoder"][layer_name]["pre_mlp_layer_norm"]["scale"]
-
-        # Assigning
-        flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["0"]["SelfAttention"]["k"]["kernel"] = (
-            t5x_attention_key
-        )
-        flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["0"]["SelfAttention"]["o"]["kernel"] = (
-            t5x_attention_out
-        )
-        flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["0"]["SelfAttention"]["q"]["kernel"] = (
-            t5x_attention_query
-        )
-        flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["0"]["SelfAttention"]["v"]["kernel"] = (
-            t5x_attention_value
-        )
-
-        flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["0"]["layer_norm"]["weight"] = (
-            t5x_attention_layer_norm
-        )
-
-        if split_mlp_wi:
-            flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["1"]["DenseReluDense"]["wi_0"][
-                "kernel"
-            ] = t5x_mlp_wi_0
-            flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["1"]["DenseReluDense"]["wi_1"][
-                "kernel"
-            ] = t5x_mlp_wi_1
-        else:
-            flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["1"]["DenseReluDense"]["wi"]["kernel"] = (
-                t5x_mlp_wi
-            )
-
-        flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["1"]["DenseReluDense"]["wo"]["kernel"] = (
-            t5x_mlp_wo
-        )
-        flax_model.params["encoder"]["block"][str(layer_index)]["layer"]["1"]["layer_norm"]["weight"] = (
-            t5x_mlp_layer_norm
-        )
-
-    # Only for layer 0:
-    t5x_encoder_rel_embedding = t5x_model["target"]["encoder"]["relpos_bias"]["rel_embedding"].T
-    flax_model.params["encoder"]["block"]["0"]["layer"]["0"]["SelfAttention"]["relative_attention_bias"][
-        "embedding"
-    ] = t5x_encoder_rel_embedding
-
-    # Assigning
-    t5x_encoder_norm = t5x_model["target"]["encoder"]["encoder_norm"]["scale"]
-    flax_model.params["encoder"]["final_layer_norm"]["weight"] = t5x_encoder_norm
-
-    # Decoder
-    for layer_index in range(config.num_decoder_layers):
-        layer_name = f"layers_{str(layer_index)}"
-
-        # Self-Attention
-        t5x_attention_key = t5x_model["target"]["decoder"][layer_name]["self_attention"]["key"]["kernel"]
-        t5x_attention_out = t5x_model["target"]["decoder"][layer_name]["self_attention"]["out"]["kernel"]
-        t5x_attention_query = t5x_model["target"]["decoder"][layer_name]["self_attention"]["query"]["kernel"]
-        t5x_attention_value = t5x_model["target"]["decoder"][layer_name]["self_attention"]["value"]["kernel"]
-
-        # Layer Normalization
-        t5x_pre_attention_layer_norm = t5x_model["target"]["decoder"][layer_name]["pre_self_attention_layer_norm"][
-            "scale"
-        ]
-
-        # Encoder-Decoder-Attention
-        t5x_enc_dec_attention_key = t5x_model["target"]["decoder"][layer_name]["encoder_decoder_attention"]["key"][
-            "kernel"
-        ]
-        t5x_enc_dec_attention_out = t5x_model["target"]["decoder"][layer_name]["encoder_decoder_attention"]["out"][
-            "kernel"
-        ]
-        t5x_enc_dec_attention_query = t5x_model["target"]["decoder"][layer_name]["encoder_decoder_attention"]["query"][
-            "kernel"
-        ]
-        t5x_enc_dec_attention_value = t5x_model["target"]["decoder"][layer_name]["encoder_decoder_attention"]["value"][
-            "kernel"
-        ]
-
-        # Layer Normalization
-        t5x_cross_layer_norm = t5x_model["target"]["decoder"][layer_name]["pre_cross_attention_layer_norm"]["scale"]
-
-        # MLP
-        if split_mlp_wi:
-            t5x_mlp_wi_0 = t5x_model["target"]["decoder"][layer_name]["mlp"]["wi_0"]["kernel"]
-            t5x_mlp_wi_1 = t5x_model["target"]["decoder"][layer_name]["mlp"]["wi_1"]["kernel"]
-        else:
-            t5x_mlp_wi = t5x_model["target"]["decoder"][layer_name]["mlp"]["wi"]["kernel"]
-
-        t5x_mlp_wo = t5x_model["target"]["decoder"][layer_name]["mlp"]["wo"]["kernel"]
-
-        # Layer Normalization
-        tx5_mlp_layer_norm = t5x_model["target"]["decoder"][layer_name]["pre_mlp_layer_norm"]["scale"]
-
-        # Assigning
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["0"]["SelfAttention"]["k"]["kernel"] = (
-            t5x_attention_key
-        )
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["0"]["SelfAttention"]["o"]["kernel"] = (
-            t5x_attention_out
-        )
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["0"]["SelfAttention"]["q"]["kernel"] = (
-            t5x_attention_query
-        )
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["0"]["SelfAttention"]["v"]["kernel"] = (
-            t5x_attention_value
-        )
-
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["0"]["layer_norm"]["weight"] = (
-            t5x_pre_attention_layer_norm
-        )
-
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["1"]["EncDecAttention"]["k"]["kernel"] = (
-            t5x_enc_dec_attention_key
-        )
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["1"]["EncDecAttention"]["o"]["kernel"] = (
-            t5x_enc_dec_attention_out
-        )
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["1"]["EncDecAttention"]["q"]["kernel"] = (
-            t5x_enc_dec_attention_query
-        )
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["1"]["EncDecAttention"]["v"]["kernel"] = (
-            t5x_enc_dec_attention_value
-        )
-
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["1"]["layer_norm"]["weight"] = (
-            t5x_cross_layer_norm
-        )
-
-        if split_mlp_wi:
-            flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["2"]["DenseReluDense"]["wi_0"][
-                "kernel"
-            ] = t5x_mlp_wi_0
-            flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["2"]["DenseReluDense"]["wi_1"][
-                "kernel"
-            ] = t5x_mlp_wi_1
-        else:
-            flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["2"]["DenseReluDense"]["wi"]["kernel"] = (
-                t5x_mlp_wi
-            )
-
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["2"]["DenseReluDense"]["wo"]["kernel"] = (
-            t5x_mlp_wo
-        )
-
-        flax_model.params["decoder"]["block"][str(layer_index)]["layer"]["2"]["layer_norm"]["weight"] = (
-            tx5_mlp_layer_norm
-        )
-
-    # Decoder Normalization
-    tx5_decoder_norm = t5x_model["target"]["decoder"]["decoder_norm"]["scale"]
-    flax_model.params["decoder"]["final_layer_norm"]["weight"] = tx5_decoder_norm
-
-    # Only for layer 0:
-    t5x_decoder_rel_embedding = t5x_model["target"]["decoder"]["relpos_bias"]["rel_embedding"].T
-    flax_model.params["decoder"]["block"]["0"]["layer"]["0"]["SelfAttention"]["relative_attention_bias"][
-        "embedding"
-    ] = t5x_decoder_rel_embedding
-
-    # Token Embeddings
-    tx5_token_embeddings = t5x_model["target"]["token_embedder"]["embedding"]
-    flax_model.params["shared"]["embedding"] = tx5_token_embeddings
-
-    # LM Head (only in v1.1 checkpoints)
-    if "logits_dense" in t5x_model["target"]["decoder"]:
-        flax_model.params["lm_head"]["kernel"] = t5x_model["target"]["decoder"]["logits_dense"]["kernel"]
-
-    flax_model.save_pretrained(flax_dump_folder_path)
-    print("T5X Model was successfully converted!")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--t5x_checkpoint_path", default=None, type=str, required=True, help="Path the TX5 checkpoint."
-    )
-    parser.add_argument("--config_name", default=None, type=str, required=True, help="Config name of T5 model.")
-    parser.add_argument(
-        "--flax_dump_folder_path", default=None, type=str, required=True, help="Path to the output FLAX model."
-    )
-    args = parser.parse_args()
-    convert_t5x_checkpoint_to_flax(args.t5x_checkpoint_path, args.config_name, args.flax_dump_folder_path)
diff --git a/src/transformers/models/t5/convert_t5x_checkpoint_to_pytorch.py b/src/transformers/models/t5/convert_t5x_checkpoint_to_pytorch.py
deleted file mode 100755
index 5e7d9ef33d3e..000000000000
--- a/src/transformers/models/t5/convert_t5x_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,238 +0,0 @@
-# coding=utf-8
-# Copyright 2022 Google LLC and HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Convert T5X checkpoint to PyTorch
-
-Steps:
-- Install gsutil according to https://cloud.google.com/storage/docs/gsutil_install
-- Get a T5X checkpoint at https://github.com/google-research/t5x/blob/main/docs/models.md#t5-11-checkpoints Example:
-    `gsutil -m cp -r gs://t5-data/pretrained_models/t5x/t5_1_1_small $HOME/`
-- Create or download a corresponding config for the downloaded model. E.g. for T5 v1.1 small, you can use
-    https://huggingface.co/google/t5-v1_1-small/blob/main/config.json
-- Convert:
-    ```
-    python3 convert_t5x_checkpoint_to_pytorch.py --t5x_checkpoint_path=$HOME/t5_1_1_small --config_file=config.json\
-      --pytorch_dump_path=$HOME/t5_1_1_small_pt
-    ```
-"""
-
-import argparse
-import collections
-
-import torch
-from flax import traverse_util
-from t5x import checkpoints
-
-from transformers import T5Config, T5EncoderModel, T5ForConditionalGeneration
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def t5x_attention_lookup(params, i, prefix, layer_name="attention"):
-    """Returns the KOQV parameters of (self-)attention. Does not transpose."""
-    k = params[f"{prefix}/layers_{i}/{layer_name}/key/kernel"]
-    o = params[f"{prefix}/layers_{i}/{layer_name}/out/kernel"]
-    q = params[f"{prefix}/layers_{i}/{layer_name}/query/kernel"]
-    v = params[f"{prefix}/layers_{i}/{layer_name}/value/kernel"]
-    return k, o, q, v
-
-
-def t5x_mlp_lookup(params, i, prefix, split_mlp_wi=False):
-    """Returns the MLP parameters of a layer. Does not transpose."""
-    if split_mlp_wi:
-        wi_0 = params[f"{prefix}/layers_{i}/mlp/wi_0/kernel"]
-        wi_1 = params[f"{prefix}/layers_{i}/mlp/wi_1/kernel"]
-        wi = (wi_0, wi_1)
-    else:
-        wi = params[f"{prefix}/layers_{i}/mlp/wi/kernel"]
-
-    wo = params[f"{prefix}/layers_{i}/mlp/wo/kernel"]
-    return wi, wo
-
-
-def t5x_layer_norm_lookup(params, i, prefix, layer_name):
-    """Returns the layer norm param of a layer."""
-    return params[f"{prefix}/layers_{i}/{layer_name}/scale"]
-
-
-def convert_t5x_to_pytorch(variables: dict, *, num_layers: int, num_decoder_layers: int, is_encoder_only: bool):
-    """Converts the parameters from T5X-Flax to Transformers-PyTorch."""
-    old = traverse_util.flatten_dict(variables["target"])
-    old = {"/".join(k): v for k, v in old.items()}
-
-    # v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
-    split_mlp_wi = "encoder/layers_0/mlp/wi_0/kernel" in old
-    print("Split MLP:", split_mlp_wi)
-
-    new = collections.OrderedDict()
-
-    # Shared embeddings.
-    new["shared.weight"] = old["token_embedder/embedding"]
-
-    # Encoder.
-    for i in range(num_layers):
-        # Block i, layer 0 (Self Attention).
-        layer_norm = t5x_layer_norm_lookup(old, i, "encoder", "pre_attention_layer_norm")
-        k, o, q, v = t5x_attention_lookup(old, i, "encoder", "attention")
-        new[f"encoder.block.{i}.layer.0.layer_norm.weight"] = layer_norm
-        new[f"encoder.block.{i}.layer.0.SelfAttention.k.weight"] = k.T
-        new[f"encoder.block.{i}.layer.0.SelfAttention.o.weight"] = o.T
-        new[f"encoder.block.{i}.layer.0.SelfAttention.q.weight"] = q.T
-        new[f"encoder.block.{i}.layer.0.SelfAttention.v.weight"] = v.T
-
-        # Block i, layer 1 (MLP).
-        layer_norm = t5x_layer_norm_lookup(old, i, "encoder", "pre_mlp_layer_norm")
-        wi, wo = t5x_mlp_lookup(old, i, "encoder", split_mlp_wi)
-        new[f"encoder.block.{i}.layer.1.layer_norm.weight"] = layer_norm
-        if split_mlp_wi:
-            new[f"encoder.block.{i}.layer.1.DenseReluDense.wi_0.weight"] = wi[0].T
-            new[f"encoder.block.{i}.layer.1.DenseReluDense.wi_1.weight"] = wi[1].T
-        else:
-            new[f"encoder.block.{i}.layer.1.DenseReluDense.wi.weight"] = wi.T
-        new[f"encoder.block.{i}.layer.1.DenseReluDense.wo.weight"] = wo.T
-
-    new["encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight"] = old[
-        "encoder/relpos_bias/rel_embedding"
-    ].T
-    new["encoder.final_layer_norm.weight"] = old["encoder/encoder_norm/scale"]
-
-    if not is_encoder_only:
-        # Decoder.
-        for i in range(num_decoder_layers):
-            # Block i, layer 0 (Self Attention).
-            layer_norm = t5x_layer_norm_lookup(old, i, "decoder", "pre_self_attention_layer_norm")
-            k, o, q, v = t5x_attention_lookup(old, i, "decoder", "self_attention")
-            new[f"decoder.block.{i}.layer.0.layer_norm.weight"] = layer_norm
-            new[f"decoder.block.{i}.layer.0.SelfAttention.k.weight"] = k.T
-            new[f"decoder.block.{i}.layer.0.SelfAttention.o.weight"] = o.T
-            new[f"decoder.block.{i}.layer.0.SelfAttention.q.weight"] = q.T
-            new[f"decoder.block.{i}.layer.0.SelfAttention.v.weight"] = v.T
-
-            # Block i, layer 1 (Cross Attention).
-            layer_norm = t5x_layer_norm_lookup(old, i, "decoder", "pre_cross_attention_layer_norm")
-            k, o, q, v = t5x_attention_lookup(old, i, "decoder", "encoder_decoder_attention")
-            new[f"decoder.block.{i}.layer.1.layer_norm.weight"] = layer_norm
-            new[f"decoder.block.{i}.layer.1.EncDecAttention.k.weight"] = k.T
-            new[f"decoder.block.{i}.layer.1.EncDecAttention.o.weight"] = o.T
-            new[f"decoder.block.{i}.layer.1.EncDecAttention.q.weight"] = q.T
-            new[f"decoder.block.{i}.layer.1.EncDecAttention.v.weight"] = v.T
-
-            # Block i, layer 2 (MLP).
-            layer_norm = t5x_layer_norm_lookup(old, i, "decoder", "pre_mlp_layer_norm")
-            wi, wo = t5x_mlp_lookup(old, i, "decoder", split_mlp_wi)
-            new[f"decoder.block.{i}.layer.2.layer_norm.weight"] = layer_norm
-            if split_mlp_wi:
-                new[f"decoder.block.{i}.layer.2.DenseReluDense.wi_0.weight"] = wi[0].T
-                new[f"decoder.block.{i}.layer.2.DenseReluDense.wi_1.weight"] = wi[1].T
-            else:
-                new[f"decoder.block.{i}.layer.2.DenseReluDense.wi.weight"] = wi.T
-            new[f"decoder.block.{i}.layer.2.DenseReluDense.wo.weight"] = wo.T
-
-        new["decoder.final_layer_norm.weight"] = old["decoder/decoder_norm/scale"]
-        new["decoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight"] = old[
-            "decoder/relpos_bias/rel_embedding"
-        ].T
-
-        # LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
-        if "decoder/logits_dense/kernel" in old:
-            new["lm_head.weight"] = old["decoder/logits_dense/kernel"].T
-
-    return new
-
-
-def make_state_dict(converted_params, is_encoder_only: bool):
-    """Prepares a state dict for the PyTorch model."""
-    # Make a state dict with torch tensors.
-    state_dict = collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])
-
-    # Add what is missing.
-    if "encoder.embed_tokens.weight" not in state_dict:
-        state_dict["encoder.embed_tokens.weight"] = state_dict["shared.weight"]
-
-    if not is_encoder_only:
-        if "decoder.embed_tokens.weight" not in state_dict:
-            state_dict["decoder.embed_tokens.weight"] = state_dict["shared.weight"]
-
-        if "lm_head.weight" not in state_dict:  # For old 1.0 models.
-            print("Using shared word embeddings as lm_head.")
-            state_dict["lm_head.weight"] = state_dict["shared.weight"]
-
-    return state_dict
-
-
-def load_t5x_weights_in_t5(model, config, t5x_checkpoint_path, is_encoder_only):
-    """Replaces the params in model witht the T5X converted params."""
-    variables = checkpoints.load_t5x_checkpoint(t5x_checkpoint_path)
-    converted = convert_t5x_to_pytorch(
-        variables,
-        num_layers=config.num_layers,
-        num_decoder_layers=config.num_decoder_layers,
-        is_encoder_only=is_encoder_only,
-    )
-    state_dict = make_state_dict(converted, is_encoder_only)
-    model.load_state_dict(state_dict, strict=True)
-
-
-def convert_t5x_checkpoint_to_pytorch(
-    t5x_checkpoint_path, config_file, pytorch_dump_path, is_encoder_only: bool = False
-):
-    """Loads the config and model, converts the T5X checkpoint, and saves a PyTorch checkpoint."""
-    # Initialise PyTorch model
-    config = T5Config.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    # Non-v1.1 checkpoints could also use T5Model, but this works for all.
-    # The v1.0 checkpoints will simply have an LM head that is the word embeddings.
-    if is_encoder_only:
-        model = T5EncoderModel(config)
-    else:
-        model = T5ForConditionalGeneration(config)
-
-    # Load weights from tf checkpoint
-    load_t5x_weights_in_t5(model, config, t5x_checkpoint_path, is_encoder_only)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-    # Verify that we can load the checkpoint.
-    model.from_pretrained(pytorch_dump_path)
-    print("Done")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Converts a native T5X checkpoint into a PyTorch checkpoint.")
-    # Required parameters
-    parser.add_argument(
-        "--t5x_checkpoint_path", default=None, type=str, required=True, help="Path to the T5X checkpoint."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--is_encoder_only", action="store_true", help="Check if the model is encoder-decoder model", default=False
-    )
-    args = parser.parse_args()
-    convert_t5x_checkpoint_to_pytorch(
-        args.t5x_checkpoint_path, args.config_file, args.pytorch_dump_path, args.is_encoder_only
-    )
diff --git a/src/transformers/models/table_transformer/convert_table_transformer_to_hf.py b/src/transformers/models/table_transformer/convert_table_transformer_to_hf.py
deleted file mode 100644
index 487cdc481992..000000000000
--- a/src/transformers/models/table_transformer/convert_table_transformer_to_hf.py
+++ /dev/null
@@ -1,317 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Table Transformer checkpoints with timm-backbone.
-
-URL: https://github.com/microsoft/table-transformer
-"""
-
-import argparse
-from collections import OrderedDict
-from pathlib import Path
-
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision.transforms import functional as F
-
-from transformers import DetrImageProcessor, TableTransformerConfig, TableTransformerForObjectDetection
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-rename_keys = []
-for i in range(6):
-    # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.self_attn.out_proj.weight", f"encoder.layers.{i}.self_attn.out_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.self_attn.out_proj.bias", f"encoder.layers.{i}.self_attn.out_proj.bias")
-    )
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear1.weight", f"encoder.layers.{i}.fc1.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear1.bias", f"encoder.layers.{i}.fc1.bias"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear2.weight", f"encoder.layers.{i}.fc2.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.linear2.bias", f"encoder.layers.{i}.fc2.bias"))
-    rename_keys.append(
-        (f"transformer.encoder.layers.{i}.norm1.weight", f"encoder.layers.{i}.self_attn_layer_norm.weight")
-    )
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm1.bias", f"encoder.layers.{i}.self_attn_layer_norm.bias"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm2.weight", f"encoder.layers.{i}.final_layer_norm.weight"))
-    rename_keys.append((f"transformer.encoder.layers.{i}.norm2.bias", f"encoder.layers.{i}.final_layer_norm.bias"))
-    # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.self_attn.out_proj.weight", f"decoder.layers.{i}.self_attn.out_proj.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.self_attn.out_proj.bias", f"decoder.layers.{i}.self_attn.out_proj.bias")
-    )
-    rename_keys.append(
-        (
-            f"transformer.decoder.layers.{i}.multihead_attn.out_proj.weight",
-            f"decoder.layers.{i}.encoder_attn.out_proj.weight",
-        )
-    )
-    rename_keys.append(
-        (
-            f"transformer.decoder.layers.{i}.multihead_attn.out_proj.bias",
-            f"decoder.layers.{i}.encoder_attn.out_proj.bias",
-        )
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear1.weight", f"decoder.layers.{i}.fc1.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear1.bias", f"decoder.layers.{i}.fc1.bias"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear2.weight", f"decoder.layers.{i}.fc2.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.linear2.bias", f"decoder.layers.{i}.fc2.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm1.weight", f"decoder.layers.{i}.self_attn_layer_norm.weight")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm1.bias", f"decoder.layers.{i}.self_attn_layer_norm.bias"))
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm2.weight", f"decoder.layers.{i}.encoder_attn_layer_norm.weight")
-    )
-    rename_keys.append(
-        (f"transformer.decoder.layers.{i}.norm2.bias", f"decoder.layers.{i}.encoder_attn_layer_norm.bias")
-    )
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm3.weight", f"decoder.layers.{i}.final_layer_norm.weight"))
-    rename_keys.append((f"transformer.decoder.layers.{i}.norm3.bias", f"decoder.layers.{i}.final_layer_norm.bias"))
-
-# convolutional projection + query embeddings + layernorm of encoder + layernorm of decoder + class and bounding box heads
-rename_keys.extend(
-    [
-        ("input_proj.weight", "input_projection.weight"),
-        ("input_proj.bias", "input_projection.bias"),
-        ("query_embed.weight", "query_position_embeddings.weight"),
-        ("transformer.encoder.norm.weight", "encoder.layernorm.weight"),
-        ("transformer.encoder.norm.bias", "encoder.layernorm.bias"),
-        ("transformer.decoder.norm.weight", "decoder.layernorm.weight"),
-        ("transformer.decoder.norm.bias", "decoder.layernorm.bias"),
-        ("class_embed.weight", "class_labels_classifier.weight"),
-        ("class_embed.bias", "class_labels_classifier.bias"),
-        ("bbox_embed.layers.0.weight", "bbox_predictor.layers.0.weight"),
-        ("bbox_embed.layers.0.bias", "bbox_predictor.layers.0.bias"),
-        ("bbox_embed.layers.1.weight", "bbox_predictor.layers.1.weight"),
-        ("bbox_embed.layers.1.bias", "bbox_predictor.layers.1.bias"),
-        ("bbox_embed.layers.2.weight", "bbox_predictor.layers.2.weight"),
-        ("bbox_embed.layers.2.bias", "bbox_predictor.layers.2.bias"),
-    ]
-)
-
-
-def rename_key(state_dict, old, new):
-    val = state_dict.pop(old)
-    state_dict[new] = val
-
-
-def rename_backbone_keys(state_dict):
-    new_state_dict = OrderedDict()
-    for key, value in state_dict.items():
-        if "backbone.0.body" in key:
-            new_key = key.replace("backbone.0.body", "backbone.conv_encoder.model")
-            new_state_dict[new_key] = value
-        else:
-            new_state_dict[key] = value
-
-    return new_state_dict
-
-
-def read_in_q_k_v(state_dict):
-    prefix = ""
-
-    # first: transformer encoder
-    for i in range(6):
-        # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-    # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
-    for i in range(6):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-        # read in weights + bias of input projection layer of cross-attention
-        in_proj_weight_cross_attn = state_dict.pop(
-            f"{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight"
-        )
-        in_proj_bias_cross_attn = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) of cross-attention to the state dict
-        state_dict[f"decoder.layers.{i}.encoder_attn.q_proj.weight"] = in_proj_weight_cross_attn[:256, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.q_proj.bias"] = in_proj_bias_cross_attn[:256]
-        state_dict[f"decoder.layers.{i}.encoder_attn.k_proj.weight"] = in_proj_weight_cross_attn[256:512, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.k_proj.bias"] = in_proj_bias_cross_attn[256:512]
-        state_dict[f"decoder.layers.{i}.encoder_attn.v_proj.weight"] = in_proj_weight_cross_attn[-256:, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.v_proj.bias"] = in_proj_bias_cross_attn[-256:]
-
-
-def resize(image, checkpoint_url):
-    width, height = image.size
-    current_max_size = max(width, height)
-    target_max_size = 800 if "detection" in checkpoint_url else 1000
-    scale = target_max_size / current_max_size
-    resized_image = image.resize((int(round(scale * width)), int(round(scale * height))))
-
-    return resized_image
-
-
-def normalize(image):
-    image = F.to_tensor(image)
-    image = F.normalize(image, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-    return image
-
-
-@torch.no_grad()
-def convert_table_transformer_checkpoint(checkpoint_url, pytorch_dump_folder_path, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our DETR structure.
-    """
-
-    logger.info("Converting model...")
-
-    # load original state dict
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
-    # rename keys
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    state_dict = rename_backbone_keys(state_dict)
-    # query, key and value matrices need special treatment
-    read_in_q_k_v(state_dict)
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    prefix = "model."
-    for key in state_dict.copy().keys():
-        if not key.startswith("class_labels_classifier") and not key.startswith("bbox_predictor"):
-            val = state_dict.pop(key)
-            state_dict[prefix + key] = val
-    # create HuggingFace model and load state dict
-    config = TableTransformerConfig(
-        backbone="resnet18",
-        mask_loss_coefficient=1,
-        dice_loss_coefficient=1,
-        ce_loss_coefficient=1,
-        bbox_loss_coefficient=5,
-        giou_loss_coefficient=2,
-        eos_coefficient=0.4,
-        class_cost=1,
-        bbox_cost=5,
-        giou_cost=2,
-    )
-
-    if "detection" in checkpoint_url:
-        config.num_queries = 15
-        config.num_labels = 2
-        id2label = {0: "table", 1: "table rotated"}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-    else:
-        config.num_queries = 125
-        config.num_labels = 6
-        id2label = {
-            0: "table",
-            1: "table column",
-            2: "table row",
-            3: "table column header",
-            4: "table projected row header",
-            5: "table spanning cell",
-        }
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    image_processor = DetrImageProcessor(
-        format="coco_detection", max_size=800 if "detection" in checkpoint_url else 1000
-    )
-    model = TableTransformerForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # verify our conversion
-    filename = "example_pdf.png" if "detection" in checkpoint_url else "example_table.png"
-    file_path = hf_hub_download(repo_id="nielsr/example-pdf", repo_type="dataset", filename=filename)
-    image = Image.open(file_path).convert("RGB")
-    pixel_values = normalize(resize(image, checkpoint_url)).unsqueeze(0)
-
-    outputs = model(pixel_values)
-
-    if "detection" in checkpoint_url:
-        expected_shape = (1, 15, 3)
-        expected_logits = torch.tensor(
-            [[-6.7897, -16.9985, 6.7937], [-8.0186, -22.2192, 6.9677], [-7.3117, -21.0708, 7.4055]]
-        )
-        expected_boxes = torch.tensor([[0.4867, 0.1767, 0.6732], [0.6718, 0.4479, 0.3830], [0.4716, 0.1760, 0.6364]])
-
-    else:
-        expected_shape = (1, 125, 7)
-        expected_logits = torch.tensor(
-            [[-18.1430, -8.3214, 4.8274], [-18.4685, -7.1361, -4.2667], [-26.3693, -9.3429, -4.9962]]
-        )
-        expected_boxes = torch.tensor([[0.4983, 0.5595, 0.9440], [0.4916, 0.6315, 0.5954], [0.6108, 0.8637, 0.1135]])
-
-    assert outputs.logits.shape == expected_shape
-    assert torch.allclose(outputs.logits[0, :3, :3], expected_logits, atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes[0, :3, :3], expected_boxes, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        # Save model and image processor
-        logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        # Push model to HF hub
-        logger.info("Pushing model to the hub...")
-        model_name = (
-            "microsoft/table-transformer-detection"
-            if "detection" in checkpoint_url
-            else "microsoft/table-transformer-structure-recognition"
-        )
-        model.push_to_hub(model_name)
-        image_processor.push_to_hub(model_name)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth",
-        type=str,
-        choices=[
-            "https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth",
-            "https://pubtables1m.blob.core.windows.net/model/pubtables1m_structure_detr_r18.pth",
-        ],
-        help="URL of the Table Transformer checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-    convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/table_transformer/convert_table_transformer_to_hf_no_timm.py b/src/transformers/models/table_transformer/convert_table_transformer_to_hf_no_timm.py
deleted file mode 100644
index 1073d4887743..000000000000
--- a/src/transformers/models/table_transformer/convert_table_transformer_to_hf_no_timm.py
+++ /dev/null
@@ -1,434 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Table Transformer checkpoints with native (Transformers) backbone.
-
-URL: https://github.com/microsoft/table-transformer
-"""
-
-import argparse
-from pathlib import Path
-
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision.transforms import functional as F
-
-from transformers import DetrImageProcessor, ResNetConfig, TableTransformerConfig, TableTransformerForObjectDetection
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def create_rename_keys(config):
-    # here we list all keys to be renamed (original name on the left, our name on the right)
-    rename_keys = []
-
-    # stem
-    # fmt: off
-    rename_keys.append(("backbone.0.body.conv1.weight", "backbone.conv_encoder.model.embedder.embedder.convolution.weight"))
-    rename_keys.append(("backbone.0.body.bn1.weight", "backbone.conv_encoder.model.embedder.embedder.normalization.weight"))
-    rename_keys.append(("backbone.0.body.bn1.bias", "backbone.conv_encoder.model.embedder.embedder.normalization.bias"))
-    rename_keys.append(("backbone.0.body.bn1.running_mean", "backbone.conv_encoder.model.embedder.embedder.normalization.running_mean"))
-    rename_keys.append(("backbone.0.body.bn1.running_var", "backbone.conv_encoder.model.embedder.embedder.normalization.running_var"))
-    # stages
-    for stage_idx in range(len(config.backbone_config.depths)):
-        for layer_idx in range(config.backbone_config.depths[stage_idx]):
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv1.weight",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.0.convolution.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn1.weight",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.0.normalization.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn1.bias",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.0.normalization.bias",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn1.running_mean",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.0.normalization.running_mean",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn1.running_var",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.0.normalization.running_var",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv2.weight",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.1.convolution.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn2.weight",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.1.normalization.weight",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn2.bias",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.1.normalization.bias",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn2.running_mean",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.1.normalization.running_mean",
-                )
-            )
-            rename_keys.append(
-                (
-                    f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn2.running_var",
-                    f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.1.normalization.running_var",
-                )
-            )
-            # all ResNet stages except the first one have a downsample as first layer
-            if stage_idx != 0 and layer_idx == 0:
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean",
-                    )
-                )
-                rename_keys.append(
-                    (
-                        # "backbone.conv_encoder.model.encoder.stages.3.layers.0.shortcut.normalization.running_var"
-                        f"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var",
-                        f"backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var",
-                    )
-                )
-    # fmt: on
-
-    for i in range(config.encoder_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append(
-            (
-                f"transformer.encoder.layers.{i}.self_attn.out_proj.weight",
-                f"encoder.layers.{i}.self_attn.out_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (f"transformer.encoder.layers.{i}.self_attn.out_proj.bias", f"encoder.layers.{i}.self_attn.out_proj.bias")
-        )
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.weight", f"encoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.bias", f"encoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.weight", f"encoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.bias", f"encoder.layers.{i}.fc2.bias"))
-        rename_keys.append(
-            (f"transformer.encoder.layers.{i}.norm1.weight", f"encoder.layers.{i}.self_attn_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"transformer.encoder.layers.{i}.norm1.bias", f"encoder.layers.{i}.self_attn_layer_norm.bias")
-        )
-        rename_keys.append(
-            (f"transformer.encoder.layers.{i}.norm2.weight", f"encoder.layers.{i}.final_layer_norm.weight")
-        )
-        rename_keys.append((f"transformer.encoder.layers.{i}.norm2.bias", f"encoder.layers.{i}.final_layer_norm.bias"))
-        # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
-        rename_keys.append(
-            (
-                f"transformer.decoder.layers.{i}.self_attn.out_proj.weight",
-                f"decoder.layers.{i}.self_attn.out_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.self_attn.out_proj.bias", f"decoder.layers.{i}.self_attn.out_proj.bias")
-        )
-        rename_keys.append(
-            (
-                f"transformer.decoder.layers.{i}.multihead_attn.out_proj.weight",
-                f"decoder.layers.{i}.encoder_attn.out_proj.weight",
-            )
-        )
-        rename_keys.append(
-            (
-                f"transformer.decoder.layers.{i}.multihead_attn.out_proj.bias",
-                f"decoder.layers.{i}.encoder_attn.out_proj.bias",
-            )
-        )
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.weight", f"decoder.layers.{i}.fc1.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.bias", f"decoder.layers.{i}.fc1.bias"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.weight", f"decoder.layers.{i}.fc2.weight"))
-        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.bias", f"decoder.layers.{i}.fc2.bias"))
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm1.weight", f"decoder.layers.{i}.self_attn_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm1.bias", f"decoder.layers.{i}.self_attn_layer_norm.bias")
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm2.weight", f"decoder.layers.{i}.encoder_attn_layer_norm.weight")
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm2.bias", f"decoder.layers.{i}.encoder_attn_layer_norm.bias")
-        )
-        rename_keys.append(
-            (f"transformer.decoder.layers.{i}.norm3.weight", f"decoder.layers.{i}.final_layer_norm.weight")
-        )
-        rename_keys.append((f"transformer.decoder.layers.{i}.norm3.bias", f"decoder.layers.{i}.final_layer_norm.bias"))
-
-    # convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
-    rename_keys.extend(
-        [
-            ("input_proj.weight", "input_projection.weight"),
-            ("input_proj.bias", "input_projection.bias"),
-            ("query_embed.weight", "query_position_embeddings.weight"),
-            ("transformer.decoder.norm.weight", "decoder.layernorm.weight"),
-            ("transformer.decoder.norm.bias", "decoder.layernorm.bias"),
-            ("class_embed.weight", "class_labels_classifier.weight"),
-            ("class_embed.bias", "class_labels_classifier.bias"),
-            ("bbox_embed.layers.0.weight", "bbox_predictor.layers.0.weight"),
-            ("bbox_embed.layers.0.bias", "bbox_predictor.layers.0.bias"),
-            ("bbox_embed.layers.1.weight", "bbox_predictor.layers.1.weight"),
-            ("bbox_embed.layers.1.bias", "bbox_predictor.layers.1.bias"),
-            ("bbox_embed.layers.2.weight", "bbox_predictor.layers.2.weight"),
-            ("bbox_embed.layers.2.bias", "bbox_predictor.layers.2.bias"),
-            ("transformer.encoder.norm.weight", "encoder.layernorm.weight"),
-            ("transformer.encoder.norm.bias", "encoder.layernorm.bias"),
-        ]
-    )
-
-    return rename_keys
-
-
-def rename_key(state_dict, old, new):
-    val = state_dict.pop(old)
-    state_dict[new] = val
-
-
-def read_in_q_k_v(state_dict, is_panoptic=False):
-    prefix = ""
-    if is_panoptic:
-        prefix = "detr."
-
-    # first: transformer encoder
-    for i in range(6):
-        # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"encoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"encoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"encoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-    # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
-    for i in range(6):
-        # read in weights + bias of input projection layer of self-attention
-        in_proj_weight = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:256, :]
-        state_dict[f"decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:256]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[256:512, :]
-        state_dict[f"decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[256:512]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-256:, :]
-        state_dict[f"decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-256:]
-        # read in weights + bias of input projection layer of cross-attention
-        in_proj_weight_cross_attn = state_dict.pop(
-            f"{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight"
-        )
-        in_proj_bias_cross_attn = state_dict.pop(f"{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) of cross-attention to the state dict
-        state_dict[f"decoder.layers.{i}.encoder_attn.q_proj.weight"] = in_proj_weight_cross_attn[:256, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.q_proj.bias"] = in_proj_bias_cross_attn[:256]
-        state_dict[f"decoder.layers.{i}.encoder_attn.k_proj.weight"] = in_proj_weight_cross_attn[256:512, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.k_proj.bias"] = in_proj_bias_cross_attn[256:512]
-        state_dict[f"decoder.layers.{i}.encoder_attn.v_proj.weight"] = in_proj_weight_cross_attn[-256:, :]
-        state_dict[f"decoder.layers.{i}.encoder_attn.v_proj.bias"] = in_proj_bias_cross_attn[-256:]
-
-
-def resize(image, checkpoint_url):
-    width, height = image.size
-    current_max_size = max(width, height)
-    target_max_size = 800 if "detection" in checkpoint_url else 1000
-    scale = target_max_size / current_max_size
-    resized_image = image.resize((int(round(scale * width)), int(round(scale * height))))
-
-    return resized_image
-
-
-def normalize(image):
-    image = F.to_tensor(image)
-    image = F.normalize(image, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-    return image
-
-
-@torch.no_grad()
-def convert_table_transformer_checkpoint(checkpoint_url, pytorch_dump_folder_path, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our DETR structure.
-    """
-
-    logger.info("Converting model...")
-
-    # create HuggingFace model and load state dict
-    backbone_config = ResNetConfig.from_pretrained(
-        "microsoft/resnet-18", out_features=["stage1", "stage2", "stage3", "stage4"]
-    )
-
-    config = TableTransformerConfig(
-        backbone_config=backbone_config,
-        use_timm_backbone=False,
-        mask_loss_coefficient=1,
-        dice_loss_coefficient=1,
-        ce_loss_coefficient=1,
-        bbox_loss_coefficient=5,
-        giou_loss_coefficient=2,
-        eos_coefficient=0.4,
-        class_cost=1,
-        bbox_cost=5,
-        giou_cost=2,
-    )
-
-    # load original state dict
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
-
-    # rename keys
-    for src, dest in create_rename_keys(config):
-        rename_key(state_dict, src, dest)
-    # query, key and value matrices need special treatment
-    read_in_q_k_v(state_dict)
-    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
-    prefix = "model."
-    for key in state_dict.copy().keys():
-        if not key.startswith("class_labels_classifier") and not key.startswith("bbox_predictor"):
-            val = state_dict.pop(key)
-            state_dict[prefix + key] = val
-
-    if "detection" in checkpoint_url:
-        config.num_queries = 15
-        config.num_labels = 2
-        id2label = {0: "table", 1: "table rotated"}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-    else:
-        config.num_queries = 125
-        config.num_labels = 6
-        id2label = {
-            0: "table",
-            1: "table column",
-            2: "table row",
-            3: "table column header",
-            4: "table projected row header",
-            5: "table spanning cell",
-        }
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    image_processor = DetrImageProcessor(format="coco_detection", size={"longest_edge": 800})
-    model = TableTransformerForObjectDetection(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # verify our conversion
-    filename = "example_pdf.png" if "detection" in checkpoint_url else "example_table.png"
-    file_path = hf_hub_download(repo_id="nielsr/example-pdf", repo_type="dataset", filename=filename)
-    image = Image.open(file_path).convert("RGB")
-    pixel_values = normalize(resize(image, checkpoint_url)).unsqueeze(0)
-
-    outputs = model(pixel_values)
-
-    if "detection" in checkpoint_url:
-        expected_shape = (1, 15, 3)
-        expected_logits = torch.tensor(
-            [[-6.7897, -16.9985, 6.7937], [-8.0186, -22.2192, 6.9677], [-7.3117, -21.0708, 7.4055]]
-        )
-        expected_boxes = torch.tensor([[0.4867, 0.1767, 0.6732], [0.6718, 0.4479, 0.3830], [0.4716, 0.1760, 0.6364]])
-
-    else:
-        expected_shape = (1, 125, 7)
-        expected_logits = torch.tensor(
-            [[-18.1430, -8.3214, 4.8274], [-18.4685, -7.1361, -4.2667], [-26.3693, -9.3429, -4.9962]]
-        )
-        expected_boxes = torch.tensor([[0.4983, 0.5595, 0.9440], [0.4916, 0.6315, 0.5954], [0.6108, 0.8637, 0.1135]])
-
-    assert outputs.logits.shape == expected_shape
-    assert torch.allclose(outputs.logits[0, :3, :3], expected_logits, atol=1e-4)
-    assert torch.allclose(outputs.pred_boxes[0, :3, :3], expected_boxes, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        # Save model and image processor
-        logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        # Push model to HF hub
-        logger.info("Pushing model to the hub...")
-        model_name = (
-            "microsoft/table-transformer-detection"
-            if "detection" in checkpoint_url
-            else "microsoft/table-transformer-structure-recognition"
-        )
-        model.push_to_hub(model_name, revision="no_timm")
-        image_processor.push_to_hub(model_name, revision="no_timm")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth",
-        type=str,
-        choices=[
-            "https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth",
-            "https://pubtables1m.blob.core.windows.net/model/pubtables1m_structure_detr_r18.pth",
-        ],
-        help="URL of the Table Transformer checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    args = parser.parse_args()
-    convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/tapas/convert_tapas_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/tapas/convert_tapas_original_tf_checkpoint_to_pytorch.py
deleted file mode 100644
index 34bf77cccd6b..000000000000
--- a/src/transformers/models/tapas/convert_tapas_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,137 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert TAPAS checkpoint."""
-
-import argparse
-
-from transformers import (
-    TapasConfig,
-    TapasForMaskedLM,
-    TapasForQuestionAnswering,
-    TapasForSequenceClassification,
-    TapasModel,
-    TapasTokenizer,
-    load_tf_weights_in_tapas,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_tf_checkpoint_to_pytorch(
-    task, reset_position_index_per_cell, tf_checkpoint_path, tapas_config_file, pytorch_dump_path
-):
-    # Initialise PyTorch model.
-    # If you want to convert a checkpoint that uses absolute position embeddings, make sure to set reset_position_index_per_cell of
-    # TapasConfig to False.
-
-    # initialize configuration from json file
-    config = TapasConfig.from_json_file(tapas_config_file)
-    # set absolute/relative position embeddings parameter
-    config.reset_position_index_per_cell = reset_position_index_per_cell
-
-    # set remaining parameters of TapasConfig as well as the model based on the task
-    if task == "SQA":
-        model = TapasForQuestionAnswering(config=config)
-    elif task == "WTQ":
-        # run_task_main.py hparams
-        config.num_aggregation_labels = 4
-        config.use_answer_as_supervision = True
-        # hparam_utils.py hparams
-        config.answer_loss_cutoff = 0.664694
-        config.cell_selection_preference = 0.207951
-        config.huber_loss_delta = 0.121194
-        config.init_cell_selection_weights_to_zero = True
-        config.select_one_column = True
-        config.allow_empty_column_selection = False
-        config.temperature = 0.0352513
-
-        model = TapasForQuestionAnswering(config=config)
-    elif task == "WIKISQL_SUPERVISED":
-        # run_task_main.py hparams
-        config.num_aggregation_labels = 4
-        config.use_answer_as_supervision = False
-        # hparam_utils.py hparams
-        config.answer_loss_cutoff = 36.4519
-        config.cell_selection_preference = 0.903421
-        config.huber_loss_delta = 222.088
-        config.init_cell_selection_weights_to_zero = True
-        config.select_one_column = True
-        config.allow_empty_column_selection = True
-        config.temperature = 0.763141
-
-        model = TapasForQuestionAnswering(config=config)
-    elif task == "TABFACT":
-        model = TapasForSequenceClassification(config=config)
-    elif task == "MLM":
-        model = TapasForMaskedLM(config=config)
-    elif task == "INTERMEDIATE_PRETRAINING":
-        model = TapasModel(config=config)
-    else:
-        raise ValueError(f"Task {task} not supported.")
-
-    print(f"Building PyTorch model from configuration: {config}")
-    # Load weights from tf checkpoint
-    load_tf_weights_in_tapas(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model (weights and configuration)
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-    # Save tokenizer files
-    print(f"Save tokenizer files to {pytorch_dump_path}")
-    tokenizer = TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + "vocab.txt", model_max_length=512)
-    tokenizer.save_pretrained(pytorch_dump_path)
-
-    print("Used relative position embeddings:", model.config.reset_position_index_per_cell)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--task", default="SQA", type=str, help="Model task for which to convert a checkpoint. Defaults to SQA."
-    )
-    parser.add_argument(
-        "--reset_position_index_per_cell",
-        default=False,
-        action="store_true",
-        help="Whether to use relative position embeddings or not. Defaults to True.",
-    )
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--tapas_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained TAPAS model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tf_checkpoint_to_pytorch(
-        args.task,
-        args.reset_position_index_per_cell,
-        args.tf_checkpoint_path,
-        args.tapas_config_file,
-        args.pytorch_dump_path,
-    )
diff --git a/src/transformers/models/textnet/convert_textnet_to_hf.py b/src/transformers/models/textnet/convert_textnet_to_hf.py
deleted file mode 100644
index a8a004d18a35..000000000000
--- a/src/transformers/models/textnet/convert_textnet_to_hf.py
+++ /dev/null
@@ -1,208 +0,0 @@
-# coding=utf-8
-# Copyright 2024 the Fast authors and The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import json
-import logging
-import re
-from collections import OrderedDict
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import TextNetBackbone, TextNetConfig, TextNetImageProcessor
-
-
-tiny_config_url = "https://raw.githubusercontent.com/czczup/FAST/main/config/fast/nas-configs/fast_tiny.config"
-small_config_url = "https://raw.githubusercontent.com/czczup/FAST/main/config/fast/nas-configs/fast_small.config"
-base_config_url = "https://raw.githubusercontent.com/czczup/FAST/main/config/fast/nas-configs/fast_base.config"
-
-rename_key_mappings = {
-    "module.backbone": "textnet",
-    "first_conv": "stem",
-    "bn": "batch_norm",
-    "ver": "vertical",
-    "hor": "horizontal",
-}
-
-
-def prepare_config(size_config_url, size):
-    config_dict = json.loads(requests.get(size_config_url).text)
-
-    backbone_config = {}
-    for stage_ix in range(1, 5):
-        stage_config = config_dict[f"stage{stage_ix}"]
-
-        merged_dict = {}
-
-        # Iterate through the list of dictionaries
-        for layer in stage_config:
-            for key, value in layer.items():
-                if key != "name":
-                    # Check if the key is already in the merged_dict
-                    if key in merged_dict:
-                        merged_dict[key].append(value)
-                    else:
-                        # If the key is not in merged_dict, create a new list with the value
-                        merged_dict[key] = [value]
-        backbone_config[f"stage{stage_ix}"] = merged_dict
-
-    neck_in_channels = []
-    neck_out_channels = []
-    neck_kernel_size = []
-    neck_stride = []
-    neck_dilation = []
-    neck_groups = []
-
-    for i in range(1, 5):
-        layer_key = f"reduce_layer{i}"
-        layer_dict = config_dict["neck"].get(layer_key)
-
-        if layer_dict:
-            # Append values to the corresponding lists
-            neck_in_channels.append(layer_dict["in_channels"])
-            neck_out_channels.append(layer_dict["out_channels"])
-            neck_kernel_size.append(layer_dict["kernel_size"])
-            neck_stride.append(layer_dict["stride"])
-            neck_dilation.append(layer_dict["dilation"])
-            neck_groups.append(layer_dict["groups"])
-
-    textnet_config = TextNetConfig(
-        stem_kernel_size=config_dict["first_conv"]["kernel_size"],
-        stem_stride=config_dict["first_conv"]["stride"],
-        stem_num_channels=config_dict["first_conv"]["in_channels"],
-        stem_out_channels=config_dict["first_conv"]["out_channels"],
-        stem_act_func=config_dict["first_conv"]["act_func"],
-        conv_layer_kernel_sizes=[
-            backbone_config["stage1"]["kernel_size"],
-            backbone_config["stage2"]["kernel_size"],
-            backbone_config["stage3"]["kernel_size"],
-            backbone_config["stage4"]["kernel_size"],
-        ],
-        conv_layer_strides=[
-            backbone_config["stage1"]["stride"],
-            backbone_config["stage2"]["stride"],
-            backbone_config["stage3"]["stride"],
-            backbone_config["stage4"]["stride"],
-        ],
-        hidden_sizes=[
-            config_dict["first_conv"]["out_channels"],
-            backbone_config["stage1"]["out_channels"][-1],
-            backbone_config["stage2"]["out_channels"][-1],
-            backbone_config["stage3"]["out_channels"][-1],
-            backbone_config["stage4"]["out_channels"][-1],
-        ],
-        out_features=["stage1", "stage2", "stage3", "stage4"],
-        out_indices=[1, 2, 3, 4],
-    )
-
-    return textnet_config
-
-
-def convert_textnet_checkpoint(checkpoint_url, checkpoint_config_filename, pytorch_dump_folder_path):
-    config_filepath = hf_hub_download(repo_id="Raghavan/fast_model_config_files", filename="fast_model_configs.json")
-
-    with open(config_filepath) as f:
-        content = json.loads(f.read())
-
-    size = content[checkpoint_config_filename]["short_size"]
-
-    if "tiny" in content[checkpoint_config_filename]["config"]:
-        config = prepare_config(tiny_config_url, size)
-        expected_slice_backbone = torch.tensor(
-            [0.0000, 0.0000, 0.0000, 0.0000, 0.5300, 0.0000, 0.0000, 0.0000, 0.0000, 1.1221]
-        )
-    elif "small" in content[checkpoint_config_filename]["config"]:
-        config = prepare_config(small_config_url, size)
-        expected_slice_backbone = torch.tensor(
-            [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.1394]
-        )
-    else:
-        config = prepare_config(base_config_url, size)
-        expected_slice_backbone = torch.tensor(
-            [0.9210, 0.6099, 0.0000, 0.0000, 0.0000, 0.0000, 3.2207, 2.6602, 1.8925, 0.0000]
-        )
-
-    model = TextNetBackbone(config)
-    textnet_image_processor = TextNetImageProcessor(size={"shortest_edge": size})
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu", check_hash=True)["ema"]
-    state_dict_changed = OrderedDict()
-    for key in state_dict:
-        if "backbone" in key:
-            val = state_dict[key]
-            new_key = key
-            for search, replacement in rename_key_mappings.items():
-                if search in new_key:
-                    new_key = new_key.replace(search, replacement)
-
-            pattern = r"textnet\.stage(\d)"
-
-            def adjust_stage(match):
-                stage_number = int(match.group(1)) - 1
-                return f"textnet.encoder.stages.{stage_number}.stage"
-
-            # Using regex to find and replace the pattern in the string
-            new_key = re.sub(pattern, adjust_stage, new_key)
-            state_dict_changed[new_key] = val
-    model.load_state_dict(state_dict_changed)
-    model.eval()
-
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-
-    original_pixel_values = torch.tensor(
-        [0.1939, 0.3481, 0.4166, 0.3309, 0.4508, 0.4679, 0.4851, 0.4851, 0.3309, 0.4337]
-    )
-    pixel_values = textnet_image_processor(image, return_tensors="pt").pixel_values
-
-    assert torch.allclose(original_pixel_values, pixel_values[0][0][3][:10], atol=1e-4)
-
-    with torch.no_grad():
-        output = model(pixel_values)
-
-    assert torch.allclose(output["feature_maps"][-1][0][10][12][:10].detach(), expected_slice_backbone, atol=1e-3)
-
-    model.save_pretrained(pytorch_dump_folder_path)
-    textnet_image_processor.save_pretrained(pytorch_dump_folder_path)
-    logging.info("The converted weights are saved here : " + pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://github.com/czczup/FAST/releases/download/release/fast_base_ic17mlt_640.pth",
-        type=str,
-        help="URL to the original PyTorch checkpoint (.pth file).",
-    )
-    parser.add_argument(
-        "--checkpoint_config_filename",
-        default="fast_base_ic17mlt_640.py",
-        type=str,
-        help="URL to the original PyTorch checkpoint (.pth file).",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    args = parser.parse_args()
-
-    convert_textnet_checkpoint(
-        args.checkpoint_url,
-        args.checkpoint_config_filename,
-        args.pytorch_dump_folder_path,
-    )
diff --git a/src/transformers/models/timesformer/convert_timesformer_to_pytorch.py b/src/transformers/models/timesformer/convert_timesformer_to_pytorch.py
deleted file mode 100644
index ce4d13421ffd..000000000000
--- a/src/transformers/models/timesformer/convert_timesformer_to_pytorch.py
+++ /dev/null
@@ -1,253 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert TimeSformer checkpoints from the original repository: https://github.com/MCG-NJU/TimeSformer"""
-
-import argparse
-import json
-
-import gdown
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor
-
-
-def get_timesformer_config(model_name):
-    config = TimesformerConfig()
-
-    if "large" in model_name:
-        config.num_frames = 96
-
-    if "hr" in model_name:
-        config.num_frames = 16
-        config.image_size = 448
-
-    repo_id = "huggingface/label-files"
-    if "k400" in model_name:
-        config.num_labels = 400
-        filename = "kinetics400-id2label.json"
-    elif "k600" in model_name:
-        config.num_labels = 600
-        filename = "kinetics600-id2label.json"
-    elif "ssv2" in model_name:
-        config.num_labels = 174
-        filename = "something-something-v2-id2label.json"
-    else:
-        raise ValueError("Model name should either contain 'k400', 'k600' or 'ssv2'.")
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-def rename_key(name):
-    if "encoder." in name:
-        name = name.replace("encoder.", "")
-    if "cls_token" in name:
-        name = name.replace("cls_token", "timesformer.embeddings.cls_token")
-    if "pos_embed" in name:
-        name = name.replace("pos_embed", "timesformer.embeddings.position_embeddings")
-    if "time_embed" in name:
-        name = name.replace("time_embed", "timesformer.embeddings.time_embeddings")
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "timesformer.embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "timesformer.embeddings.norm")
-    if "blocks" in name:
-        name = name.replace("blocks", "timesformer.encoder.layer")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name and "bias" not in name and "temporal" not in name:
-        name = name.replace("attn", "attention.self")
-    if "attn" in name and "temporal" not in name:
-        name = name.replace("attn", "attention.attention")
-    if "temporal_norm1" in name:
-        name = name.replace("temporal_norm1", "temporal_layernorm")
-    if "temporal_attn.proj" in name:
-        name = name.replace("temporal_attn", "temporal_attention.output.dense")
-    if "temporal_fc" in name:
-        name = name.replace("temporal_fc", "temporal_dense")
-    if "norm1" in name and "temporal" not in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "norm.weight" in name and "fc" not in name and "temporal" not in name:
-        name = name.replace("norm.weight", "timesformer.layernorm.weight")
-    if "norm.bias" in name and "fc" not in name and "temporal" not in name:
-        name = name.replace("norm.bias", "timesformer.layernorm.bias")
-    if "head" in name:
-        name = name.replace("head", "classifier")
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, config):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if key.startswith("model."):
-            key = key.replace("model.", "")
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[1])
-            prefix = "timesformer.encoder.layer."
-            if "temporal" in key:
-                postfix = ".temporal_attention.attention.qkv."
-            else:
-                postfix = ".attention.attention.qkv."
-            if "weight" in key:
-                orig_state_dict[f"{prefix}{layer_num}{postfix}weight"] = val
-            else:
-                orig_state_dict[f"{prefix}{layer_num}{postfix}bias"] = val
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-# We will verify our results on a video of eating spaghetti
-# Frame indices used: [164 168 172 176 181 185 189 193 198 202 206 210 215 219 223 227]
-def prepare_video():
-    file = hf_hub_download(
-        repo_id="hf-internal-testing/spaghetti-video", filename="eating_spaghetti.npy", repo_type="dataset"
-    )
-    video = np.load(file)
-    return list(video)
-
-
-def convert_timesformer_checkpoint(checkpoint_url, pytorch_dump_folder_path, model_name, push_to_hub):
-    config = get_timesformer_config(model_name)
-
-    model = TimesformerForVideoClassification(config)
-
-    # download original checkpoint, hosted on Google Drive
-    output = "pytorch_model.bin"
-    gdown.cached_download(checkpoint_url, output, quiet=False)
-    files = torch.load(output, map_location="cpu")
-    if "model" in files:
-        state_dict = files["model"]
-    elif "module" in files:
-        state_dict = files["module"]
-    else:
-        state_dict = files["model_state"]
-    new_state_dict = convert_state_dict(state_dict, config)
-
-    model.load_state_dict(new_state_dict)
-    model.eval()
-
-    # verify model on basic input
-    image_processor = VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5], image_std=[0.5, 0.5, 0.5])
-    video = prepare_video()
-    inputs = image_processor(video[:8], return_tensors="pt")
-
-    outputs = model(**inputs)
-    logits = outputs.logits
-
-    model_names = [
-        # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
-        "timesformer-base-finetuned-k400",
-        "timesformer-large-finetuned-k400",
-        "timesformer-hr-finetuned-k400",
-        # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
-        "timesformer-base-finetuned-k600",
-        "timesformer-large-finetuned-k600",
-        "timesformer-hr-finetuned-k600",
-        # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
-        "timesformer-base-finetuned-ssv2",
-        "timesformer-large-finetuned-ssv2",
-        "timesformer-hr-finetuned-ssv2",
-    ]
-
-    # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
-    if model_name == "timesformer-base-finetuned-k400":
-        expected_shape = torch.Size([1, 400])
-        expected_slice = torch.tensor([-0.3016, -0.7713, -0.4205])
-    elif model_name == "timesformer-base-finetuned-k600":
-        expected_shape = torch.Size([1, 600])
-        expected_slice = torch.tensor([-0.7267, -0.7466, 3.2404])
-    elif model_name == "timesformer-base-finetuned-ssv2":
-        expected_shape = torch.Size([1, 174])
-        expected_slice = torch.tensor([-0.9059, 0.6433, -3.1457])
-    elif model_name == "timesformer-large-finetuned-k400":
-        expected_shape = torch.Size([1, 400])
-        expected_slice = torch.tensor([0, 0, 0])
-    elif model_name == "timesformer-large-finetuned-k600":
-        expected_shape = torch.Size([1, 600])
-        expected_slice = torch.tensor([0, 0, 0])
-    elif model_name == "timesformer-large-finetuned-ssv2":
-        expected_shape = torch.Size([1, 174])
-        expected_slice = torch.tensor([0, 0, 0])
-    elif model_name == "timesformer-hr-finetuned-k400":
-        expected_shape = torch.Size([1, 400])
-        expected_slice = torch.tensor([-0.9617, -3.7311, -3.7708])
-    elif model_name == "timesformer-hr-finetuned-k600":
-        expected_shape = torch.Size([1, 600])
-        expected_slice = torch.tensor([2.5273, 0.7127, 1.8848])
-    elif model_name == "timesformer-hr-finetuned-ssv2":
-        expected_shape = torch.Size([1, 174])
-        expected_slice = torch.tensor([-3.6756, -0.7513, 0.7180])
-    else:
-        raise ValueError(f"Model name not supported. Should be one of {model_names}")
-
-    # verify logits
-    assert logits.shape == expected_shape
-    assert torch.allclose(logits[0, :3], expected_slice, atol=1e-4)
-    print("Logits ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and image processor to {pytorch_dump_folder_path}")
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-        model.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing to the hub...")
-        model.push_to_hub(f"fcakyon/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download",
-        type=str,
-        help=(
-            "URL of the original PyTorch checkpoint (on Google Drive) you'd like to convert. Should be a direct"
-            " download link."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--model_name", default="timesformer-base-finetuned-k400", type=str, help="Name of the model.")
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_timesformer_checkpoint(
-        args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
-    )
diff --git a/src/transformers/models/trocr/convert_trocr_unilm_to_pytorch.py b/src/transformers/models/trocr/convert_trocr_unilm_to_pytorch.py
deleted file mode 100644
index a787932b7694..000000000000
--- a/src/transformers/models/trocr/convert_trocr_unilm_to_pytorch.py
+++ /dev/null
@@ -1,237 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert TrOCR checkpoints from the unilm repository."""
-
-import argparse
-from pathlib import Path
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import (
-    RobertaTokenizer,
-    TrOCRConfig,
-    TrOCRForCausalLM,
-    TrOCRProcessor,
-    VisionEncoderDecoderModel,
-    ViTConfig,
-    ViTImageProcessor,
-    ViTModel,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(encoder_config, decoder_config):
-    rename_keys = []
-    for i in range(encoder_config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append(
-            (f"encoder.deit.blocks.{i}.norm1.weight", f"encoder.encoder.layer.{i}.layernorm_before.weight")
-        )
-        rename_keys.append((f"encoder.deit.blocks.{i}.norm1.bias", f"encoder.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append(
-            (f"encoder.deit.blocks.{i}.attn.proj.weight", f"encoder.encoder.layer.{i}.attention.output.dense.weight")
-        )
-        rename_keys.append(
-            (f"encoder.deit.blocks.{i}.attn.proj.bias", f"encoder.encoder.layer.{i}.attention.output.dense.bias")
-        )
-        rename_keys.append(
-            (f"encoder.deit.blocks.{i}.norm2.weight", f"encoder.encoder.layer.{i}.layernorm_after.weight")
-        )
-        rename_keys.append((f"encoder.deit.blocks.{i}.norm2.bias", f"encoder.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append(
-            (f"encoder.deit.blocks.{i}.mlp.fc1.weight", f"encoder.encoder.layer.{i}.intermediate.dense.weight")
-        )
-        rename_keys.append(
-            (f"encoder.deit.blocks.{i}.mlp.fc1.bias", f"encoder.encoder.layer.{i}.intermediate.dense.bias")
-        )
-        rename_keys.append(
-            (f"encoder.deit.blocks.{i}.mlp.fc2.weight", f"encoder.encoder.layer.{i}.output.dense.weight")
-        )
-        rename_keys.append((f"encoder.deit.blocks.{i}.mlp.fc2.bias", f"encoder.encoder.layer.{i}.output.dense.bias"))
-
-    # cls token, position embeddings and patch embeddings of encoder
-    rename_keys.extend(
-        [
-            ("encoder.deit.cls_token", "encoder.embeddings.cls_token"),
-            ("encoder.deit.pos_embed", "encoder.embeddings.position_embeddings"),
-            ("encoder.deit.patch_embed.proj.weight", "encoder.embeddings.patch_embeddings.projection.weight"),
-            ("encoder.deit.patch_embed.proj.bias", "encoder.embeddings.patch_embeddings.projection.bias"),
-            ("encoder.deit.norm.weight", "encoder.layernorm.weight"),
-            ("encoder.deit.norm.bias", "encoder.layernorm.bias"),
-        ]
-    )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, encoder_config):
-    for i in range(encoder_config.num_hidden_layers):
-        # queries, keys and values (only weights, no biases)
-        in_proj_weight = state_dict.pop(f"encoder.deit.blocks.{i}.attn.qkv.weight")
-
-        state_dict[f"encoder.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : encoder_config.hidden_size, :
-        ]
-        state_dict[f"encoder.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            encoder_config.hidden_size : encoder_config.hidden_size * 2, :
-        ]
-        state_dict[f"encoder.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -encoder_config.hidden_size :, :
-        ]
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of the IAM Handwriting Database
-def prepare_img(checkpoint_url):
-    if "handwritten" in checkpoint_url:
-        url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg"  # industry
-        # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-12.jpg" # have
-        # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-10.jpg" # let
-        # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"  #
-        # url = "https://fki.tic.heia-fr.ch/static/img/a01-122.jpg"
-    elif "printed" in checkpoint_url or "stage1" in checkpoint_url:
-        url = "https://www.researchgate.net/profile/Dinh-Sang/publication/338099565/figure/fig8/AS:840413229350922@1577381536857/An-receipt-example-in-the-SROIE-2019-dataset_Q640.jpg"
-    im = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-    return im
-
-
-@torch.no_grad()
-def convert_tr_ocr_checkpoint(checkpoint_url, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our VisionEncoderDecoderModel structure.
-    """
-    # define encoder and decoder configs based on checkpoint_url
-    encoder_config = ViTConfig(image_size=384, qkv_bias=False)
-    decoder_config = TrOCRConfig()
-
-    # size of the architecture
-    if "base" in checkpoint_url:
-        decoder_config.encoder_hidden_size = 768
-    elif "large" in checkpoint_url:
-        # use ViT-large encoder
-        encoder_config.hidden_size = 1024
-        encoder_config.intermediate_size = 4096
-        encoder_config.num_hidden_layers = 24
-        encoder_config.num_attention_heads = 16
-        decoder_config.encoder_hidden_size = 1024
-    else:
-        raise ValueError("Should either find 'base' or 'large' in checkpoint URL")
-
-    # the large-printed + stage1 checkpoints uses sinusoidal position embeddings, no layernorm afterwards
-    if "large-printed" in checkpoint_url or "stage1" in checkpoint_url:
-        decoder_config.tie_word_embeddings = False
-        decoder_config.activation_function = "relu"
-        decoder_config.max_position_embeddings = 1024
-        decoder_config.scale_embedding = True
-        decoder_config.use_learned_position_embeddings = False
-        decoder_config.layernorm_embedding = False
-
-    # load HuggingFace model
-    encoder = ViTModel(encoder_config, add_pooling_layer=False)
-    decoder = TrOCRForCausalLM(decoder_config)
-    model = VisionEncoderDecoderModel(encoder=encoder, decoder=decoder)
-    model.eval()
-
-    # load state_dict of original model, rename some keys
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu", check_hash=True)["model"]
-
-    rename_keys = create_rename_keys(encoder_config, decoder_config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, encoder_config)
-
-    # remove parameters we don't need
-    del state_dict["encoder.deit.head.weight"]
-    del state_dict["encoder.deit.head.bias"]
-    del state_dict["decoder.version"]
-
-    # add prefix to decoder keys
-    for key, val in state_dict.copy().items():
-        val = state_dict.pop(key)
-        if key.startswith("decoder") and "output_projection" not in key:
-            state_dict["decoder.model." + key] = val
-        else:
-            state_dict[key] = val
-
-    # load state dict
-    model.load_state_dict(state_dict)
-
-    # Check outputs on an image
-    image_processor = ViTImageProcessor(size=encoder_config.image_size)
-    tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-large")
-    processor = TrOCRProcessor(image_processor, tokenizer)
-
-    pixel_values = processor(images=prepare_img(checkpoint_url), return_tensors="pt").pixel_values
-
-    # verify logits
-    decoder_input_ids = torch.tensor([[model.config.decoder.decoder_start_token_id]])
-    outputs = model(pixel_values=pixel_values, decoder_input_ids=decoder_input_ids)
-    logits = outputs.logits
-
-    expected_shape = torch.Size([1, 1, 50265])
-    if "trocr-base-handwritten" in checkpoint_url:
-        expected_slice = torch.tensor(
-            [-1.4502, -4.6683, -0.5347, -2.9291, 9.1435, -3.0571, 8.9764, 1.7560, 8.7358, -1.5311]
-        )
-    elif "trocr-large-handwritten" in checkpoint_url:
-        expected_slice = torch.tensor(
-            [-2.6437, -1.3129, -2.2596, -5.3455, 6.3539, 1.7604, 5.4991, 1.4702, 5.6113, 2.0170]
-        )
-    elif "trocr-base-printed" in checkpoint_url:
-        expected_slice = torch.tensor(
-            [-5.6816, -5.8388, 1.1398, -6.9034, 6.8505, -2.4393, 1.2284, -1.0232, -1.9661, -3.9210]
-        )
-    elif "trocr-large-printed" in checkpoint_url:
-        expected_slice = torch.tensor(
-            [-6.0162, -7.0959, 4.4155, -5.1063, 7.0468, -3.1631, 2.6466, -0.3081, -0.8106, -1.7535]
-        )
-
-    if "stage1" not in checkpoint_url:
-        assert logits.shape == expected_shape, "Shape of logits not as expected"
-        assert torch.allclose(logits[0, 0, :10], expected_slice, atol=1e-3), "First elements of logits not as expected"
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving processor to {pytorch_dump_folder_path}")
-    processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://layoutlm.blob.core.windows.net/trocr/model_zoo/fairseq/trocr-base-handwritten.pt",
-        type=str,
-        help="URL to the original PyTorch checkpoint (.pth file).",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_tr_ocr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/udop/convert_udop_to_hf.py b/src/transformers/models/udop/convert_udop_to_hf.py
deleted file mode 100644
index f2d54b8ca542..000000000000
--- a/src/transformers/models/udop/convert_udop_to_hf.py
+++ /dev/null
@@ -1,224 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert UDOP checkpoints from the original repository. URL: https://github.com/microsoft/i-Code/tree/main/i-Code-Doc"""
-
-import argparse
-
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-from torchvision import transforms as T
-
-from transformers import (
-    LayoutLMv3ImageProcessor,
-    UdopConfig,
-    UdopForConditionalGeneration,
-    UdopProcessor,
-    UdopTokenizer,
-)
-from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
-
-
-def original_transform(image, image_size=224):
-    transform = T.Compose(
-        [
-            T.Resize([image_size, image_size]),
-            T.ToTensor(),
-            T.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD),
-        ]
-    )
-
-    image = transform(image)
-    return image
-
-
-def get_image():
-    filepath = hf_hub_download(
-        repo_id="hf-internal-testing/fixtures_docvqa", filename="document_2.png", repo_type="dataset"
-    )
-    image = Image.open(filepath).convert("RGB")
-
-    return image
-
-
-def prepare_dummy_inputs(tokenizer, image_processor):
-    prompt = "Question answering. What is the name of the company?"
-    prompt = "Question answering. In which year is the report made?"
-    prompt_ids = tokenizer.encode(prompt, add_special_tokens=False)
-
-    image = get_image()
-    # words, boxes = apply_tesseract(image, lang=None)
-    # fmt: off
-    words = ['7', 'ITC', 'Limited', 'REPORT', 'AND', 'ACCOUNTS', '2013', 'ITC’s', 'Brands:', 'An', 'Asset', 'for', 'the', 'Nation', 'The', 'consumer', 'needs', 'and', 'aspirations', 'they', 'fulfil,', 'the', 'benefit', 'they', 'generate', 'for', 'millions', 'across', 'ITC’s', 'value', 'chains,', 'the', 'future-ready', 'capabilities', 'that', 'support', 'them,', 'and', 'the', 'value', 'that', 'they', 'create', 'for', 'the', 'country,', 'have', 'made', 'ITC’s', 'brands', 'national', 'assets,', 'adding', 'to', 'India’s', 'competitiveness.', 'It', 'is', 'ITC’s', 'aspiration', 'to', 'be', 'the', 'No', '1', 'FMCG', 'player', 'in', 'the', 'country,', 'driven', 'by', 'its', 'new', 'FMCG', 'businesses.', 'A', 'recent', 'Nielsen', 'report', 'has', 'highlighted', 'that', "ITC's", 'new', 'FMCG', 'businesses', 'are', 'the', 'fastest', 'growing', 'among', 'the', 'top', 'consumer', 'goods', 'companies', 'operating', 'in', 'India.', 'ITC', 'takes', 'justifiable', 'pride', 'that,', 'along', 'with', 'generating', 'economic', 'value,', 'these', 'celebrated', 'Indian', 'brands', 'also', 'drive', 'the', 'creation', 'of', 'larger', 'societal', 'capital', 'through', 'the', 'virtuous', 'cycle', 'of', 'sustainable', 'and', 'inclusive', 'growth.', 'DI', 'WILLS', '*', ';', 'LOVE', 'DELIGHTFULLY', 'SOFT', 'SKIN?', 'aia', 'Ans', 'Source:', 'https://www.industrydocuments.ucsf.edu/docs/snbx0223']
-    boxes = [[0, 45, 67, 80], [72, 56, 109, 67], [116, 56, 189, 67], [198, 59, 253, 66], [257, 59, 285, 66], [289, 59, 365, 66], [372, 59, 407, 66], [74, 136, 161, 158], [175, 137, 306, 158], [318, 137, 363, 158], [374, 137, 472, 158], [483, 136, 529, 158], [540, 137, 593, 158], [608, 137, 717, 158], [73, 194, 100, 203], [106, 196, 177, 203], [183, 194, 227, 203], [233, 194, 259, 203], [265, 194, 344, 205], [74, 211, 104, 222], [109, 210, 141, 221], [147, 211, 169, 220], [175, 210, 223, 220], [229, 211, 259, 222], [265, 211, 329, 222], [334, 210, 352, 220], [74, 227, 127, 236], [133, 229, 180, 236], [187, 227, 221, 236], [226, 227, 264, 236], [270, 227, 320, 237], [327, 227, 349, 236], [74, 243, 161, 254], [166, 243, 249, 254], [254, 243, 281, 252], [286, 244, 342, 254], [74, 260, 112, 270], [119, 260, 145, 269], [151, 260, 174, 269], [179, 260, 217, 269], [222, 260, 249, 269], [254, 260, 285, 271], [290, 260, 335, 269], [340, 259, 359, 269], [74, 276, 95, 284], [101, 276, 156, 287], [164, 276, 198, 284], [203, 276, 244, 284], [251, 275, 285, 284], [291, 276, 340, 284], [74, 292, 129, 301], [135, 292, 185, 302], [192, 292, 242, 303], [248, 292, 261, 301], [267, 292, 312, 301], [74, 308, 195, 319], [75, 335, 82, 344], [88, 335, 98, 344], [105, 335, 138, 344], [144, 335, 214, 346], [220, 336, 233, 344], [239, 335, 256, 344], [262, 335, 283, 344], [290, 335, 309, 344], [316, 335, 320, 344], [74, 351, 119, 360], [126, 352, 170, 362], [176, 352, 186, 360], [192, 352, 214, 360], [220, 352, 276, 362], [282, 352, 326, 360], [333, 352, 349, 362], [74, 368, 89, 377], [95, 370, 124, 377], [129, 367, 175, 377], [181, 368, 266, 377], [272, 368, 283, 376], [289, 368, 333, 377], [74, 384, 126, 393], [134, 385, 175, 395], [181, 384, 206, 393], [212, 384, 292, 395], [298, 384, 325, 393], [330, 384, 366, 393], [74, 403, 103, 409], [109, 400, 154, 409], [161, 401, 241, 409], [247, 403, 269, 409], [275, 401, 296, 409], [302, 400, 349, 409], [74, 417, 131, 428], [137, 419, 186, 428], [192, 417, 214, 426], [219, 417, 242, 428], [248, 419, 319, 426], [74, 433, 119, 444], [125, 433, 204, 444], [210, 433, 278, 444], [285, 433, 295, 441], [302, 433, 340, 442], [75, 449, 98, 458], [104, 449, 142, 458], [146, 449, 215, 460], [221, 449, 258, 460], [263, 449, 293, 459], [300, 449, 339, 460], [74, 466, 101, 474], [108, 466, 185, 476], [191, 466, 261, 474], [267, 466, 309, 476], [315, 466, 354, 474], [74, 482, 151, 491], [158, 482, 201, 491], [208, 482, 258, 491], [263, 482, 292, 491], [298, 482, 333, 491], [338, 482, 360, 491], [74, 498, 131, 507], [137, 498, 150, 507], [156, 498, 197, 509], [202, 498, 257, 507], [263, 498, 310, 509], [74, 515, 128, 525], [134, 515, 156, 523], [161, 515, 218, 523], [223, 515, 261, 525], [267, 514, 280, 523], [74, 531, 156, 540], [162, 531, 188, 540], [195, 531, 257, 540], [263, 531, 315, 542], [871, 199, 878, 202], [883, 199, 908, 202], [894, 251, 904, 257], [841, 268, 841, 270], [784, 373, 811, 378], [816, 373, 896, 378], [784, 381, 811, 387], [815, 381, 847, 387], [645, 908, 670, 915], [692, 908, 712, 915], [220, 984, 285, 993], [293, 983, 779, 996]]
-    # fmt: on
-    text_list = []
-    bbox_list = []
-    for text, box in zip(words, boxes):
-        if text == "":
-            continue
-        sub_tokens = tokenizer.tokenize(text)
-        for sub_token in sub_tokens:
-            text_list.append(sub_token)
-            bbox_list.append(box)
-
-    input_ids = tokenizer.convert_tokens_to_ids(text_list)
-
-    input_ids = prompt_ids + input_ids
-    bbox = [[0, 0, 0, 0]] * len(prompt_ids) + bbox_list
-
-    pixel_values = image_processor(image, return_tensors="pt").pixel_values
-    original_pixel_values = original_transform(image, image_size=image_processor.size["height"]).unsqueeze(0)
-    # verify pixel values
-    assert torch.allclose(original_pixel_values, pixel_values)
-    print("Pixel values are ok!")
-
-    return torch.tensor(input_ids).unsqueeze(0), torch.tensor(bbox).unsqueeze(0).float(), pixel_values
-
-
-def convert_udop_checkpoint(model_name, pytorch_dump_folder_path=None, push_to_hub=False):
-    # model_name to checkpoint_path
-    name_to_checkpoint_path = {
-        "udop-large": "/Users/nielsrogge/Documents/UDOP/udop-unimodel-large-224/pytorch_model.bin",
-        "udop-large-512": "/Users/nielsrogge/Documents/UDOP/udop-unimodel-large-512/pytorch_model.bin",
-        "udop-large-512-300k": "/Users/nielsrogge/Documents/UDOP/udop-unimodel-large-512-300k-steps/pytorch_model.bin",
-    }
-
-    # load original state dict
-    checkpoint_path = name_to_checkpoint_path[model_name]
-    state_dict = torch.load(checkpoint_path, map_location="cpu")
-
-    print("Checkpoint path:", checkpoint_path)
-
-    # create HF model
-    image_size = 512 if "512" in model_name else 224
-    config = UdopConfig(decoder_start_token_id=0, image_size=image_size)
-    model = UdopForConditionalGeneration(config)
-    model.eval()
-
-    # rename keys
-    state_dict = {k.replace("cell2dembedding", "cell_2d_embedding"): v for k, v in state_dict.items()}
-
-    # load weights
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    print("Missing keys:", missing_keys)
-    print("Unexpected keys:", unexpected_keys)
-    assert missing_keys == ["encoder.embed_patches.proj.weight", "encoder.embed_patches.proj.bias"]
-    assert unexpected_keys == ["pos_embed"]
-
-    # Add extra_ids to the special token list
-    # NOTE special tokens have a unique order
-    # see https://github.com/huggingface/transformers/issues/29591 for details
-    # fmt: off
-    additional_special_tokens = ['<extra_id_99>', '<extra_id_98>', '<extra_id_97>', '<extra_id_96>', '<extra_id_95>', '<extra_id_94>', '<extra_id_93>', '<extra_id_92>', '<extra_id_91>', '<extra_id_90>', '<extra_id_89>', '<extra_id_88>', '<extra_id_87>', '<extra_id_86>', '<extra_id_85>', '<extra_id_84>', '<extra_id_83>', '<extra_id_82>', '<extra_id_81>', '<extra_id_80>', '<extra_id_79>', '<extra_id_78>', '<extra_id_77>', '<extra_id_76>', '<extra_id_75>', '<extra_id_74>', '<extra_id_73>', '<extra_id_72>', '<extra_id_71>', '<extra_id_70>', '<extra_id_69>', '<extra_id_68>', '<extra_id_67>', '<extra_id_66>', '<extra_id_65>', '<extra_id_64>', '<extra_id_63>', '<extra_id_62>', '<extra_id_61>', '<extra_id_60>', '<extra_id_59>', '<extra_id_58>', '<extra_id_57>', '<extra_id_56>', '<extra_id_55>', '<extra_id_54>', '<extra_id_53>', '<extra_id_52>', '<extra_id_51>', '<extra_id_50>', '<extra_id_49>', '<extra_id_48>', '<extra_id_47>', '<extra_id_46>', '<extra_id_45>', '<extra_id_44>', '<extra_id_43>', '<extra_id_42>', '<extra_id_41>', '<extra_id_40>', '<extra_id_39>', '<extra_id_38>', '<extra_id_37>', '<extra_id_36>', '<extra_id_35>', '<extra_id_34>', '<extra_id_33>', '<extra_id_32>', '<extra_id_31>', '<extra_id_30>', '<extra_id_29>', '<extra_id_28>', '<extra_id_27>', '<extra_id_26>', '<extra_id_25>', '<extra_id_24>', '<extra_id_23>', '<extra_id_22>', '<extra_id_21>', '<extra_id_20>', '<extra_id_19>', '<extra_id_18>', '<extra_id_17>', '<extra_id_16>', '<extra_id_15>', '<extra_id_14>', '<extra_id_13>', '<extra_id_12>', '<extra_id_11>', '<extra_id_10>', '<extra_id_9>', '<extra_id_8>', '<extra_id_7>', '<extra_id_6>', '<extra_id_5>', '<extra_id_4>', '<extra_id_3>', '<extra_id_2>', '<extra_id_1>', '<extra_id_0>', '<extra_l_id_99>', '<extra_l_id_98>', '<extra_l_id_97>', '<extra_l_id_96>', '<extra_l_id_95>', '<extra_l_id_94>', '<extra_l_id_93>', '<extra_l_id_92>', '<extra_l_id_91>', '<extra_l_id_90>', '<extra_l_id_89>', '<extra_l_id_88>', '<extra_l_id_87>', '<extra_l_id_86>', '<extra_l_id_85>', '<extra_l_id_84>', '<extra_l_id_83>', '<extra_l_id_82>', '<extra_l_id_81>', '<extra_l_id_80>', '<extra_l_id_79>', '<extra_l_id_78>', '<extra_l_id_77>', '<extra_l_id_76>', '<extra_l_id_75>', '<extra_l_id_74>', '<extra_l_id_73>', '<extra_l_id_72>', '<extra_l_id_71>', '<extra_l_id_70>', '<extra_l_id_69>', '<extra_l_id_68>', '<extra_l_id_67>', '<extra_l_id_66>', '<extra_l_id_65>', '<extra_l_id_64>', '<extra_l_id_63>', '<extra_l_id_62>', '<extra_l_id_61>', '<extra_l_id_60>', '<extra_l_id_59>', '<extra_l_id_58>', '<extra_l_id_57>', '<extra_l_id_56>', '<extra_l_id_55>', '<extra_l_id_54>', '<extra_l_id_53>', '<extra_l_id_52>', '<extra_l_id_51>', '<extra_l_id_50>', '<extra_l_id_49>', '<extra_l_id_48>', '<extra_l_id_47>', '<extra_l_id_46>', '<extra_l_id_45>', '<extra_l_id_44>', '<extra_l_id_43>', '<extra_l_id_42>', '<extra_l_id_41>', '<extra_l_id_40>', '<extra_l_id_39>', '<extra_l_id_38>', '<extra_l_id_37>', '<extra_l_id_36>', '<extra_l_id_35>', '<extra_l_id_34>', '<extra_l_id_33>', '<extra_l_id_32>', '<extra_l_id_31>', '<extra_l_id_30>', '<extra_l_id_29>', '<extra_l_id_28>', '<extra_l_id_27>', '<extra_l_id_26>', '<extra_l_id_25>', '<extra_l_id_24>', '<extra_l_id_23>', '<extra_l_id_22>', '<extra_l_id_21>', '<extra_l_id_20>', '<extra_l_id_19>', '<extra_l_id_18>', '<extra_l_id_17>', '<extra_l_id_16>', '<extra_l_id_15>', '<extra_l_id_14>', '<extra_l_id_13>', '<extra_l_id_12>', '<extra_l_id_11>', '<extra_l_id_10>', '<extra_l_id_9>', '<extra_l_id_8>', '<extra_l_id_7>', '<extra_l_id_6>', '<extra_l_id_5>', '<extra_l_id_4>', '<extra_l_id_3>', '<extra_l_id_2>', '<extra_l_id_1>', '<extra_l_id_0>', '</extra_l_id_99>', '</extra_l_id_98>', '</extra_l_id_97>', '</extra_l_id_96>', '</extra_l_id_95>', '</extra_l_id_94>', '</extra_l_id_93>', '</extra_l_id_92>', '</extra_l_id_91>', '</extra_l_id_90>', '</extra_l_id_89>', '</extra_l_id_88>', '</extra_l_id_87>', '</extra_l_id_86>', '</extra_l_id_85>', '</extra_l_id_84>', '</extra_l_id_83>', '</extra_l_id_82>', '</extra_l_id_81>', '</extra_l_id_80>', '</extra_l_id_79>', '</extra_l_id_78>', '</extra_l_id_77>', '</extra_l_id_76>', '</extra_l_id_75>', '</extra_l_id_74>', '</extra_l_id_73>', '</extra_l_id_72>', '</extra_l_id_71>', '</extra_l_id_70>', '</extra_l_id_69>', '</extra_l_id_68>', '</extra_l_id_67>', '</extra_l_id_66>', '</extra_l_id_65>', '</extra_l_id_64>', '</extra_l_id_63>', '</extra_l_id_62>', '</extra_l_id_61>', '</extra_l_id_60>', '</extra_l_id_59>', '</extra_l_id_58>', '</extra_l_id_57>', '</extra_l_id_56>', '</extra_l_id_55>', '</extra_l_id_54>', '</extra_l_id_53>', '</extra_l_id_52>', '</extra_l_id_51>', '</extra_l_id_50>', '</extra_l_id_49>', '</extra_l_id_48>', '</extra_l_id_47>', '</extra_l_id_46>', '</extra_l_id_45>', '</extra_l_id_44>', '</extra_l_id_43>', '</extra_l_id_42>', '</extra_l_id_41>', '</extra_l_id_40>', '</extra_l_id_39>', '</extra_l_id_38>', '</extra_l_id_37>', '</extra_l_id_36>', '</extra_l_id_35>', '</extra_l_id_34>', '</extra_l_id_33>', '</extra_l_id_32>', '</extra_l_id_31>', '</extra_l_id_30>', '</extra_l_id_29>', '</extra_l_id_28>', '</extra_l_id_27>', '</extra_l_id_26>', '</extra_l_id_25>', '</extra_l_id_24>', '</extra_l_id_23>', '</extra_l_id_22>', '</extra_l_id_21>', '</extra_l_id_20>', '</extra_l_id_19>', '</extra_l_id_18>', '</extra_l_id_17>', '</extra_l_id_16>', '</extra_l_id_15>', '</extra_l_id_14>', '</extra_l_id_13>', '</extra_l_id_12>', '</extra_l_id_11>', '</extra_l_id_10>', '</extra_l_id_9>', '</extra_l_id_8>', '</extra_l_id_7>', '</extra_l_id_6>', '</extra_l_id_5>', '</extra_l_id_4>', '</extra_l_id_3>', '</extra_l_id_2>', '</extra_l_id_1>', '</extra_l_id_0>', '<extra_t_id_99>', '<extra_t_id_98>', '<extra_t_id_97>', '<extra_t_id_96>', '<extra_t_id_95>', '<extra_t_id_94>', '<extra_t_id_93>', '<extra_t_id_92>', '<extra_t_id_91>', '<extra_t_id_90>', '<extra_t_id_89>', '<extra_t_id_88>', '<extra_t_id_87>', '<extra_t_id_86>', '<extra_t_id_85>', '<extra_t_id_84>', '<extra_t_id_83>', '<extra_t_id_82>', '<extra_t_id_81>', '<extra_t_id_80>', '<extra_t_id_79>', '<extra_t_id_78>', '<extra_t_id_77>', '<extra_t_id_76>', '<extra_t_id_75>', '<extra_t_id_74>', '<extra_t_id_73>', '<extra_t_id_72>', '<extra_t_id_71>', '<extra_t_id_70>', '<extra_t_id_69>', '<extra_t_id_68>', '<extra_t_id_67>', '<extra_t_id_66>', '<extra_t_id_65>', '<extra_t_id_64>', '<extra_t_id_63>', '<extra_t_id_62>', '<extra_t_id_61>', '<extra_t_id_60>', '<extra_t_id_59>', '<extra_t_id_58>', '<extra_t_id_57>', '<extra_t_id_56>', '<extra_t_id_55>', '<extra_t_id_54>', '<extra_t_id_53>', '<extra_t_id_52>', '<extra_t_id_51>', '<extra_t_id_50>', '<extra_t_id_49>', '<extra_t_id_48>', '<extra_t_id_47>', '<extra_t_id_46>', '<extra_t_id_45>', '<extra_t_id_44>', '<extra_t_id_43>', '<extra_t_id_42>', '<extra_t_id_41>', '<extra_t_id_40>', '<extra_t_id_39>', '<extra_t_id_38>', '<extra_t_id_37>', '<extra_t_id_36>', '<extra_t_id_35>', '<extra_t_id_34>', '<extra_t_id_33>', '<extra_t_id_32>', '<extra_t_id_31>', '<extra_t_id_30>', '<extra_t_id_29>', '<extra_t_id_28>', '<extra_t_id_27>', '<extra_t_id_26>', '<extra_t_id_25>', '<extra_t_id_24>', '<extra_t_id_23>', '<extra_t_id_22>', '<extra_t_id_21>', '<extra_t_id_20>', '<extra_t_id_19>', '<extra_t_id_18>', '<extra_t_id_17>', '<extra_t_id_16>', '<extra_t_id_15>', '<extra_t_id_14>', '<extra_t_id_13>', '<extra_t_id_12>', '<extra_t_id_11>', '<extra_t_id_10>', '<extra_t_id_9>', '<extra_t_id_8>', '<extra_t_id_7>', '<extra_t_id_6>', '<extra_t_id_5>', '<extra_t_id_4>', '<extra_t_id_3>', '<extra_t_id_2>', '<extra_t_id_1>', '<extra_t_id_0>', '</extra_t_id_99>', '</extra_t_id_98>', '</extra_t_id_97>', '</extra_t_id_96>', '</extra_t_id_95>', '</extra_t_id_94>', '</extra_t_id_93>', '</extra_t_id_92>', '</extra_t_id_91>', '</extra_t_id_90>', '</extra_t_id_89>', '</extra_t_id_88>', '</extra_t_id_87>', '</extra_t_id_86>', '</extra_t_id_85>', '</extra_t_id_84>', '</extra_t_id_83>', '</extra_t_id_82>', '</extra_t_id_81>', '</extra_t_id_80>', '</extra_t_id_79>', '</extra_t_id_78>', '</extra_t_id_77>', '</extra_t_id_76>', '</extra_t_id_75>', '</extra_t_id_74>', '</extra_t_id_73>', '</extra_t_id_72>', '</extra_t_id_71>', '</extra_t_id_70>', '</extra_t_id_69>', '</extra_t_id_68>', '</extra_t_id_67>', '</extra_t_id_66>', '</extra_t_id_65>', '</extra_t_id_64>', '</extra_t_id_63>', '</extra_t_id_62>', '</extra_t_id_61>', '</extra_t_id_60>', '</extra_t_id_59>', '</extra_t_id_58>', '</extra_t_id_57>', '</extra_t_id_56>', '</extra_t_id_55>', '</extra_t_id_54>', '</extra_t_id_53>', '</extra_t_id_52>', '</extra_t_id_51>', '</extra_t_id_50>', '</extra_t_id_49>', '</extra_t_id_48>', '</extra_t_id_47>', '</extra_t_id_46>', '</extra_t_id_45>', '</extra_t_id_44>', '</extra_t_id_43>', '</extra_t_id_42>', '</extra_t_id_41>', '</extra_t_id_40>', '</extra_t_id_39>', '</extra_t_id_38>', '</extra_t_id_37>', '</extra_t_id_36>', '</extra_t_id_35>', '</extra_t_id_34>', '</extra_t_id_33>', '</extra_t_id_32>', '</extra_t_id_31>', '</extra_t_id_30>', '</extra_t_id_29>', '</extra_t_id_28>', '</extra_t_id_27>', '</extra_t_id_26>', '</extra_t_id_25>', '</extra_t_id_24>', '</extra_t_id_23>', '</extra_t_id_22>', '</extra_t_id_21>', '</extra_t_id_20>', '</extra_t_id_19>', '</extra_t_id_18>', '</extra_t_id_17>', '</extra_t_id_16>', '</extra_t_id_15>', '</extra_t_id_14>', '</extra_t_id_13>', '</extra_t_id_12>', '</extra_t_id_11>', '</extra_t_id_10>', '</extra_t_id_9>', '</extra_t_id_8>', '</extra_t_id_7>', '</extra_t_id_6>', '</extra_t_id_5>', '</extra_t_id_4>', '</extra_t_id_3>', '</extra_t_id_2>', '</extra_t_id_1>', '</extra_t_id_0>', '<loc_500>', '<loc_499>', '<loc_498>', '<loc_497>', '<loc_496>', '<loc_495>', '<loc_494>', '<loc_493>', '<loc_492>', '<loc_491>', '<loc_490>', '<loc_489>', '<loc_488>', '<loc_487>', '<loc_486>', '<loc_485>', '<loc_484>', '<loc_483>', '<loc_482>', '<loc_481>', '<loc_480>', '<loc_479>', '<loc_478>', '<loc_477>', '<loc_476>', '<loc_475>', '<loc_474>', '<loc_473>', '<loc_472>', '<loc_471>', '<loc_470>', '<loc_469>', '<loc_468>', '<loc_467>', '<loc_466>', '<loc_465>', '<loc_464>', '<loc_463>', '<loc_462>', '<loc_461>', '<loc_460>', '<loc_459>', '<loc_458>', '<loc_457>', '<loc_456>', '<loc_455>', '<loc_454>', '<loc_453>', '<loc_452>', '<loc_451>', '<loc_450>', '<loc_449>', '<loc_448>', '<loc_447>', '<loc_446>', '<loc_445>', '<loc_444>', '<loc_443>', '<loc_442>', '<loc_441>', '<loc_440>', '<loc_439>', '<loc_438>', '<loc_437>', '<loc_436>', '<loc_435>', '<loc_434>', '<loc_433>', '<loc_432>', '<loc_431>', '<loc_430>', '<loc_429>', '<loc_428>', '<loc_427>', '<loc_426>', '<loc_425>', '<loc_424>', '<loc_423>', '<loc_422>', '<loc_421>', '<loc_420>', '<loc_419>', '<loc_418>', '<loc_417>', '<loc_416>', '<loc_415>', '<loc_414>', '<loc_413>', '<loc_412>', '<loc_411>', '<loc_410>', '<loc_409>', '<loc_408>', '<loc_407>', '<loc_406>', '<loc_405>', '<loc_404>', '<loc_403>', '<loc_402>', '<loc_401>', '<loc_400>', '<loc_399>', '<loc_398>', '<loc_397>', '<loc_396>', '<loc_395>', '<loc_394>', '<loc_393>', '<loc_392>', '<loc_391>', '<loc_390>', '<loc_389>', '<loc_388>', '<loc_387>', '<loc_386>', '<loc_385>', '<loc_384>', '<loc_383>', '<loc_382>', '<loc_381>', '<loc_380>', '<loc_379>', '<loc_378>', '<loc_377>', '<loc_376>', '<loc_375>', '<loc_374>', '<loc_373>', '<loc_372>', '<loc_371>', '<loc_370>', '<loc_369>', '<loc_368>', '<loc_367>', '<loc_366>', '<loc_365>', '<loc_364>', '<loc_363>', '<loc_362>', '<loc_361>', '<loc_360>', '<loc_359>', '<loc_358>', '<loc_357>', '<loc_356>', '<loc_355>', '<loc_354>', '<loc_353>', '<loc_352>', '<loc_351>', '<loc_350>', '<loc_349>', '<loc_348>', '<loc_347>', '<loc_346>', '<loc_345>', '<loc_344>', '<loc_343>', '<loc_342>', '<loc_341>', '<loc_340>', '<loc_339>', '<loc_338>', '<loc_337>', '<loc_336>', '<loc_335>', '<loc_334>', '<loc_333>', '<loc_332>', '<loc_331>', '<loc_330>', '<loc_329>', '<loc_328>', '<loc_327>', '<loc_326>', '<loc_325>', '<loc_324>', '<loc_323>', '<loc_322>', '<loc_321>', '<loc_320>', '<loc_319>', '<loc_318>', '<loc_317>', '<loc_316>', '<loc_315>', '<loc_314>', '<loc_313>', '<loc_312>', '<loc_311>', '<loc_310>', '<loc_309>', '<loc_308>', '<loc_307>', '<loc_306>', '<loc_305>', '<loc_304>', '<loc_303>', '<loc_302>', '<loc_301>', '<loc_300>', '<loc_299>', '<loc_298>', '<loc_297>', '<loc_296>', '<loc_295>', '<loc_294>', '<loc_293>', '<loc_292>', '<loc_291>', '<loc_290>', '<loc_289>', '<loc_288>', '<loc_287>', '<loc_286>', '<loc_285>', '<loc_284>', '<loc_283>', '<loc_282>', '<loc_281>', '<loc_280>', '<loc_279>', '<loc_278>', '<loc_277>', '<loc_276>', '<loc_275>', '<loc_274>', '<loc_273>', '<loc_272>', '<loc_271>', '<loc_270>', '<loc_269>', '<loc_268>', '<loc_267>', '<loc_266>', '<loc_265>', '<loc_264>', '<loc_263>', '<loc_262>', '<loc_261>', '<loc_260>', '<loc_259>', '<loc_258>', '<loc_257>', '<loc_256>', '<loc_255>', '<loc_254>', '<loc_253>', '<loc_252>', '<loc_251>', '<loc_250>', '<loc_249>', '<loc_248>', '<loc_247>', '<loc_246>', '<loc_245>', '<loc_244>', '<loc_243>', '<loc_242>', '<loc_241>', '<loc_240>', '<loc_239>', '<loc_238>', '<loc_237>', '<loc_236>', '<loc_235>', '<loc_234>', '<loc_233>', '<loc_232>', '<loc_231>', '<loc_230>', '<loc_229>', '<loc_228>', '<loc_227>', '<loc_226>', '<loc_225>', '<loc_224>', '<loc_223>', '<loc_222>', '<loc_221>', '<loc_220>', '<loc_219>', '<loc_218>', '<loc_217>', '<loc_216>', '<loc_215>', '<loc_214>', '<loc_213>', '<loc_212>', '<loc_211>', '<loc_210>', '<loc_209>', '<loc_208>', '<loc_207>', '<loc_206>', '<loc_205>', '<loc_204>', '<loc_203>', '<loc_202>', '<loc_201>', '<loc_200>', '<loc_199>', '<loc_198>', '<loc_197>', '<loc_196>', '<loc_195>', '<loc_194>', '<loc_193>', '<loc_192>', '<loc_191>', '<loc_190>', '<loc_189>', '<loc_188>', '<loc_187>', '<loc_186>', '<loc_185>', '<loc_184>', '<loc_183>', '<loc_182>', '<loc_181>', '<loc_180>', '<loc_179>', '<loc_178>', '<loc_177>', '<loc_176>', '<loc_175>', '<loc_174>', '<loc_173>', '<loc_172>', '<loc_171>', '<loc_170>', '<loc_169>', '<loc_168>', '<loc_167>', '<loc_166>', '<loc_165>', '<loc_164>', '<loc_163>', '<loc_162>', '<loc_161>', '<loc_160>', '<loc_159>', '<loc_158>', '<loc_157>', '<loc_156>', '<loc_155>', '<loc_154>', '<loc_153>', '<loc_152>', '<loc_151>', '<loc_150>', '<loc_149>', '<loc_148>', '<loc_147>', '<loc_146>', '<loc_145>', '<loc_144>', '<loc_143>', '<loc_142>', '<loc_141>', '<loc_140>', '<loc_139>', '<loc_138>', '<loc_137>', '<loc_136>', '<loc_135>', '<loc_134>', '<loc_133>', '<loc_132>', '<loc_131>', '<loc_130>', '<loc_129>', '<loc_128>', '<loc_127>', '<loc_126>', '<loc_125>', '<loc_124>', '<loc_123>', '<loc_122>', '<loc_121>', '<loc_120>', '<loc_119>', '<loc_118>', '<loc_117>', '<loc_116>', '<loc_115>', '<loc_114>', '<loc_113>', '<loc_112>', '<loc_111>', '<loc_110>', '<loc_109>', '<loc_108>', '<loc_107>', '<loc_106>', '<loc_105>', '<loc_104>', '<loc_103>', '<loc_102>', '<loc_101>', '<loc_100>', '<loc_99>', '<loc_98>', '<loc_97>', '<loc_96>', '<loc_95>', '<loc_94>', '<loc_93>', '<loc_92>', '<loc_91>', '<loc_90>', '<loc_89>', '<loc_88>', '<loc_87>', '<loc_86>', '<loc_85>', '<loc_84>', '<loc_83>', '<loc_82>', '<loc_81>', '<loc_80>', '<loc_79>', '<loc_78>', '<loc_77>', '<loc_76>', '<loc_75>', '<loc_74>', '<loc_73>', '<loc_72>', '<loc_71>', '<loc_70>', '<loc_69>', '<loc_68>', '<loc_67>', '<loc_66>', '<loc_65>', '<loc_64>', '<loc_63>', '<loc_62>', '<loc_61>', '<loc_60>', '<loc_59>', '<loc_58>', '<loc_57>', '<loc_56>', '<loc_55>', '<loc_54>', '<loc_53>', '<loc_52>', '<loc_51>', '<loc_50>', '<loc_49>', '<loc_48>', '<loc_47>', '<loc_46>', '<loc_45>', '<loc_44>', '<loc_43>', '<loc_42>', '<loc_41>', '<loc_40>', '<loc_39>', '<loc_38>', '<loc_37>', '<loc_36>', '<loc_35>', '<loc_34>', '<loc_33>', '<loc_32>', '<loc_31>', '<loc_30>', '<loc_29>', '<loc_28>', '<loc_27>', '<loc_26>', '<loc_25>', '<loc_24>', '<loc_23>', '<loc_22>', '<loc_21>', '<loc_20>', '<loc_19>', '<loc_18>', '<loc_17>', '<loc_16>', '<loc_15>', '<loc_14>', '<loc_13>', '<loc_12>', '<loc_11>', '<loc_10>', '<loc_9>', '<loc_8>', '<loc_7>', '<loc_6>', '<loc_5>', '<loc_4>', '<loc_3>', '<loc_2>', '<loc_1>', '<loc_0>', '<other_199>', '<other_198>', '<other_197>', '<other_196>', '<other_195>', '<other_194>', '<other_193>', '<other_192>', '<other_191>', '<other_190>', '<other_189>', '<other_188>', '<other_187>', '<other_186>', '<other_185>', '<other_184>', '<other_183>', '<other_182>', '<other_181>', '<other_180>', '<other_179>', '<other_178>', '<other_177>', '<other_176>', '<other_175>', '<other_174>', '<other_173>', '<other_172>', '<other_171>', '<other_170>', '<other_169>', '<other_168>', '<other_167>', '<other_166>', '<other_165>', '<other_164>', '<other_163>', '<other_162>', '<other_161>', '<other_160>', '<other_159>', '<other_158>', '<other_157>', '<other_156>', '<other_155>', '<other_154>', '<other_153>', '<other_152>', '<other_151>', '<other_150>', '<other_149>', '<other_148>', '<other_147>', '<other_146>', '<other_145>', '<other_144>', '<other_143>', '<other_142>', '<other_141>', '<other_140>', '<other_139>', '<other_138>', '<other_137>', '<other_136>', '<other_135>', '<other_134>', '<other_133>', '<other_132>', '<other_131>', '<other_130>', '<other_129>', '<other_128>', '<other_127>', '<other_126>', '<other_125>', '<other_124>', '<other_123>', '<other_122>', '<other_121>', '<other_120>', '<other_119>', '<other_118>', '<other_117>', '<other_116>', '<other_115>', '<other_114>', '<other_113>', '<other_112>', '<other_111>', '<other_110>', '<other_109>', '<other_108>', '<other_107>', '<other_106>', '<other_105>', '<other_104>', '<other_103>', '<other_102>', '<other_101>', '<other_100>', '<other_99>', '<other_98>', '<other_97>', '<other_96>', '<other_95>', '<other_94>', '<other_93>', '<other_92>', '<other_91>', '<other_90>', '<other_89>', '<other_88>', '<other_87>', '<other_86>', '<other_85>', '<other_84>', '<other_83>', '<other_82>', '<other_81>', '<other_80>', '<other_79>', '<other_78>', '<other_77>', '<other_76>', '<other_75>', '<other_74>', '<other_73>', '<other_72>', '<other_71>', '<other_70>', '<other_69>', '<other_68>', '<other_67>', '<other_66>', '<other_65>', '<other_64>', '<other_63>', '<other_62>', '<other_61>', '<other_60>', '<other_59>', '<other_58>', '<other_57>', '<other_56>', '<other_55>', '<other_54>', '<other_53>', '<other_52>', '<other_51>', '<other_50>', '<other_49>', '<other_48>', '<other_47>', '<other_46>', '<other_45>', '<other_44>', '<other_43>', '<other_42>', '<other_41>', '<other_40>', '<other_39>', '<other_38>', '<other_37>', '<other_36>', '<other_35>', '<other_34>', '<other_33>', '<other_32>', '<other_31>', '<other_30>', '<other_29>', '<other_28>', '<other_27>', '<other_26>', '<other_25>', '<other_24>', '<other_23>', '<other_22>', '<other_21>', '<other_20>', '<other_19>', '<other_18>', '<other_17>', '<other_16>', '<other_15>', '<other_14>', '<other_13>', '<other_12>', '<other_11>', '<other_10>', '<other_9>', '<other_8>', '<other_7>', '<other_6>', '<other_5>', '<other_4>', '<other_3>', '<other_2>', '<other_1>', '<other_0>']
-    # fmt: on
-
-    tokenizer = UdopTokenizer.from_pretrained(
-        "/Users/nielsrogge/Documents/UDOP/udop-unimodel-large-512",
-        legacy=True,
-        additional_special_tokens=additional_special_tokens,
-    )
-    size = {"height": image_size, "width": image_size}
-    image_processor = LayoutLMv3ImageProcessor(
-        image_mean=IMAGENET_DEFAULT_MEAN, image_std=IMAGENET_DEFAULT_STD, size=size
-    )
-    processor = UdopProcessor(image_processor=image_processor, tokenizer=tokenizer)
-
-    # prepare dummy inputs
-    input_ids, bbox, image = prepare_dummy_inputs(tokenizer, image_processor)
-    prompt = "Question answering. In which year is the report made?"
-    encoding = processor(images=get_image(), text=prompt, return_tensors="pt")
-
-    input_ids = encoding.input_ids
-    try:
-        EXPECTED_INPUT_IDS = torch.tensor([[11860, 18243, 5, 86, 84, 215, 19, 8, 934, 263, 58, 1, 489, 27, 3838, 7363, 4083, 14536, 3430, 5686, 5911, 17161, 134, 2038, 27, 3838, 22, 7, 4688, 7, 10, 389, 18202, 21, 8, 11046, 37, 3733, 523, 11, 38, 2388, 1628, 3, 13133, 23334, 6, 8, 1656, 79, 3806, 21, 4040, 640, 27, 3838, 22, 7, 701, 16534, 6, 8, 3, 76, 2693, 18, 23015, 5644, 24, 380, 3, 6015, 6, 11, 8, 701, 24, 79, 482, 21, 3, 88, 684, 6, 43, 263, 27, 3838, 22, 7, 3635, 1157, 4089, 6, 2651, 12, 1547, 22, 7, 3265, 655, 5, 19, 27, 3838, 22, 7, 38, 2388, 257, 12, 36, 8, 465, 209, 13409, 12150, 1959, 16, 8, 684, 6, 6737, 57, 165, 126, 13409, 12150, 1623, 5, 71, 1100, 30298, 934, 65, 12566, 24, 27, 3838, 31, 7, 126, 13409, 12150, 1623, 33, 8, 10391, 1710, 859, 8, 420, 3733, 4968, 688, 2699, 16, 1547, 5, 27, 3838, 1217, 131, 99, 23, 179, 6064, 24, 6, 590, 28, 3, 11600, 1456, 701, 6, 175, 9443, 2557, 3635, 92, 1262, 8, 3409, 13, 2186, 3, 27908, 1784, 190, 8, 3, 5771, 17, 13281, 4005, 13, 5086, 11, 13066, 1170, 5, 10826, 16309, 134, 3, 2, 276, 26, 3, 55, 391, 13570, 5, 10315, 309, 3577, 19114, 371, 4254, 5121, 5055, 6245, 3, 10047, 3162, 58, 3, 9, 61, 1713, 2703, 476, 667, 25158, 301, 6058, 6038, 476, 3765, 9149, 10, 4893, 1303, 1986, 5, 13580, 7, 8224, 28244, 7, 5, 76, 75, 7, 89, 5, 15, 1259, 87, 7171, 7, 87, 7, 29, 115, 226, 4305, 2773, 1]])  # fmt: skip
-        torch.testing.assert_close(EXPECTED_INPUT_IDS, input_ids)
-        bbox = encoding.bbox.float()
-        pixel_values = encoding.pixel_values
-    except Exception:
-        print("Input_ids don't match, preparing dummy inputs")
-        input_ids, bbox, pixel_values = prepare_dummy_inputs(tokenizer, image_processor)
-
-    # Verify single forward pass
-    print("Testing single forward pass..")
-    with torch.no_grad():
-        decoder_input_ids = torch.tensor([[101]])
-        outputs = model(input_ids=input_ids, bbox=bbox, pixel_values=pixel_values, decoder_input_ids=decoder_input_ids)
-        print("Shape of logits:", outputs.logits.shape)
-        print("First values of logits:", outputs.logits[0, :3, :3])
-
-    # tensor([[-18.5262,   1.5087, -15.7051]]) on linux
-    # tensor([[-19.4976,   0.8515, -17.1873]]) on mac
-    try:
-        assert torch.allclose(outputs.logits[0, :3, :3], torch.tensor([[-18.5262, 1.5087, -15.7051]]), atol=1e-4)
-        print("Looks ok!")
-    except Exception:
-        print("logits don't match let's try to generate")
-
-    # Verify autoregressive decoding
-    print("Testing generation...")
-    model_kwargs = {"bbox": bbox, "pixel_values": pixel_values}
-    outputs = model.generate(input_ids=input_ids, **model_kwargs, max_new_tokens=20)
-
-    print("Generated:", tokenizer.batch_decode(outputs, skip_special_tokens=True))
-
-    # autoregressive decoding with original input data
-    print("Testing generation with original inputs...")
-    filepath = hf_hub_download(repo_id="nielsr/test-image", filename="input_ids_udop.pt", repo_type="dataset")
-    input_ids = torch.load(filepath)
-    filepath = hf_hub_download(repo_id="nielsr/test-image", filename="bbox_udop.pt", repo_type="dataset")
-    bbox = torch.load(filepath)
-    pixel_values_filename = "pixel_values_udop_512.pt" if "512" in model_name else "pixel_values_udop_224.pt"
-    filepath = hf_hub_download(repo_id="nielsr/test-image", filename=pixel_values_filename, repo_type="dataset")
-    pixel_values = torch.load(filepath)
-
-    print("Decoded input ids:", tokenizer.decode(input_ids[0], skip_special_tokens=True))
-    print("Bbox shape:", bbox.shape)
-
-    model_kwargs = {"bbox": bbox, "pixel_values": pixel_values}
-    outputs = model.generate(input_ids=input_ids, **model_kwargs, max_new_tokens=20)
-    generated_text = tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]
-    print("Generated:", generated_text)
-
-    if pytorch_dump_folder_path is not None:
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model.push_to_hub(f"microsoft/{model_name}")
-        processor.push_to_hub(f"microsoft/{model_name}")
-        # BIG note here: to save the fast tokenizer files in the repo on the hub, you need to do the following:
-        # see https://discuss.huggingface.co/t/convert-slow-xlmrobertatokenizer-to-fast-one/20876
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="udop-large",
-        type=str,
-        choices=["udop-large", "udop-large-512", "udop-large-512-300k"],
-        help=("Name of the UDOP model you'd like to convert."),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_udop_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/umt5/convert_umt5_checkpoint_to_pytorch.py b/src/transformers/models/umt5/convert_umt5_checkpoint_to_pytorch.py
deleted file mode 100644
index 848ca3c5660c..000000000000
--- a/src/transformers/models/umt5/convert_umt5_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,274 +0,0 @@
-# coding=utf-8
-# Copyright 2023 Google LLC and HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Convert T5X checkpoint to PyTorch
-
-Steps:
-- Install gsutil according to https://cloud.google.com/storage/docs/gsutil_install
-- Get a T5X checkpoint at https://github.com/google-research/t5x/blob/main/docs/models.md#t5-11-checkpoints Example:
-    `gsutil -m cp -r gs://t5-data/pretrained_models/t5x/t5_1_1_small $HOME/`
-- Create or download a corresponding config for the downloaded model. E.g. for T5 v1.1 small, you can use
-    https://huggingface.co/google/t5-v1_1-small/blob/main/config.json
-- Convert:
-    ```
-    python3 convert_t5x_checkpoint_to_pytorch.py --t5x_checkpoint_path=$HOME/t5_1_1_small --config_file=config.json\
-      --pytorch_dump_path=$HOME/t5_1_1_small_pt
-    ```
-"""
-
-import argparse
-import collections
-
-import numpy as np
-import torch
-from flax import traverse_util
-from t5x import checkpoints
-
-from transformers import MT5Config, UMT5EncoderModel, UMT5ForConditionalGeneration
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-
-
-def t5x_relpos_bias_lookup(params, i, prefix):
-    """Returns the Relative Position Bias parameters of a layer. Does not transpose."""
-    return params[f"{prefix}/{prefix}/relpos_bias/rel_embedding"][:, i, :]
-
-
-def t5x_attention_lookup(params, i, prefix, layer_name="attention"):
-    """Returns the KOQV parameters of (self-)attention. Does not transpose."""
-    k_tmp = k_tmp = np.ascontiguousarray(params[f"{prefix}/{prefix}/{layer_name}/key/kernel"][:, i, :, :])
-    k = k_tmp.reshape(k_tmp.shape[0], k_tmp.shape[1] * k_tmp.shape[2])
-    o_tmp = np.ascontiguousarray(params[f"{prefix}/{prefix}/{layer_name}/out/kernel"][:, i, :, :])
-    o = o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1], o_tmp.shape[2])
-    q_tmp = np.ascontiguousarray(params[f"{prefix}/{prefix}/{layer_name}/query/kernel"][:, i, :, :])
-    q = q_tmp.reshape(q_tmp.shape[0], q_tmp.shape[1] * q_tmp.shape[2])
-    v_tmp = np.ascontiguousarray(params[f"{prefix}/{prefix}/{layer_name}/value/kernel"][:, i, :, :])
-    v = v_tmp.reshape(v_tmp.shape[0], v_tmp.shape[1] * v_tmp.shape[2])
-    return k, o, q, v
-
-
-def t5x_mlp_lookup(params, i, prefix, split_mlp_wi=False):
-    """Returns the MLP parameters of a layer. Does not transpose."""
-    if split_mlp_wi:
-        wi_0 = params[f"{prefix}/{prefix}/mlp/wi_0/kernel"][:, i, :]
-        wi_1 = params[f"{prefix}/{prefix}/mlp/wi_1/kernel"][:, i, :]
-        wi = (wi_0, wi_1)
-    else:
-        wi = params[f"{prefix}/{prefix}/mlp/wi/kernel"][:, i, :]
-
-    wo = params[f"{prefix}/{prefix}/mlp/wo/kernel"][:, i, :]
-    return wi, wo
-
-
-def t5x_layer_norm_lookup(params, i, prefix, layer_name):
-    """Returns the layer norm param of a layer."""
-    return params[f"{prefix}/{prefix}/{layer_name}/scale"][:, i]
-
-
-def convert_t5x_to_pytorch(
-    variables: dict, *, num_layers: int, is_encoder_only: bool, scalable_attention: bool = False
-):
-    """Converts the parameters from T5X-Flax to Transformers-PyTorch."""
-    old = traverse_util.flatten_dict(variables["target"])
-    old = {"/".join(k): v for k, v in old.items()}
-
-    # v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
-    split_mlp_wi = "encoder/encoder/mlp/wi_0/kernel" in old
-    print("Split MLP:", split_mlp_wi)
-
-    new = collections.OrderedDict()
-
-    # Shared embeddings.
-    new["shared.weight"] = old["token_embedder/embedding"]
-
-    # Encoder.
-    for i in range(num_layers):
-        # Block i, layer 0 (Self Attention).
-        layer_norm = t5x_layer_norm_lookup(old, i, "encoder", "pre_attention_layer_norm")
-        k, o, q, v = t5x_attention_lookup(old, i, "encoder", "attention")
-        new[f"encoder.block.{i}.layer.0.layer_norm.weight"] = layer_norm
-        new[f"encoder.block.{i}.layer.0.SelfAttention.k.weight"] = k.T
-        new[f"encoder.block.{i}.layer.0.SelfAttention.o.weight"] = o.T
-        new[f"encoder.block.{i}.layer.0.SelfAttention.q.weight"] = q.T
-        new[f"encoder.block.{i}.layer.0.SelfAttention.v.weight"] = v.T
-
-        # Block i, layer 1 (MLP).
-        layer_norm = t5x_layer_norm_lookup(old, i, "encoder", "pre_mlp_layer_norm")
-        wi, wo = t5x_mlp_lookup(old, i, "encoder", split_mlp_wi)
-        new[f"encoder.block.{i}.layer.1.layer_norm.weight"] = layer_norm
-        if split_mlp_wi:
-            new[f"encoder.block.{i}.layer.1.DenseReluDense.wi_0.weight"] = wi[0].T
-            new[f"encoder.block.{i}.layer.1.DenseReluDense.wi_1.weight"] = wi[1].T
-        else:
-            new[f"encoder.block.{i}.layer.1.DenseReluDense.wi.weight"] = wi.T
-        new[f"encoder.block.{i}.layer.1.DenseReluDense.wo.weight"] = wo.T
-        if scalable_attention:
-            # convert the rel_embedding of each layer
-            new[f"encoder.block.{i}.layer.0.SelfAttention.relative_attention_bias.weight"] = t5x_relpos_bias_lookup(
-                old, i, "encoder"
-            ).T
-
-    new["encoder.final_layer_norm.weight"] = old["encoder/encoder_norm/scale"]
-
-    if not scalable_attention:
-        new["encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight"] = t5x_relpos_bias_lookup(
-            old, 0, "encoder"
-        ).T
-        new["decoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight"] = t5x_relpos_bias_lookup(
-            old, 0, "decoder"
-        ).T
-
-    if not is_encoder_only:
-        # Decoder.
-        for i in range(num_layers):
-            # Block i, layer 0 (Self Attention).
-            layer_norm = t5x_layer_norm_lookup(old, i, "decoder", "pre_self_attention_layer_norm")
-            k, o, q, v = t5x_attention_lookup(old, i, "decoder", "self_attention")
-            new[f"decoder.block.{i}.layer.0.layer_norm.weight"] = layer_norm
-            new[f"decoder.block.{i}.layer.0.SelfAttention.k.weight"] = k.T
-            new[f"decoder.block.{i}.layer.0.SelfAttention.o.weight"] = o.T
-            new[f"decoder.block.{i}.layer.0.SelfAttention.q.weight"] = q.T
-            new[f"decoder.block.{i}.layer.0.SelfAttention.v.weight"] = v.T
-
-            # Block i, layer 1 (Cross Attention).
-            layer_norm = t5x_layer_norm_lookup(old, i, "decoder", "pre_cross_attention_layer_norm")
-            k, o, q, v = t5x_attention_lookup(old, i, "decoder", "encoder_decoder_attention")
-            new[f"decoder.block.{i}.layer.1.layer_norm.weight"] = layer_norm
-            new[f"decoder.block.{i}.layer.1.EncDecAttention.k.weight"] = k.T
-            new[f"decoder.block.{i}.layer.1.EncDecAttention.o.weight"] = o.T
-            new[f"decoder.block.{i}.layer.1.EncDecAttention.q.weight"] = q.T
-            new[f"decoder.block.{i}.layer.1.EncDecAttention.v.weight"] = v.T
-
-            # Block i, layer 2 (MLP).
-            layer_norm = t5x_layer_norm_lookup(old, i, "decoder", "pre_mlp_layer_norm")
-            wi, wo = t5x_mlp_lookup(old, i, "decoder", split_mlp_wi)
-            new[f"decoder.block.{i}.layer.2.layer_norm.weight"] = layer_norm
-            if split_mlp_wi:
-                new[f"decoder.block.{i}.layer.2.DenseReluDense.wi_0.weight"] = wi[0].T
-                new[f"decoder.block.{i}.layer.2.DenseReluDense.wi_1.weight"] = wi[1].T
-            else:
-                new[f"encoder.block.{i}.layer.2.DenseReluDense.wi.weight"] = wi.T
-            new[f"decoder.block.{i}.layer.2.DenseReluDense.wo.weight"] = wo.T
-
-            if scalable_attention:
-                # convert the rel_embedding of each layer
-                new[f"decoder.block.{i}.layer.0.SelfAttention.relative_attention_bias.weight"] = (
-                    t5x_relpos_bias_lookup(old, i, "decoder").T
-                )
-
-        new["decoder.final_layer_norm.weight"] = old["decoder/decoder_norm/scale"]
-
-        # LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
-        if "decoder/logits_dense/kernel" in old:
-            new["lm_head.weight"] = old["decoder/logits_dense/kernel"].T
-
-    return new
-
-
-def make_state_dict(converted_params, is_encoder_only: bool):
-    """Prepares a state dict for the PyTorch model."""
-    # Make a state dict with torch tensors.
-    state_dict = collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])
-
-    # Add what is missing.
-    if "encoder.embed_tokens.weight" not in state_dict:
-        state_dict["encoder.embed_tokens.weight"] = state_dict["shared.weight"]
-
-    if not is_encoder_only:
-        if "decoder.embed_tokens.weight" not in state_dict:
-            state_dict["decoder.embed_tokens.weight"] = state_dict["shared.weight"]
-
-        if "lm_head.weight" not in state_dict:  # For old 1.0 models.
-            print("Using shared word embeddings as lm_head.")
-            state_dict["lm_head.weight"] = state_dict["shared.weight"]
-
-    return state_dict
-
-
-def load_t5x_weights_in_t5(model, config, t5x_checkpoint_path, is_encoder_only, scalable_attention):
-    """Replaces the params in model witht the T5X converted params."""
-    variables = checkpoints.load_t5x_checkpoint(t5x_checkpoint_path)
-    converted = convert_t5x_to_pytorch(
-        variables, num_layers=config.num_layers, is_encoder_only=is_encoder_only, scalable_attention=scalable_attention
-    )
-    state_dict = make_state_dict(converted, is_encoder_only)
-    model.load_state_dict(state_dict, strict=True)
-
-
-def convert_t5x_checkpoint_to_pytorch(
-    t5x_checkpoint_path,
-    config_file,
-    pytorch_dump_path,
-    is_encoder_only: bool = False,
-    scalable_attention: bool = False,
-):
-    """Loads the config and model, converts the T5X checkpoint, and saves a PyTorch checkpoint."""
-    # Initialise PyTorch model
-    config = MT5Config.from_json_file(config_file)
-    print(f"Building PyTorch model from configuration: {config}")
-    # Non-v1.1 checkpoints could also use T5Model, but this works for all.
-    # The v1.0 checkpoints will simply have an LM head that is the word embeddings.
-    if is_encoder_only:
-        model = UMT5EncoderModel(config)
-    else:
-        model = UMT5ForConditionalGeneration(config)
-
-    # Load weights from tf checkpoint
-    load_t5x_weights_in_t5(model, config, t5x_checkpoint_path, is_encoder_only, scalable_attention)
-
-    # Save pytorch-model
-    print(f"Save PyTorch model to {pytorch_dump_path}")
-    model.save_pretrained(pytorch_dump_path)
-
-    # Verify that we can load the checkpoint.
-    model.from_pretrained(pytorch_dump_path)
-    print("Done")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Converts a native T5X checkpoint into a PyTorch checkpoint.")
-    # Required parameters
-    parser.add_argument(
-        "--t5x_checkpoint_path", default=None, type=str, required=True, help="Path to the T5X checkpoint."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--is_encoder_only", action="store_true", help="Check if the model is encoder-decoder model", default=False
-    )
-    parser.add_argument(
-        "--scalable_attention",
-        action="store_true",
-        help="Whether the model uses scaled attention (umt5 model)",
-        default=False,
-    )
-    args = parser.parse_args()
-    convert_t5x_checkpoint_to_pytorch(
-        args.t5x_checkpoint_path,
-        args.config_file,
-        args.pytorch_dump_path,
-        args.is_encoder_only,
-        args.scalable_attention,
-    )
diff --git a/src/transformers/models/unispeech/convert_unispeech_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/unispeech/convert_unispeech_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 4eb8dfa7bbd2..000000000000
--- a/src/transformers/models/unispeech/convert_unispeech_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,273 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert UniSpeech checkpoint."""
-
-import argparse
-import json
-import os
-
-import fairseq
-import torch
-from fairseq.data import Dictionary
-
-from transformers import (
-    UniSpeechConfig,
-    UniSpeechForCTC,
-    UniSpeechForPreTraining,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2PhonemeCTCTokenizer,
-    Wav2Vec2Processor,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "quantizer.weight_proj": "quantizer.weight_proj",
-    "quantizer.vars": "quantizer.codevectors",
-    "project_q": "project_q",
-    "final_proj": "project_hid",
-    "w2v_encoder.proj": "ctc_proj",
-    "mask_emb": "masked_spec_embed",
-}
-TOP_LEVEL_KEYS = [
-    "ctc_proj",
-    "quantizer.weight_proj",
-    "quantizer.codevectors",
-    "project_q",
-    "project_hid",
-]
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type, is_finetuned):
-    for attribute in key.split("."):
-        if is_finetuned:
-            if attribute in ["quantizer", "project_q", "project_hid"]:
-                # those layers are only relevant for pretraining and should be dropped
-                return
-
-            if attribute == "ctc_proj":
-                # we should rename `ctc_proj` to `lm_head` for fine-tuned phoneme models
-                attribute = "lm_head"
-
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    assert hf_shape == value.shape, (
-        f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-        f" {value.shape} for {full_name}"
-    )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model, is_finetuned):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.unispeech.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                mapped_key = "unispeech." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    elif "weight" in name:
-                        # TODO: don't match quantizer.weight_proj
-                        weight_type = "weight"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type, is_finetuned)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
-                " found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-@torch.no_grad()
-def convert_unispeech_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, config_path=None, dict_path=None, is_finetuned=True
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = UniSpeechConfig.from_pretrained(config_path)
-    else:
-        config = UniSpeechConfig()
-
-    if is_finetuned:
-        if dict_path:
-            target_dict = Dictionary.load_from_json(dict_path)
-
-            # important change bos & pad token id since CTC symbol is <pad> and
-            # not <s> as in fairseq
-            config.bos_token_id = target_dict.pad_index
-            config.pad_token_id = target_dict.bos_index
-            config.eos_token_id = target_dict.eos_index
-            config.vocab_size = len(target_dict.symbols)
-            vocab_path = os.path.join(pytorch_dump_folder_path, "vocab.json")
-            if not os.path.isdir(pytorch_dump_folder_path):
-                logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(pytorch_dump_folder_path))
-                return
-            os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-            vocab_dict = target_dict.indices
-
-            # fairseq has the <pad> and <s> switched
-            vocab_dict["<pad>"] = 42
-            vocab_dict["<s>"] = 43
-            with open(vocab_path, "w", encoding="utf-8") as vocab_handle:
-                json.dump(vocab_dict, vocab_handle)
-            tokenizer = Wav2Vec2PhonemeCTCTokenizer(
-                vocab_path,
-                unk_token=target_dict.unk_word,
-                pad_token=target_dict.pad_word,
-                bos_token=target_dict.bos_word,
-                eos_token=target_dict.eos_word,
-                word_delimiter_token="|",
-                do_lower_case=False,
-            )
-            return_attention_mask = True if config.feat_extract_norm == "layer" else False
-            feature_extractor = Wav2Vec2FeatureExtractor(
-                feature_size=1,
-                sampling_rate=16000,
-                padding_value=0,
-                do_normalize=True,
-                return_attention_mask=return_attention_mask,
-            )
-            processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
-            processor.save_pretrained(pytorch_dump_folder_path)
-
-        hf_unispeech = UniSpeechForCTC(config)
-    else:
-        hf_unispeech = UniSpeechForPreTraining(config)
-
-    if is_finetuned:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-            [checkpoint_path], arg_overrides={"data": "/".join(dict_path.split("/")[:-1]), "w2v_path": checkpoint_path}
-        )
-    else:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path])
-
-    model = model[0].eval()
-
-    recursively_load_weights(model, hf_unispeech, is_finetuned)
-
-    hf_unispeech.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
-    )
-    args = parser.parse_args()
-    convert_unispeech_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
-    )
diff --git a/src/transformers/models/unispeech_sat/convert_unispeech_original_s3prl_checkpoint_to_pytorch.py b/src/transformers/models/unispeech_sat/convert_unispeech_original_s3prl_checkpoint_to_pytorch.py
deleted file mode 100644
index fca35acb634d..000000000000
--- a/src/transformers/models/unispeech_sat/convert_unispeech_original_s3prl_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Hubert checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import (
-    UniSpeechSatConfig,
-    UniSpeechSatForAudioFrameClassification,
-    UniSpeechSatForSequenceClassification,
-    UniSpeechSatForXVector,
-    Wav2Vec2FeatureExtractor,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def convert_classification(base_model_name, hf_config, downstream_dict):
-    model = UniSpeechSatForSequenceClassification.from_pretrained(base_model_name, config=hf_config)
-    model.projector.weight.data = downstream_dict["projector.weight"]
-    model.projector.bias.data = downstream_dict["projector.bias"]
-    model.classifier.weight.data = downstream_dict["model.post_net.linear.weight"]
-    model.classifier.bias.data = downstream_dict["model.post_net.linear.bias"]
-    return model
-
-
-def convert_diarization(base_model_name, hf_config, downstream_dict):
-    model = UniSpeechSatForAudioFrameClassification.from_pretrained(base_model_name, config=hf_config)
-    model.classifier.weight.data = downstream_dict["model.linear.weight"]
-    model.classifier.bias.data = downstream_dict["model.linear.bias"]
-    return model
-
-
-def convert_xvector(base_model_name, hf_config, downstream_dict):
-    model = UniSpeechSatForXVector.from_pretrained(base_model_name, config=hf_config)
-    model.projector.weight.data = downstream_dict["connector.weight"]
-    model.projector.bias.data = downstream_dict["connector.bias"]
-    for i, kernel_size in enumerate(hf_config.tdnn_kernel):
-        model.tdnn[i].kernel.weight.data = downstream_dict[
-            f"model.framelevel_feature_extractor.module.{i}.kernel.weight"
-        ]
-        model.tdnn[i].kernel.bias.data = downstream_dict[f"model.framelevel_feature_extractor.module.{i}.kernel.bias"]
-
-    model.feature_extractor.weight.data = downstream_dict["model.utterancelevel_feature_extractor.linear1.weight"]
-    model.feature_extractor.bias.data = downstream_dict["model.utterancelevel_feature_extractor.linear1.bias"]
-    model.classifier.weight.data = downstream_dict["model.utterancelevel_feature_extractor.linear2.weight"]
-    model.classifier.bias.data = downstream_dict["model.utterancelevel_feature_extractor.linear2.bias"]
-    model.objective.weight.data = downstream_dict["objective.W"]
-    return model
-
-
-@torch.no_grad()
-def convert_s3prl_checkpoint(base_model_name, config_path, checkpoint_path, model_dump_path):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    checkpoint = torch.load(checkpoint_path, map_location="cpu")
-
-    downstream_dict = checkpoint["Downstream"]
-
-    hf_config = UniSpeechSatConfig.from_pretrained(config_path)
-    hf_feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
-        base_model_name, return_attention_mask=True, do_normalize=False
-    )
-
-    arch = hf_config.architectures[0]
-    if arch.endswith("ForSequenceClassification"):
-        hf_model = convert_classification(base_model_name, hf_config, downstream_dict)
-    elif arch.endswith("ForAudioFrameClassification"):
-        hf_model = convert_diarization(base_model_name, hf_config, downstream_dict)
-    elif arch.endswith("ForXVector"):
-        hf_model = convert_xvector(base_model_name, hf_config, downstream_dict)
-    else:
-        raise NotImplementedError(f"S3PRL weights conversion is not supported for {arch}")
-
-    if hf_config.use_weighted_layer_sum:
-        hf_model.layer_weights.data = checkpoint["Featurizer"]["weights"]
-
-    hf_feature_extractor.save_pretrained(model_dump_path)
-    hf_model.save_pretrained(model_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--base_model_name", default=None, type=str, help="Name of the huggingface pretrained base model."
-    )
-    parser.add_argument("--config_path", default=None, type=str, help="Path to the huggingface classifier config.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to the s3prl checkpoint.")
-    parser.add_argument("--model_dump_path", default=None, type=str, help="Path to the final converted model.")
-    args = parser.parse_args()
-    convert_s3prl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
diff --git a/src/transformers/models/unispeech_sat/convert_unispeech_sat_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/unispeech_sat/convert_unispeech_sat_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 4a70d41dd282..000000000000
--- a/src/transformers/models/unispeech_sat/convert_unispeech_sat_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,224 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert UniSpeechSat checkpoint."""
-
-import argparse
-
-import fairseq
-import torch
-
-from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "encoder.layer_norm_for_extract": "layer_norm_for_extract",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "quantizer.weight_proj": "quantizer.weight_proj",
-    "quantizer.vars": "quantizer.codevectors",
-    "project_q": "project_q",
-    "final_proj": "project_hid",
-    "w2v_encoder.proj": "lm_head",
-    "label_embs_concat": "label_embeddings_concat",
-    "mask_emb": "masked_spec_embed",
-    "spk_proj": "speaker_proj",
-}
-TOP_LEVEL_KEYS = [
-    "lm_head",
-    "quantizer.weight_proj",
-    "quantizer.codevectors",
-    "project_q",
-    "project_hid",
-    "label_embeddings_concat",
-    "speaker_proj",
-    "layer_norm_for_extract",
-]
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    if hf_shape != value.shape:
-        raise ValueError(
-            f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-            f" {value.shape} for {full_name}"
-        )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.unispeech_sat.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                mapped_key = "unispeech_sat." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    if "layer_norm_for_extract" in name and (".".join(name.split(".")[:-1]) != key):
-                        # special case since naming is very similar
-                        continue
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    elif "weight" in name:
-                        # TODO: don't match quantizer.weight_proj
-                        weight_type = "weight"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor[layer_id].layer_norm.bias.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-@torch.no_grad()
-def convert_unispeech_sat_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, config_path=None, dict_path=None, is_finetuned=True
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = UniSpeechSatConfig.from_pretrained(config_path)
-    else:
-        config = UniSpeechSatConfig()
-
-    dict_path = ""
-
-    if is_finetuned:
-        hf_wav2vec = UniSpeechSatForCTC(config)
-    else:
-        hf_wav2vec = UniSpeechSatForPreTraining(config)
-
-    model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-        [checkpoint_path], arg_overrides={"data": "/".join(dict_path.split("/")[:-1])}
-    )
-    model = model[0].eval()
-
-    recursively_load_weights(model, hf_wav2vec)
-
-    hf_wav2vec.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
-    )
-    args = parser.parse_args()
-    convert_unispeech_sat_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
-    )
diff --git a/src/transformers/models/univnet/convert_univnet.py b/src/transformers/models/univnet/convert_univnet.py
deleted file mode 100644
index 30520b7fa147..000000000000
--- a/src/transformers/models/univnet/convert_univnet.py
+++ /dev/null
@@ -1,162 +0,0 @@
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import torch
-
-from transformers import UnivNetConfig, UnivNetModel, logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.univnet")
-
-
-def get_kernel_predictor_key_mapping(config: UnivNetConfig, old_prefix: str = "", new_prefix: str = ""):
-    mapping = {}
-    # Initial conv layer
-    mapping[f"{old_prefix}.input_conv.0.weight_g"] = f"{new_prefix}.input_conv.weight_g"
-    mapping[f"{old_prefix}.input_conv.0.weight_v"] = f"{new_prefix}.input_conv.weight_v"
-    mapping[f"{old_prefix}.input_conv.0.bias"] = f"{new_prefix}.input_conv.bias"
-
-    # Kernel predictor resnet blocks
-    for i in range(config.kernel_predictor_num_blocks):
-        mapping[f"{old_prefix}.residual_convs.{i}.1.weight_g"] = f"{new_prefix}.resblocks.{i}.conv1.weight_g"
-        mapping[f"{old_prefix}.residual_convs.{i}.1.weight_v"] = f"{new_prefix}.resblocks.{i}.conv1.weight_v"
-        mapping[f"{old_prefix}.residual_convs.{i}.1.bias"] = f"{new_prefix}.resblocks.{i}.conv1.bias"
-
-        mapping[f"{old_prefix}.residual_convs.{i}.3.weight_g"] = f"{new_prefix}.resblocks.{i}.conv2.weight_g"
-        mapping[f"{old_prefix}.residual_convs.{i}.3.weight_v"] = f"{new_prefix}.resblocks.{i}.conv2.weight_v"
-        mapping[f"{old_prefix}.residual_convs.{i}.3.bias"] = f"{new_prefix}.resblocks.{i}.conv2.bias"
-
-    # Kernel output conv
-    mapping[f"{old_prefix}.kernel_conv.weight_g"] = f"{new_prefix}.kernel_conv.weight_g"
-    mapping[f"{old_prefix}.kernel_conv.weight_v"] = f"{new_prefix}.kernel_conv.weight_v"
-    mapping[f"{old_prefix}.kernel_conv.bias"] = f"{new_prefix}.kernel_conv.bias"
-
-    # Bias output conv
-    mapping[f"{old_prefix}.bias_conv.weight_g"] = f"{new_prefix}.bias_conv.weight_g"
-    mapping[f"{old_prefix}.bias_conv.weight_v"] = f"{new_prefix}.bias_conv.weight_v"
-    mapping[f"{old_prefix}.bias_conv.bias"] = f"{new_prefix}.bias_conv.bias"
-
-    return mapping
-
-
-def get_key_mapping(config: UnivNetConfig):
-    mapping = {}
-
-    # NOTE: inital conv layer keys are the same
-
-    # LVC Residual blocks
-    for i in range(len(config.resblock_stride_sizes)):
-        # LVCBlock initial convt layer
-        mapping[f"res_stack.{i}.convt_pre.1.weight_g"] = f"resblocks.{i}.convt_pre.weight_g"
-        mapping[f"res_stack.{i}.convt_pre.1.weight_v"] = f"resblocks.{i}.convt_pre.weight_v"
-        mapping[f"res_stack.{i}.convt_pre.1.bias"] = f"resblocks.{i}.convt_pre.bias"
-
-        # Kernel predictor
-        kernel_predictor_mapping = get_kernel_predictor_key_mapping(
-            config, old_prefix=f"res_stack.{i}.kernel_predictor", new_prefix=f"resblocks.{i}.kernel_predictor"
-        )
-        mapping.update(kernel_predictor_mapping)
-
-        # LVC Residual blocks
-        for j in range(len(config.resblock_dilation_sizes[i])):
-            mapping[f"res_stack.{i}.conv_blocks.{j}.1.weight_g"] = f"resblocks.{i}.resblocks.{j}.conv.weight_g"
-            mapping[f"res_stack.{i}.conv_blocks.{j}.1.weight_v"] = f"resblocks.{i}.resblocks.{j}.conv.weight_v"
-            mapping[f"res_stack.{i}.conv_blocks.{j}.1.bias"] = f"resblocks.{i}.resblocks.{j}.conv.bias"
-
-    # Output conv layer
-    mapping["conv_post.1.weight_g"] = "conv_post.weight_g"
-    mapping["conv_post.1.weight_v"] = "conv_post.weight_v"
-    mapping["conv_post.1.bias"] = "conv_post.bias"
-
-    return mapping
-
-
-def rename_state_dict(state_dict, keys_to_modify, keys_to_remove):
-    model_state_dict = {}
-    for key, value in state_dict.items():
-        if key in keys_to_remove:
-            continue
-
-        if key in keys_to_modify:
-            new_key = keys_to_modify[key]
-            model_state_dict[new_key] = value
-        else:
-            model_state_dict[key] = value
-    return model_state_dict
-
-
-def convert_univnet_checkpoint(
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    config_path=None,
-    repo_id=None,
-    safe_serialization=False,
-):
-    model_state_dict_base = torch.load(checkpoint_path, map_location="cpu")
-    # Get the generator's state dict
-    state_dict = model_state_dict_base["model_g"]
-
-    if config_path is not None:
-        config = UnivNetConfig.from_pretrained(config_path)
-    else:
-        config = UnivNetConfig()
-
-    keys_to_modify = get_key_mapping(config)
-    keys_to_remove = set()
-    hf_state_dict = rename_state_dict(state_dict, keys_to_modify, keys_to_remove)
-
-    model = UnivNetModel(config)
-    # Apply weight norm since the original checkpoint has weight norm applied
-    model.apply_weight_norm()
-    model.load_state_dict(hf_state_dict)
-    # Remove weight norm in preparation for inference
-    model.remove_weight_norm()
-
-    model.save_pretrained(pytorch_dump_folder_path, safe_serialization=safe_serialization)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        model.push_to_hub(repo_id)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-    parser.add_argument(
-        "--safe_serialization", action="store_true", help="Whether to save the model using `safetensors`."
-    )
-
-    args = parser.parse_args()
-
-    convert_univnet_checkpoint(
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.config_path,
-        args.push_to_hub,
-        args.safe_serialization,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/upernet/convert_convnext_upernet_to_pytorch.py b/src/transformers/models/upernet/convert_convnext_upernet_to_pytorch.py
deleted file mode 100644
index eeb3ab5fc993..000000000000
--- a/src/transformers/models/upernet/convert_convnext_upernet_to_pytorch.py
+++ /dev/null
@@ -1,214 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ConvNext + UperNet checkpoints from mmsegmentation."""
-
-import argparse
-import json
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import ConvNextConfig, SegformerImageProcessor, UperNetConfig, UperNetForSemanticSegmentation
-
-
-def get_upernet_config(model_name):
-    auxiliary_in_channels = 384
-    if "tiny" in model_name:
-        depths = [3, 3, 9, 3]
-        hidden_sizes = [96, 192, 384, 768]
-    if "small" in model_name:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [96, 192, 384, 768]
-    if "base" in model_name:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [128, 256, 512, 1024]
-        auxiliary_in_channels = 512
-    if "large" in model_name:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [192, 384, 768, 1536]
-        auxiliary_in_channels = 768
-    if "xlarge" in model_name:
-        depths = [3, 3, 27, 3]
-        hidden_sizes = [256, 512, 1024, 2048]
-        auxiliary_in_channels = 1024
-
-    # set label information
-    num_labels = 150
-    repo_id = "huggingface/label-files"
-    filename = "ade20k-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    label2id = {v: k for k, v in id2label.items()}
-
-    backbone_config = ConvNextConfig(
-        depths=depths, hidden_sizes=hidden_sizes, out_features=["stage1", "stage2", "stage3", "stage4"]
-    )
-    config = UperNetConfig(
-        backbone_config=backbone_config,
-        auxiliary_in_channels=auxiliary_in_channels,
-        num_labels=num_labels,
-        id2label=id2label,
-        label2id=label2id,
-    )
-
-    return config
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-
-    # fmt: off
-    # stem
-    rename_keys.append(("backbone.downsample_layers.0.0.weight", "backbone.embeddings.patch_embeddings.weight"))
-    rename_keys.append(("backbone.downsample_layers.0.0.bias", "backbone.embeddings.patch_embeddings.bias"))
-    rename_keys.append(("backbone.downsample_layers.0.1.weight", "backbone.embeddings.layernorm.weight"))
-    rename_keys.append(("backbone.downsample_layers.0.1.bias", "backbone.embeddings.layernorm.bias"))
-    # stages
-    for i in range(len(config.backbone_config.depths)):
-        for j in range(config.backbone_config.depths[i]):
-            rename_keys.append((f"backbone.stages.{i}.{j}.gamma", f"backbone.encoder.stages.{i}.layers.{j}.layer_scale_parameter"))
-            rename_keys.append((f"backbone.stages.{i}.{j}.depthwise_conv.weight", f"backbone.encoder.stages.{i}.layers.{j}.dwconv.weight"))
-            rename_keys.append((f"backbone.stages.{i}.{j}.depthwise_conv.bias", f"backbone.encoder.stages.{i}.layers.{j}.dwconv.bias"))
-            rename_keys.append((f"backbone.stages.{i}.{j}.norm.weight", f"backbone.encoder.stages.{i}.layers.{j}.layernorm.weight"))
-            rename_keys.append((f"backbone.stages.{i}.{j}.norm.bias", f"backbone.encoder.stages.{i}.layers.{j}.layernorm.bias"))
-            rename_keys.append((f"backbone.stages.{i}.{j}.pointwise_conv1.weight", f"backbone.encoder.stages.{i}.layers.{j}.pwconv1.weight"))
-            rename_keys.append((f"backbone.stages.{i}.{j}.pointwise_conv1.bias", f"backbone.encoder.stages.{i}.layers.{j}.pwconv1.bias"))
-            rename_keys.append((f"backbone.stages.{i}.{j}.pointwise_conv2.weight", f"backbone.encoder.stages.{i}.layers.{j}.pwconv2.weight"))
-            rename_keys.append((f"backbone.stages.{i}.{j}.pointwise_conv2.bias", f"backbone.encoder.stages.{i}.layers.{j}.pwconv2.bias"))
-        if i > 0:
-            rename_keys.append((f"backbone.downsample_layers.{i}.0.weight", f"backbone.encoder.stages.{i}.downsampling_layer.0.weight"))
-            rename_keys.append((f"backbone.downsample_layers.{i}.0.bias", f"backbone.encoder.stages.{i}.downsampling_layer.0.bias"))
-            rename_keys.append((f"backbone.downsample_layers.{i}.1.weight", f"backbone.encoder.stages.{i}.downsampling_layer.1.weight"))
-            rename_keys.append((f"backbone.downsample_layers.{i}.1.bias", f"backbone.encoder.stages.{i}.downsampling_layer.1.bias"))
-
-        rename_keys.append((f"backbone.norm{i}.weight", f"backbone.hidden_states_norms.stage{i+1}.weight"))
-        rename_keys.append((f"backbone.norm{i}.bias", f"backbone.hidden_states_norms.stage{i+1}.bias"))
-
-    # decode head
-    rename_keys.extend(
-        [
-            ("decode_head.conv_seg.weight", "decode_head.classifier.weight"),
-            ("decode_head.conv_seg.bias", "decode_head.classifier.bias"),
-            ("auxiliary_head.conv_seg.weight", "auxiliary_head.classifier.weight"),
-            ("auxiliary_head.conv_seg.bias", "auxiliary_head.classifier.bias"),
-        ]
-    )
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def convert_upernet_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub):
-    model_name_to_url = {
-        "upernet-convnext-tiny": "https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth",
-        "upernet-convnext-small": "https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth",
-        "upernet-convnext-base": "https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth",
-        "upernet-convnext-large": "https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth",
-        "upernet-convnext-xlarge": "https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth",
-    }
-    checkpoint_url = model_name_to_url[model_name]
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["state_dict"]
-
-    config = get_upernet_config(model_name)
-    model = UperNetForSemanticSegmentation(config)
-    model.eval()
-
-    # replace "bn" => "batch_norm"
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        if "bn" in key:
-            key = key.replace("bn", "batch_norm")
-        state_dict[key] = val
-
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-
-    model.load_state_dict(state_dict)
-
-    # verify on image
-    url = "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-
-    processor = SegformerImageProcessor()
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    with torch.no_grad():
-        outputs = model(pixel_values)
-
-    if model_name == "upernet-convnext-tiny":
-        expected_slice = torch.tensor(
-            [[-8.8110, -8.8110, -8.6521], [-8.8110, -8.8110, -8.6521], [-8.7746, -8.7746, -8.6130]]
-        )
-    elif model_name == "upernet-convnext-small":
-        expected_slice = torch.tensor(
-            [[-8.8236, -8.8236, -8.6771], [-8.8236, -8.8236, -8.6771], [-8.7638, -8.7638, -8.6240]]
-        )
-    elif model_name == "upernet-convnext-base":
-        expected_slice = torch.tensor(
-            [[-8.8558, -8.8558, -8.6905], [-8.8558, -8.8558, -8.6905], [-8.7669, -8.7669, -8.6021]]
-        )
-    elif model_name == "upernet-convnext-large":
-        expected_slice = torch.tensor(
-            [[-8.6660, -8.6660, -8.6210], [-8.6660, -8.6660, -8.6210], [-8.6310, -8.6310, -8.5964]]
-        )
-    elif model_name == "upernet-convnext-xlarge":
-        expected_slice = torch.tensor(
-            [[-8.4980, -8.4980, -8.3977], [-8.4980, -8.4980, -8.3977], [-8.4379, -8.4379, -8.3412]]
-        )
-    print("Logits:", outputs.logits[0, 0, :3, :3])
-    assert torch.allclose(outputs.logits[0, 0, :3, :3], expected_slice, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving processor to {pytorch_dump_folder_path}")
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and processor for {model_name} to hub")
-        model.push_to_hub(f"openmmlab/{model_name}")
-        processor.push_to_hub(f"openmmlab/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="upernet-convnext-tiny",
-        type=str,
-        choices=[f"upernet-convnext-{size}" for size in ["tiny", "small", "base", "large", "xlarge"]],
-        help="Name of the ConvNext UperNet model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/upernet/convert_swin_upernet_to_pytorch.py b/src/transformers/models/upernet/convert_swin_upernet_to_pytorch.py
deleted file mode 100644
index 9580af7c46a5..000000000000
--- a/src/transformers/models/upernet/convert_swin_upernet_to_pytorch.py
+++ /dev/null
@@ -1,297 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Swin Transformer + UperNet checkpoints from mmsegmentation.
-
-URL: https://github.com/open-mmlab/mmsegmentation/tree/master/configs/swin
-"""
-
-import argparse
-import json
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import SegformerImageProcessor, SwinConfig, UperNetConfig, UperNetForSemanticSegmentation
-
-
-def get_upernet_config(model_name):
-    auxiliary_in_channels = 384
-    window_size = 7
-    if "tiny" in model_name:
-        embed_dim = 96
-        depths = (2, 2, 6, 2)
-        num_heads = (3, 6, 12, 24)
-    elif "small" in model_name:
-        embed_dim = 96
-        depths = (2, 2, 18, 2)
-        num_heads = (3, 6, 12, 24)
-    elif "base" in model_name:
-        embed_dim = 128
-        depths = (2, 2, 18, 2)
-        num_heads = (4, 8, 16, 32)
-        window_size = 12
-        auxiliary_in_channels = 512
-    elif "large" in model_name:
-        embed_dim = 192
-        depths = (2, 2, 18, 2)
-        num_heads = (6, 12, 24, 48)
-        window_size = 12
-        auxiliary_in_channels = 768
-
-    # set label information
-    num_labels = 150
-    repo_id = "huggingface/label-files"
-    filename = "ade20k-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    label2id = {v: k for k, v in id2label.items()}
-
-    backbone_config = SwinConfig(
-        embed_dim=embed_dim,
-        depths=depths,
-        num_heads=num_heads,
-        window_size=window_size,
-        out_features=["stage1", "stage2", "stage3", "stage4"],
-    )
-    config = UperNetConfig(
-        backbone_config=backbone_config,
-        auxiliary_in_channels=auxiliary_in_channels,
-        num_labels=num_labels,
-        id2label=id2label,
-        label2id=label2id,
-    )
-
-    return config
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-
-    # fmt: off
-    # stem
-    rename_keys.append(("backbone.patch_embed.projection.weight", "backbone.embeddings.patch_embeddings.projection.weight"))
-    rename_keys.append(("backbone.patch_embed.projection.bias", "backbone.embeddings.patch_embeddings.projection.bias"))
-    rename_keys.append(("backbone.patch_embed.norm.weight", "backbone.embeddings.norm.weight"))
-    rename_keys.append(("backbone.patch_embed.norm.bias", "backbone.embeddings.norm.bias"))
-    # stages
-    for i in range(len(config.backbone_config.depths)):
-        for j in range(config.backbone_config.depths[i]):
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.norm1.weight", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.norm1.bias", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_bias_table", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_index", f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.weight", f"backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.bias", f"backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.norm2.weight", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.norm2.bias", f"backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.weight", f"backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.bias", f"backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.ffn.layers.1.weight", f"backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight"))
-            rename_keys.append((f"backbone.stages.{i}.blocks.{j}.ffn.layers.1.bias", f"backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias"))
-
-        if i < 3:
-            rename_keys.append((f"backbone.stages.{i}.downsample.reduction.weight", f"backbone.encoder.layers.{i}.downsample.reduction.weight"))
-            rename_keys.append((f"backbone.stages.{i}.downsample.norm.weight", f"backbone.encoder.layers.{i}.downsample.norm.weight"))
-            rename_keys.append((f"backbone.stages.{i}.downsample.norm.bias", f"backbone.encoder.layers.{i}.downsample.norm.bias"))
-        rename_keys.append((f"backbone.norm{i}.weight", f"backbone.hidden_states_norms.stage{i+1}.weight"))
-        rename_keys.append((f"backbone.norm{i}.bias", f"backbone.hidden_states_norms.stage{i+1}.bias"))
-
-    # decode head
-    rename_keys.extend(
-        [
-            ("decode_head.conv_seg.weight", "decode_head.classifier.weight"),
-            ("decode_head.conv_seg.bias", "decode_head.classifier.bias"),
-            ("auxiliary_head.conv_seg.weight", "auxiliary_head.classifier.weight"),
-            ("auxiliary_head.conv_seg.bias", "auxiliary_head.classifier.bias"),
-        ]
-    )
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, backbone_config):
-    num_features = [int(backbone_config.embed_dim * 2**i) for i in range(len(backbone_config.depths))]
-    for i in range(len(backbone_config.depths)):
-        dim = num_features[i]
-        for j in range(backbone_config.depths[i]):
-            # fmt: off
-            # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-            in_proj_weight = state_dict.pop(f"backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight")
-            in_proj_bias = state_dict.pop(f"backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.bias")
-            # next, add query, keys and values (in that order) to the state dict
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.query.weight"] = in_proj_weight[:dim, :]
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.query.bias"] = in_proj_bias[: dim]
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.key.weight"] = in_proj_weight[
-                dim : dim * 2, :
-            ]
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.key.bias"] = in_proj_bias[
-                dim : dim * 2
-            ]
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.value.weight"] = in_proj_weight[
-                -dim :, :
-            ]
-            state_dict[f"backbone.encoder.layers.{i}.blocks.{j}.attention.self.value.bias"] = in_proj_bias[-dim :]
-            # fmt: on
-
-
-def correct_unfold_reduction_order(x):
-    out_channel, in_channel = x.shape
-    x = x.reshape(out_channel, 4, in_channel // 4)
-    x = x[:, [0, 2, 1, 3], :].transpose(1, 2).reshape(out_channel, in_channel)
-    return x
-
-
-def reverse_correct_unfold_reduction_order(x):
-    out_channel, in_channel = x.shape
-    x = x.reshape(out_channel, in_channel // 4, 4)
-    x = x[:, :, [0, 2, 1, 3]].transpose(1, 2).reshape(out_channel, in_channel)
-
-    return x
-
-
-def correct_unfold_norm_order(x):
-    in_channel = x.shape[0]
-    x = x.reshape(4, in_channel // 4)
-    x = x[[0, 2, 1, 3], :].transpose(0, 1).reshape(in_channel)
-    return x
-
-
-# there was an incompatibility with this version, due to a new implementation of their downsampling operation using nn.Unfold.
-# was resolved as seen here:
-# https://github.com/open-mmlab/mmdetection/blob/31c84958f54287a8be2b99cbf87a6dcf12e57753/mmdet/models/utils/ckpt_convert.py#L96.
-def reverse_correct_unfold_norm_order(x):
-    in_channel = x.shape[0]
-    x = x.reshape(in_channel // 4, 4)
-    x = x[:, [0, 2, 1, 3]].transpose(0, 1).reshape(in_channel)
-    return x
-
-
-def convert_upernet_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub):
-    model_name_to_url = {
-        "upernet-swin-tiny": "https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth",
-        "upernet-swin-small": "https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth",
-        "upernet-swin-base": "https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth",
-        "upernet-swin-large": "https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k_20220318_091743-9ba68901.pth",
-    }
-    checkpoint_url = model_name_to_url[model_name]
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu", file_name=model_name)[
-        "state_dict"
-    ]
-
-    for name, param in state_dict.items():
-        print(name, param.shape)
-
-    config = get_upernet_config(model_name)
-    model = UperNetForSemanticSegmentation(config)
-    model.eval()
-
-    # replace "bn" => "batch_norm"
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        if "bn" in key:
-            key = key.replace("bn", "batch_norm")
-        state_dict[key] = val
-
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config.backbone_config)
-
-    # fix downsample parameters
-    for key, value in state_dict.items():
-        if "downsample" in key:
-            if "reduction" in key:
-                state_dict[key] = reverse_correct_unfold_reduction_order(value)
-            if "norm" in key:
-                state_dict[key] = reverse_correct_unfold_norm_order(value)
-
-    model.load_state_dict(state_dict)
-
-    # verify on image
-    url = "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-
-    processor = SegformerImageProcessor()
-    pixel_values = processor(image, return_tensors="pt").pixel_values
-
-    with torch.no_grad():
-        outputs = model(pixel_values)
-        logits = outputs.logits
-
-    print(logits.shape)
-    print("First values of logits:", logits[0, 0, :3, :3])
-    # assert values
-    if model_name == "upernet-swin-tiny":
-        expected_slice = torch.tensor(
-            [[-7.5958, -7.5958, -7.4302], [-7.5958, -7.5958, -7.4302], [-7.4797, -7.4797, -7.3068]]
-        )
-    elif model_name == "upernet-swin-small":
-        expected_slice = torch.tensor(
-            [[-7.1921, -7.1921, -6.9532], [-7.1921, -7.1921, -6.9532], [-7.0908, -7.0908, -6.8534]]
-        )
-    elif model_name == "upernet-swin-base":
-        expected_slice = torch.tensor(
-            [[-6.5851, -6.5851, -6.4330], [-6.5851, -6.5851, -6.4330], [-6.4763, -6.4763, -6.3254]]
-        )
-    elif model_name == "upernet-swin-large":
-        expected_slice = torch.tensor(
-            [[-7.5297, -7.5297, -7.3802], [-7.5297, -7.5297, -7.3802], [-7.4044, -7.4044, -7.2586]]
-        )
-    print("Logits:", outputs.logits[0, 0, :3, :3])
-    assert torch.allclose(outputs.logits[0, 0, :3, :3], expected_slice, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        print(f"Saving processor to {pytorch_dump_folder_path}")
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and processor for {model_name} to hub")
-        model.push_to_hub(f"openmmlab/{model_name}")
-        processor.push_to_hub(f"openmmlab/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="upernet-swin-tiny",
-        type=str,
-        choices=[f"upernet-swin-{size}" for size in ["tiny", "small", "base", "large"]],
-        help="Name of the Swin + UperNet model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/video_llava/convert_video_llava_weights_to_hf.py b/src/transformers/models/video_llava/convert_video_llava_weights_to_hf.py
deleted file mode 100644
index 4c07ca0a03a7..000000000000
--- a/src/transformers/models/video_llava/convert_video_llava_weights_to_hf.py
+++ /dev/null
@@ -1,159 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import (
-    AddedToken,
-    AutoConfig,
-    AutoTokenizer,
-    VideoLlavaConfig,
-    VideoLlavaForConditionalGeneration,
-    VideoLlavaImageProcessor,
-    VideoLlavaProcessor,
-)
-
-
-EPILOG_TXT = """Example:
-    python transformers/src/transformers/models/video_llava/convert_video_llava_weights_to_hf.py --text_model_id lmsys/vicuna-7b-v1.5 --vision_model_id openai/clip-vit-large-patch14 --output_hub_path org/video_llava-7b --old_state_dict_id LanguageBind/Video-LLaVA-7B
-
-Example for creating the old state dict file with Python:
-
-    import torch
-    from video_llava.model.language_model.video_llava import VideoLlavaForCausalLM
-
-    # load model
-    kwargs = {"device_map": "auto", "torch_dtype": torch.float16}
-    model = VideoLlavaForCausalLM.from_pretrained("LanguageBind/Video-LLaVA-7B-hf", low_cpu_mem_usage=True, **kwargs)
-
-    # load vision tower
-    model.get_vision_tower().load_model()
-
-    # Save state dict
-    torch.save(model.state_dict(), "tmp/hf_models/video_llava-7b/model_state_dict.bin")
-"""
-
-KEYS_TO_MODIFY_MAPPING = {
-    "model.video_tower.video_tower": "video_tower",
-    "model.image_tower.image_tower": "image_tower",
-    "model.mm_projector": "multi_modal_projector",
-    "model": "language_model.model",
-    "lm_head": "language_model.lm_head",
-    "video_tower": "video_tower.vision_model",
-    "image_tower": "image_tower.vision_model",
-    "multi_modal_projector.0": "multi_modal_projector.linear_1",
-    "multi_modal_projector.2": "multi_modal_projector.linear_2",
-}
-
-
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if key.endswith(".inv_freq"):
-            continue
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-
-        new_state_dict[key] = value
-    return new_state_dict
-
-
-def convert_video_llava_llama_to_hf(text_model_id, vision_model_id, output_hub_path, old_state_dict_id):
-    torch.set_default_dtype(torch.float16)
-    text_config = AutoConfig.from_pretrained(text_model_id)
-
-    tokenizer = AutoTokenizer.from_pretrained(text_model_id)
-    tokenizer.add_tokens(AddedToken("<image>", special=True, normalized=False), special_tokens=True)
-    tokenizer.add_tokens(AddedToken("<video>", special=True, normalized=False), special_tokens=True)
-    tokenizer.add_special_tokens({"pad_token": "<pad>"})
-    tokenizer.padding_side = "left"
-
-    image_processor = VideoLlavaImageProcessor.from_pretrained(vision_model_id)
-
-    processor = VideoLlavaProcessor(tokenizer=tokenizer, image_processor=image_processor)
-
-    config = VideoLlavaConfig(text_config=text_config)
-    config.pad_token_id = 32002
-
-    with torch.device("meta"):
-        model = VideoLlavaForConditionalGeneration(config)
-
-    model_state_dict = set(model.state_dict().keys())
-
-    # Pad to 64 for performance reasons
-    pad_shape = 64
-    state_dict_temp = "pytorch_model-0000{i}-of-00002.bin"
-    for shard in range(1, 3):
-        state_dict_path = hf_hub_download(old_state_dict_id, state_dict_temp.format(i=shard))
-        state_dict = torch.load(state_dict_path, map_location="cpu")
-        state_dict = convert_state_dict_to_hf(state_dict)
-        model.load_state_dict(state_dict, strict=False, assign=True)
-        model_state_dict -= set(state_dict.keys())
-
-    if len(model_state_dict) > 0:
-        raise RuntimeError(f"Missing keys in state dict: {model_state_dict}")
-
-    pre_expansion_embeddings = model.language_model.model.embed_tokens.weight.data
-    mu = torch.mean(pre_expansion_embeddings, dim=0).float()
-    n = pre_expansion_embeddings.size()[0]
-    sigma = ((pre_expansion_embeddings - mu).T @ (pre_expansion_embeddings - mu)) / n
-    dist = torch.distributions.multivariate_normal.MultivariateNormal(mu, covariance_matrix=1e-5 * sigma)
-
-    # We add an image and video token so we resize the model
-    model.resize_token_embeddings(config.text_config.vocab_size + 3, pad_shape)
-    model.language_model.model.embed_tokens.weight.data[32000:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.model.embed_tokens.weight.data[32000:].shape[0]))),
-        dim=0,
-    )
-    model.language_model.lm_head.weight.data[32000:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.lm_head.weight.data[32000:].shape[0]))),
-        dim=0,
-    )
-
-    model.push_to_hub(output_hub_path)
-    processor.push_to_hub(output_hub_path)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        epilog=EPILOG_TXT,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument(
-        "--text_model_id",
-        help="Hub location of the text model",
-    )
-    parser.add_argument(
-        "--vision_model_id",
-        help="Hub location of the vision model",
-    )
-    parser.add_argument(
-        "--output_hub_path",
-        help="Location on the hub of the converted model",
-    )
-    parser.add_argument(
-        "--old_state_dict_id",
-        help="Location on the hub of the raw state dict of the original model. The filename needs to be `model_state_dict.bin`",
-    )
-    args = parser.parse_args()
-    convert_video_llava_llama_to_hf(
-        args.text_model_id, args.vision_model_id, args.output_hub_path, args.old_state_dict_id
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/videomae/convert_videomae_to_pytorch.py b/src/transformers/models/videomae/convert_videomae_to_pytorch.py
deleted file mode 100644
index c98160a6bb82..000000000000
--- a/src/transformers/models/videomae/convert_videomae_to_pytorch.py
+++ /dev/null
@@ -1,324 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert VideoMAE checkpoints from the original repository: https://github.com/MCG-NJU/VideoMAE"""
-
-import argparse
-import json
-
-import gdown
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import (
-    VideoMAEConfig,
-    VideoMAEForPreTraining,
-    VideoMAEForVideoClassification,
-    VideoMAEImageProcessor,
-)
-
-
-def get_videomae_config(model_name):
-    config = VideoMAEConfig()
-
-    set_architecture_configs(model_name, config)
-
-    if "finetuned" not in model_name:
-        config.use_mean_pooling = False
-
-    if "finetuned" in model_name:
-        repo_id = "huggingface/label-files"
-        if "kinetics" in model_name:
-            config.num_labels = 400
-            filename = "kinetics400-id2label.json"
-        elif "ssv2" in model_name:
-            config.num_labels = 174
-            filename = "something-something-v2-id2label.json"
-        else:
-            raise ValueError("Model name should either contain 'kinetics' or 'ssv2' in case it's fine-tuned.")
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-def set_architecture_configs(model_name, config):
-    if "small" in model_name:
-        config.hidden_size = 384
-        config.intermediate_size = 1536
-        config.num_hidden_layers = 12
-        config.num_attention_heads = 16
-        config.decoder_num_hidden_layers = 12
-        config.decoder_num_attention_heads = 3
-        config.decoder_hidden_size = 192
-        config.decoder_intermediate_size = 768
-    elif "large" in model_name:
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-        config.decoder_num_hidden_layers = 12
-        config.decoder_num_attention_heads = 8
-        config.decoder_hidden_size = 512
-        config.decoder_intermediate_size = 2048
-    elif "huge" in model_name:
-        config.hidden_size = 1280
-        config.intermediate_size = 5120
-        config.num_hidden_layers = 32
-        config.num_attention_heads = 16
-        config.decoder_num_hidden_layers = 12
-        config.decoder_num_attention_heads = 8
-        config.decoder_hidden_size = 640
-        config.decoder_intermediate_size = 2560
-    elif "base" not in model_name:
-        raise ValueError('Model name should include either "small", "base", "large", or "huge"')
-
-
-def rename_key(name):
-    if "encoder." in name:
-        name = name.replace("encoder.", "")
-    if "cls_token" in name:
-        name = name.replace("cls_token", "videomae.embeddings.cls_token")
-    if "decoder_pos_embed" in name:
-        name = name.replace("decoder_pos_embed", "decoder.decoder_pos_embed")
-    if "pos_embed" in name and "decoder" not in name:
-        name = name.replace("pos_embed", "videomae.embeddings.position_embeddings")
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "videomae.embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "videomae.embeddings.norm")
-    if "decoder.blocks" in name:
-        name = name.replace("decoder.blocks", "decoder.decoder_layers")
-    if "blocks" in name:
-        name = name.replace("blocks", "videomae.encoder.layer")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name and "bias" not in name:
-        name = name.replace("attn", "attention.self")
-    if "attn" in name:
-        name = name.replace("attn", "attention.attention")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "decoder_embed" in name:
-        name = name.replace("decoder_embed", "decoder.decoder_embed")
-    if "decoder_norm" in name:
-        name = name.replace("decoder_norm", "decoder.decoder_norm")
-    if "decoder_pred" in name:
-        name = name.replace("decoder_pred", "decoder.decoder_pred")
-    if "norm.weight" in name and "decoder" not in name and "fc" not in name:
-        name = name.replace("norm.weight", "videomae.layernorm.weight")
-    if "norm.bias" in name and "decoder" not in name and "fc" not in name:
-        name = name.replace("norm.bias", "videomae.layernorm.bias")
-    if "head" in name and "decoder" not in name:
-        name = name.replace("head", "classifier")
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, config):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if key.startswith("encoder."):
-            key = key.replace("encoder.", "")
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            if key.startswith("decoder.blocks"):
-                dim = config.decoder_hidden_size
-                layer_num = int(key_split[2])
-                prefix = "decoder.decoder_layers."
-                if "weight" in key:
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.query.weight"] = val[:dim, :]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.key.weight"] = val[dim : dim * 2, :]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.value.weight"] = val[-dim:, :]
-            else:
-                dim = config.hidden_size
-                layer_num = int(key_split[1])
-                prefix = "videomae.encoder.layer."
-                if "weight" in key:
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.query.weight"] = val[:dim, :]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.key.weight"] = val[dim : dim * 2, :]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.value.weight"] = val[-dim:, :]
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-# We will verify our results on a video of eating spaghetti
-# Frame indices used: [164 168 172 176 181 185 189 193 198 202 206 210 215 219 223 227]
-def prepare_video():
-    file = hf_hub_download(
-        repo_id="hf-internal-testing/spaghetti-video", filename="eating_spaghetti.npy", repo_type="dataset"
-    )
-    video = np.load(file)
-    return list(video)
-
-
-def convert_videomae_checkpoint(checkpoint_url, pytorch_dump_folder_path, model_name, push_to_hub):
-    config = get_videomae_config(model_name)
-
-    if "finetuned" in model_name:
-        model = VideoMAEForVideoClassification(config)
-    else:
-        model = VideoMAEForPreTraining(config)
-
-    # download original checkpoint, hosted on Google Drive
-    output = "pytorch_model.bin"
-    gdown.cached_download(checkpoint_url, output, quiet=False)
-    files = torch.load(output, map_location="cpu")
-    if "model" in files:
-        state_dict = files["model"]
-    else:
-        state_dict = files["module"]
-    new_state_dict = convert_state_dict(state_dict, config)
-
-    model.load_state_dict(new_state_dict)
-    model.eval()
-
-    # verify model on basic input
-    image_processor = VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5], image_std=[0.5, 0.5, 0.5])
-    video = prepare_video()
-    inputs = image_processor(video, return_tensors="pt")
-
-    if "finetuned" not in model_name:
-        local_path = hf_hub_download(repo_id="hf-internal-testing/bool-masked-pos", filename="bool_masked_pos.pt")
-        inputs["bool_masked_pos"] = torch.load(local_path)
-
-    outputs = model(**inputs)
-    logits = outputs.logits
-
-    model_names = [
-        "videomae-small-finetuned-kinetics",
-        "videomae-small-finetuned-ssv2",
-        # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600)
-        "videomae-base-short",
-        "videomae-base-short-finetuned-kinetics",
-        "videomae-base",
-        "videomae-base-finetuned-kinetics",
-        "videomae-large",
-        "videomae-large-finetuned-kinetics",
-        "videomae-huge-finetuned-kinetics",
-        # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400)
-        "videomae-base-short-ssv2",
-        "videomae-base-short-finetuned-ssv2",
-        "videomae-base-ssv2",
-        "videomae-base-finetuned-ssv2",
-    ]
-
-    # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
-    if model_name == "videomae-small-finetuned-kinetics":
-        expected_shape = torch.Size([1, 400])
-        expected_slice = torch.tensor([-0.9291, -0.4061, -0.9307])
-    elif model_name == "videomae-small-finetuned-ssv2":
-        expected_shape = torch.Size([1, 174])
-        expected_slice = torch.tensor([0.2671, -0.4689, -0.8235])
-    elif model_name == "videomae-base":
-        expected_shape = torch.Size([1, 1408, 1536])
-        expected_slice = torch.tensor([[0.7739, 0.7968, 0.7089], [0.6701, 0.7487, 0.6209], [0.4287, 0.5158, 0.4773]])
-    elif model_name == "videomae-base-short":
-        expected_shape = torch.Size([1, 1408, 1536])
-        expected_slice = torch.tensor([[0.7994, 0.9612, 0.8508], [0.7401, 0.8958, 0.8302], [0.5862, 0.7468, 0.7325]])
-        # we verified the loss both for normalized and unnormalized targets for this one
-        expected_loss = torch.tensor([0.5142]) if config.norm_pix_loss else torch.tensor([0.6469])
-    elif model_name == "videomae-large":
-        expected_shape = torch.Size([1, 1408, 1536])
-        expected_slice = torch.tensor([[0.7149, 0.7997, 0.6966], [0.6768, 0.7869, 0.6948], [0.5139, 0.6221, 0.5605]])
-    elif model_name == "videomae-large-finetuned-kinetics":
-        expected_shape = torch.Size([1, 400])
-        expected_slice = torch.tensor([0.0771, 0.0011, -0.3625])
-    elif model_name == "videomae-huge-finetuned-kinetics":
-        expected_shape = torch.Size([1, 400])
-        expected_slice = torch.tensor([0.2433, 0.1632, -0.4894])
-    elif model_name == "videomae-base-short-finetuned-kinetics":
-        expected_shape = torch.Size([1, 400])
-        expected_slice = torch.tensor([0.6588, 0.0990, -0.2493])
-    elif model_name == "videomae-base-finetuned-kinetics":
-        expected_shape = torch.Size([1, 400])
-        expected_slice = torch.tensor([0.3669, -0.0688, -0.2421])
-    elif model_name == "videomae-base-short-ssv2":
-        expected_shape = torch.Size([1, 1408, 1536])
-        expected_slice = torch.tensor([[0.4712, 0.5296, 0.5786], [0.2278, 0.2729, 0.4026], [0.0352, 0.0730, 0.2506]])
-    elif model_name == "videomae-base-short-finetuned-ssv2":
-        expected_shape = torch.Size([1, 174])
-        expected_slice = torch.tensor([-0.0537, -0.1539, -0.3266])
-    elif model_name == "videomae-base-ssv2":
-        expected_shape = torch.Size([1, 1408, 1536])
-        expected_slice = torch.tensor([[0.8131, 0.8727, 0.8546], [0.7366, 0.9377, 0.8870], [0.5935, 0.8874, 0.8564]])
-    elif model_name == "videomae-base-finetuned-ssv2":
-        expected_shape = torch.Size([1, 174])
-        expected_slice = torch.tensor([0.1961, -0.8337, -0.6389])
-    else:
-        raise ValueError(f"Model name not supported. Should be one of {model_names}")
-
-    # verify logits
-    assert logits.shape == expected_shape
-    if "finetuned" in model_name:
-        assert torch.allclose(logits[0, :3], expected_slice, atol=1e-4)
-    else:
-        print("Logits:", logits[0, :3, :3])
-        assert torch.allclose(logits[0, :3, :3], expected_slice, atol=1e-4)
-    print("Logits ok!")
-
-    # verify loss, if applicable
-    if model_name == "videomae-base-short":
-        loss = outputs.loss
-        assert torch.allclose(loss, expected_loss, atol=1e-4)
-        print("Loss ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and image processor to {pytorch_dump_folder_path}")
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-        model.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing to the hub...")
-        model.push_to_hub(model_name, organization="nielsr")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4",
-        type=str,
-        help=(
-            "URL of the original PyTorch checkpoint (on Google Drive) you'd like to convert. Should be a direct"
-            " download link."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default="/Users/nielsrogge/Documents/VideoMAE/Test",
-        type=str,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument("--model_name", default="videomae-base", type=str, help="Name of the model.")
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)
diff --git a/src/transformers/models/vilt/convert_vilt_original_to_pytorch.py b/src/transformers/models/vilt/convert_vilt_original_to_pytorch.py
deleted file mode 100644
index 79b9f3ba03ab..000000000000
--- a/src/transformers/models/vilt/convert_vilt_original_to_pytorch.py
+++ /dev/null
@@ -1,299 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ViLT checkpoints from the original Github repository."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import (
-    BertTokenizer,
-    ViltConfig,
-    ViltForImageAndTextRetrieval,
-    ViltForImagesAndTextClassification,
-    ViltForMaskedLM,
-    ViltForQuestionAnswering,
-    ViltImageProcessor,
-    ViltProcessor,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, vqa_model=False, nlvr_model=False, irtr_model=False):
-    rename_keys = []
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"transformer.blocks.{i}.norm1.weight", f"vilt.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"transformer.blocks.{i}.norm1.bias", f"vilt.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append(
-            (f"transformer.blocks.{i}.attn.proj.weight", f"vilt.encoder.layer.{i}.attention.output.dense.weight")
-        )
-        rename_keys.append(
-            (f"transformer.blocks.{i}.attn.proj.bias", f"vilt.encoder.layer.{i}.attention.output.dense.bias")
-        )
-        rename_keys.append((f"transformer.blocks.{i}.norm2.weight", f"vilt.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"transformer.blocks.{i}.norm2.bias", f"vilt.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append(
-            (f"transformer.blocks.{i}.mlp.fc1.weight", f"vilt.encoder.layer.{i}.intermediate.dense.weight")
-        )
-        rename_keys.append((f"transformer.blocks.{i}.mlp.fc1.bias", f"vilt.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"transformer.blocks.{i}.mlp.fc2.weight", f"vilt.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"transformer.blocks.{i}.mlp.fc2.bias", f"vilt.encoder.layer.{i}.output.dense.bias"))
-
-    # embeddings
-    rename_keys.extend(
-        [
-            # text embeddings
-            ("text_embeddings.word_embeddings.weight", "vilt.embeddings.text_embeddings.word_embeddings.weight"),
-            (
-                "text_embeddings.position_embeddings.weight",
-                "vilt.embeddings.text_embeddings.position_embeddings.weight",
-            ),
-            ("text_embeddings.position_ids", "vilt.embeddings.text_embeddings.position_ids"),
-            (
-                "text_embeddings.token_type_embeddings.weight",
-                "vilt.embeddings.text_embeddings.token_type_embeddings.weight",
-            ),
-            ("text_embeddings.LayerNorm.weight", "vilt.embeddings.text_embeddings.LayerNorm.weight"),
-            ("text_embeddings.LayerNorm.bias", "vilt.embeddings.text_embeddings.LayerNorm.bias"),
-            # patch embeddings
-            ("transformer.cls_token", "vilt.embeddings.cls_token"),
-            ("transformer.patch_embed.proj.weight", "vilt.embeddings.patch_embeddings.projection.weight"),
-            ("transformer.patch_embed.proj.bias", "vilt.embeddings.patch_embeddings.projection.bias"),
-            ("transformer.pos_embed", "vilt.embeddings.position_embeddings"),
-            # token type embeddings
-            ("token_type_embeddings.weight", "vilt.embeddings.token_type_embeddings.weight"),
-        ]
-    )
-
-    # final layernorm + pooler
-    rename_keys.extend(
-        [
-            ("transformer.norm.weight", "vilt.layernorm.weight"),
-            ("transformer.norm.bias", "vilt.layernorm.bias"),
-            ("pooler.dense.weight", "vilt.pooler.dense.weight"),
-            ("pooler.dense.bias", "vilt.pooler.dense.bias"),
-        ]
-    )
-
-    # classifier head(s)
-    if vqa_model:
-        # classification head
-        rename_keys.extend(
-            [
-                ("vqa_classifier.0.weight", "classifier.0.weight"),
-                ("vqa_classifier.0.bias", "classifier.0.bias"),
-                ("vqa_classifier.1.weight", "classifier.1.weight"),
-                ("vqa_classifier.1.bias", "classifier.1.bias"),
-                ("vqa_classifier.3.weight", "classifier.3.weight"),
-                ("vqa_classifier.3.bias", "classifier.3.bias"),
-            ]
-        )
-    elif nlvr_model:
-        # classification head
-        rename_keys.extend(
-            [
-                ("nlvr2_classifier.0.weight", "classifier.0.weight"),
-                ("nlvr2_classifier.0.bias", "classifier.0.bias"),
-                ("nlvr2_classifier.1.weight", "classifier.1.weight"),
-                ("nlvr2_classifier.1.bias", "classifier.1.bias"),
-                ("nlvr2_classifier.3.weight", "classifier.3.weight"),
-                ("nlvr2_classifier.3.bias", "classifier.3.bias"),
-            ]
-        )
-    else:
-        pass
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    for i in range(config.num_hidden_layers):
-        prefix = "vilt."
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"transformer.blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"transformer.blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-def remove_classification_head_(state_dict):
-    ignore_keys = ["head.weight", "head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-@torch.no_grad()
-def convert_vilt_checkpoint(checkpoint_url, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our ViLT structure.
-    """
-
-    # define configuration and initialize HuggingFace model
-    config = ViltConfig(image_size=384, patch_size=32, tie_word_embeddings=False)
-    mlm_model = False
-    vqa_model = False
-    nlvr_model = False
-    irtr_model = False
-    if "vqa" in checkpoint_url:
-        vqa_model = True
-        config.num_labels = 3129
-        repo_id = "huggingface/label-files"
-        filename = "vqa2-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-        model = ViltForQuestionAnswering(config)
-    elif "nlvr" in checkpoint_url:
-        nlvr_model = True
-        config.num_labels = 2
-        config.id2label = {0: "False", 1: "True"}
-        config.label2id = {v: k for k, v in config.id2label.items()}
-        config.modality_type_vocab_size = 3
-        model = ViltForImagesAndTextClassification(config)
-    elif "irtr" in checkpoint_url:
-        irtr_model = True
-        model = ViltForImageAndTextRetrieval(config)
-    elif "mlm_itm" in checkpoint_url:
-        mlm_model = True
-        model = ViltForMaskedLM(config)
-    else:
-        raise ValueError("Unknown model type")
-
-    # load state_dict of original model, remove and rename some keys
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["state_dict"]
-    rename_keys = create_rename_keys(config, vqa_model, nlvr_model, irtr_model)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config)
-    if mlm_model or irtr_model:
-        ignore_keys = ["itm_score.fc.weight", "itm_score.fc.bias"]
-        for k in ignore_keys:
-            state_dict.pop(k, None)
-
-    # load state dict into HuggingFace model
-    model.eval()
-    if mlm_model:
-        missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-        assert missing_keys == ["mlm_score.decoder.bias"]
-    else:
-        model.load_state_dict(state_dict)
-
-    # Define processor
-    image_processor = ViltImageProcessor(size=384)
-    tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
-    processor = ViltProcessor(image_processor, tokenizer)
-
-    # Forward pass on example inputs (image + text)
-    if nlvr_model:
-        image1 = Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg", stream=True).raw)
-        image2 = Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg", stream=True).raw)
-        text = (
-            "The left image contains twice the number of dogs as the right image, and at least two dogs in total are"
-            " standing."
-        )
-        encoding_1 = processor(image1, text, return_tensors="pt")
-        encoding_2 = processor(image2, text, return_tensors="pt")
-        outputs = model(
-            input_ids=encoding_1.input_ids,
-            pixel_values=encoding_1.pixel_values,
-            pixel_values_2=encoding_2.pixel_values,
-        )
-    else:
-        image = Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw)
-        if mlm_model:
-            text = "a bunch of [MASK] laying on a [MASK]."
-        else:
-            text = "How many cats are there?"
-        encoding = processor(image, text, return_tensors="pt")
-        outputs = model(**encoding)
-
-    # Verify outputs
-    if mlm_model:
-        expected_shape = torch.Size([1, 11, 30522])
-        expected_slice = torch.tensor([-12.5061, -12.5123, -12.5174])
-        assert outputs.logits.shape == expected_shape
-        assert torch.allclose(outputs.logits[0, 0, :3], expected_slice, atol=1e-4)
-
-        # verify masked token prediction equals "cats"
-        predicted_id = outputs.logits[0, 4, :].argmax(-1).item()
-        assert tokenizer.decode([predicted_id]) == "cats"
-    elif vqa_model:
-        expected_shape = torch.Size([1, 3129])
-        expected_slice = torch.tensor([-15.9495, -18.1472, -10.3041])
-        assert torch.allclose(outputs.logits[0, :3], expected_slice, atol=1e-4)
-        assert outputs.logits.shape == expected_shape
-        assert torch.allclose(outputs.logits[0, 0, :3], expected_slice, atol=1e-4)
-
-        # verify vqa prediction equals "2"
-        predicted_idx = outputs.logits.argmax(-1).item()
-        assert model.config.id2label[predicted_idx] == "2"
-    elif nlvr_model:
-        expected_shape = torch.Size([1, 2])
-        expected_slice = torch.tensor([-2.8721, 2.1291])
-        assert torch.allclose(outputs.logits[0, :3], expected_slice, atol=1e-4)
-        assert outputs.logits.shape == expected_shape
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model and processor to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt",
-        type=str,
-        help="URL of the checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/vipllava/convert_vipllava_weights_to_hf.py b/src/transformers/models/vipllava/convert_vipllava_weights_to_hf.py
deleted file mode 100644
index 2914cfdfcd4b..000000000000
--- a/src/transformers/models/vipllava/convert_vipllava_weights_to_hf.py
+++ /dev/null
@@ -1,132 +0,0 @@
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import argparse
-
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import (
-    AddedToken,
-    AutoConfig,
-    AutoTokenizer,
-    CLIPImageProcessor,
-    LlavaProcessor,
-    VipLlavaConfig,
-    VipLlavaForConditionalGeneration,
-)
-
-
-KEYS_TO_MODIFY_MAPPING = {
-    "model.vision_tower.": "",
-    "model.mm_projector": "multi_modal_projector",
-    "model": "model.model",
-    "vision_model.model": "vision_model",
-    "lm_head": "language_model.lm_head",
-    "model.model": "language_model.model",
-    "multi_modal_projector.0": "multi_modal_projector.linear_1",
-    "multi_modal_projector.2": "multi_modal_projector.linear_2",
-    "final_linear.0": "linear_1",
-    "final_linear.2": "linear_2",
-    "multi_modal_projector.clip_layernorm": "multi_modal_projector.projector_layernorm",
-}
-
-
-# Copied from transformers.models.llava.convert_llava_weights_to_hf.convert_state_dict_to_hf
-def convert_state_dict_to_hf(state_dict):
-    new_state_dict = {}
-    for key, value in state_dict.items():
-        if key.endswith(".inv_freq"):
-            continue
-        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
-            if key_to_modify in key:
-                key = key.replace(key_to_modify, new_key)
-        new_state_dict[key] = value
-    return new_state_dict
-
-
-def convert_vipllava_llama_to_hf(text_model_id, vision_model_id, output_hub_path, old_state_dict_id):
-    torch.set_default_dtype(torch.float16)
-    text_config = AutoConfig.from_pretrained(text_model_id)
-
-    tokenizer = AutoTokenizer.from_pretrained(text_model_id)
-    tokenizer.add_tokens(AddedToken("<image>", special=True, normalized=False), special_tokens=True)
-    tokenizer.add_special_tokens({"pad_token": "<pad>"})
-
-    image_processor = CLIPImageProcessor.from_pretrained(vision_model_id)
-
-    processor = LlavaProcessor(tokenizer=tokenizer, image_processor=image_processor)
-
-    config = VipLlavaConfig(text_config=text_config)
-    config.pad_token_id = 32001
-
-    with torch.device("meta"):
-        model = VipLlavaForConditionalGeneration(config)
-
-    # Pad to 64 for performance reasons
-    pad_shape = 64
-
-    state_dict_path = hf_hub_download(old_state_dict_id, "model_state_dict_7b.bin")
-
-    state_dict = torch.load(state_dict_path, map_location="cpu")
-    state_dict = convert_state_dict_to_hf(state_dict)
-
-    model.load_state_dict(state_dict, strict=True, assign=True)
-
-    pre_expansion_embeddings = model.language_model.model.embed_tokens.weight.data
-    mu = torch.mean(pre_expansion_embeddings, dim=0).float()
-    n = pre_expansion_embeddings.size()[0]
-    sigma = ((pre_expansion_embeddings - mu).T @ (pre_expansion_embeddings - mu)) / n
-    dist = torch.distributions.multivariate_normal.MultivariateNormal(mu, covariance_matrix=1e-5 * sigma)
-
-    # We add an image token so we resize the model
-    model.resize_token_embeddings(config.text_config.vocab_size + 2, pad_shape)
-    model.language_model.model.embed_tokens.weight.data[32000:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.model.embed_tokens.weight.data[32000:].shape[0]))),
-        dim=0,
-    )
-    model.language_model.lm_head.weight.data[32000:] = torch.stack(
-        tuple((dist.sample() for _ in range(model.language_model.lm_head.weight.data[32000:].shape[0]))),
-        dim=0,
-    )
-
-    model.push_to_hub(output_hub_path)
-    processor.push_to_hub(output_hub_path)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--text_model_id",
-        help="Hub location of the text model",
-    )
-    parser.add_argument(
-        "--vision_model_id",
-        help="Hub location of the vision model",
-    )
-    parser.add_argument(
-        "--output_hub_path",
-        help="Location on the hub of the converted model",
-    )
-    parser.add_argument(
-        "--old_state_dict_id",
-        help="Location on the hub of the raw state dict of the original model. The filename needs to be `model_state_dict.bin`",
-    )
-    args = parser.parse_args()
-    convert_vipllava_llama_to_hf(
-        args.text_model_id, args.vision_model_id, args.output_hub_path, args.old_state_dict_id
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/visual_bert/convert_visual_bert_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/visual_bert/convert_visual_bert_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 597335394158..000000000000
--- a/src/transformers/models/visual_bert/convert_visual_bert_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,149 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert VisualBert checkpoint."""
-
-import argparse
-from collections import OrderedDict
-from pathlib import Path
-
-import torch
-
-from transformers import (
-    VisualBertConfig,
-    VisualBertForMultipleChoice,
-    VisualBertForPreTraining,
-    VisualBertForQuestionAnswering,
-    VisualBertForVisualReasoning,
-)
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-rename_keys_prefix = [
-    ("bert.bert", "visual_bert"),
-    ("bert.cls", "cls"),
-    ("bert.classifier", "cls"),
-    ("token_type_embeddings_visual", "visual_token_type_embeddings"),
-    ("position_embeddings_visual", "visual_position_embeddings"),
-    ("projection", "visual_projection"),
-]
-
-ACCEPTABLE_CHECKPOINTS = [
-    "nlvr2_coco_pre_trained.th",
-    "nlvr2_fine_tuned.th",
-    "nlvr2_pre_trained.th",
-    "vcr_coco_pre_train.th",
-    "vcr_fine_tune.th",
-    "vcr_pre_train.th",
-    "vqa_coco_pre_trained.th",
-    "vqa_fine_tuned.th",
-    "vqa_pre_trained.th",
-]
-
-
-def load_state_dict(checkpoint_path):
-    sd = torch.load(checkpoint_path, map_location="cpu")
-    return sd
-
-
-def get_new_dict(d, config, rename_keys_prefix=rename_keys_prefix):
-    new_d = OrderedDict()
-    new_d["visual_bert.embeddings.position_ids"] = torch.arange(config.max_position_embeddings).expand((1, -1))
-    # detector_d = OrderedDict()
-    for key in d:
-        if "detector" in key:
-            # detector_d[key.replace('detector.','')] = d[key]
-            continue
-        new_key = key
-        for name_pair in rename_keys_prefix:
-            new_key = new_key.replace(name_pair[0], name_pair[1])
-        new_d[new_key] = d[key]
-        if key == "bert.cls.predictions.decoder.weight":
-            # Old bert code didn't have `decoder.bias`, but was added separately
-            new_d["cls.predictions.decoder.bias"] = new_d["cls.predictions.bias"]
-    return new_d
-
-
-@torch.no_grad()
-def convert_visual_bert_checkpoint(checkpoint_path, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our VisualBERT structure.
-    """
-
-    assert checkpoint_path.split("/")[-1] in ACCEPTABLE_CHECKPOINTS, (
-        f"The checkpoint provided must be in {ACCEPTABLE_CHECKPOINTS}."
-    )
-
-    # Get Config
-    if "pre" in checkpoint_path:
-        model_type = "pretraining"
-        if "vcr" in checkpoint_path:
-            config_params = {"visual_embedding_dim": 512}
-        elif "vqa_advanced" in checkpoint_path:
-            config_params = {"visual_embedding_dim": 2048}
-        elif "vqa" in checkpoint_path:
-            config_params = {"visual_embedding_dim": 2048}
-        elif "nlvr" in checkpoint_path:
-            config_params = {"visual_embedding_dim": 1024}
-        else:
-            raise NotImplementedError(f"No implementation found for `{checkpoint_path}`.")
-    else:
-        if "vcr" in checkpoint_path:
-            config_params = {"visual_embedding_dim": 512}
-            model_type = "multichoice"
-        elif "vqa_advanced" in checkpoint_path:
-            config_params = {"visual_embedding_dim": 2048}
-            model_type = "vqa_advanced"
-        elif "vqa" in checkpoint_path:
-            config_params = {"visual_embedding_dim": 2048, "num_labels": 3129}
-            model_type = "vqa"
-        elif "nlvr" in checkpoint_path:
-            config_params = {
-                "visual_embedding_dim": 1024,
-                "num_labels": 2,
-            }
-            model_type = "nlvr"
-
-    config = VisualBertConfig(**config_params)
-
-    # Load State Dict
-    state_dict = load_state_dict(checkpoint_path)
-
-    new_state_dict = get_new_dict(state_dict, config)
-
-    if model_type == "pretraining":
-        model = VisualBertForPreTraining(config)
-    elif model_type == "vqa":
-        model = VisualBertForQuestionAnswering(config)
-    elif model_type == "nlvr":
-        model = VisualBertForVisualReasoning(config)
-    elif model_type == "multichoice":
-        model = VisualBertForMultipleChoice(config)
-
-    model.load_state_dict(new_state_dict)
-    # Save Checkpoints
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("orig_checkpoint_path", type=str, help="A path to .th on local filesystem.")
-    parser.add_argument("pytorch_dump_folder_path", type=str, help="Path to the output PyTorch model.")
-    args = parser.parse_args()
-    convert_visual_bert_checkpoint(args.orig_checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/vit/convert_dino_to_pytorch.py b/src/transformers/models/vit/convert_dino_to_pytorch.py
deleted file mode 100644
index 8608da8eb411..000000000000
--- a/src/transformers/models/vit/convert_dino_to_pytorch.py
+++ /dev/null
@@ -1,218 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ViT checkpoints trained with the DINO method."""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, base_model=False):
-    rename_keys = []
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"blocks.{i}.norm1.weight", f"vit.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"blocks.{i}.norm1.bias", f"vit.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append((f"blocks.{i}.attn.proj.weight", f"vit.encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.attn.proj.bias", f"vit.encoder.layer.{i}.attention.output.dense.bias"))
-        rename_keys.append((f"blocks.{i}.norm2.weight", f"vit.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"blocks.{i}.norm2.bias", f"vit.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"vit.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"vit.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"vit.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"vit.encoder.layer.{i}.output.dense.bias"))
-
-    # projection layer + position embeddings
-    rename_keys.extend(
-        [
-            ("cls_token", "vit.embeddings.cls_token"),
-            ("patch_embed.proj.weight", "vit.embeddings.patch_embeddings.projection.weight"),
-            ("patch_embed.proj.bias", "vit.embeddings.patch_embeddings.projection.bias"),
-            ("pos_embed", "vit.embeddings.position_embeddings"),
-        ]
-    )
-
-    if base_model:
-        # layernorm + pooler
-        rename_keys.extend(
-            [
-                ("norm.weight", "layernorm.weight"),
-                ("norm.bias", "layernorm.bias"),
-            ]
-        )
-
-        # if just the base model, we should remove "vit" from all keys that start with "vit"
-        rename_keys = [(pair[0], pair[1][4:]) if pair[1].startswith("vit") else pair for pair in rename_keys]
-    else:
-        # layernorm + classification head
-        rename_keys.extend(
-            [
-                ("norm.weight", "vit.layernorm.weight"),
-                ("norm.bias", "vit.layernorm.bias"),
-                ("head.weight", "classifier.weight"),
-                ("head.bias", "classifier.bias"),
-            ]
-        )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, base_model=False):
-    for i in range(config.num_hidden_layers):
-        if base_model:
-            prefix = ""
-        else:
-            prefix = "vit."
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-def remove_classification_head_(state_dict):
-    ignore_keys = ["head.weight", "head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_vit_checkpoint(model_name, pytorch_dump_folder_path, base_model=True):
-    """
-    Copy/paste/tweak model's weights to our ViT structure.
-    """
-
-    # define default ViT configuration
-    config = ViTConfig()
-    # patch_size
-    if model_name[-1] == "8":
-        config.patch_size = 8
-    # set labels if required
-    if not base_model:
-        config.num_labels = 1000
-        repo_id = "huggingface/label-files"
-        filename = "imagenet-1k-id2label.json"
-        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-        id2label = {int(k): v for k, v in id2label.items()}
-        config.id2label = id2label
-        config.label2id = {v: k for k, v in id2label.items()}
-    # size of the architecture
-    if model_name in ["dino_vits8", "dino_vits16"]:
-        config.hidden_size = 384
-        config.intermediate_size = 1536
-        config.num_hidden_layers = 12
-        config.num_attention_heads = 6
-
-    # load original model from torch hub
-    original_model = torch.hub.load("facebookresearch/dino:main", model_name)
-    original_model.eval()
-
-    # load state_dict of original model, remove and rename some keys
-    state_dict = original_model.state_dict()
-    if base_model:
-        remove_classification_head_(state_dict)
-    rename_keys = create_rename_keys(config, base_model=base_model)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config, base_model)
-
-    # load HuggingFace model
-    if base_model:
-        model = ViTModel(config, add_pooling_layer=False).eval()
-    else:
-        model = ViTForImageClassification(config).eval()
-    model.load_state_dict(state_dict)
-
-    # Check outputs on an image, prepared by ViTImageProcessor
-    image_processor = ViTImageProcessor()
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-    outputs = model(pixel_values)
-
-    if base_model:
-        final_hidden_state_cls_token = original_model(pixel_values)
-        assert torch.allclose(final_hidden_state_cls_token, outputs.last_hidden_state[:, 0, :], atol=1e-1)
-    else:
-        logits = original_model(pixel_values)
-        assert logits.shape == outputs.logits.shape
-        assert torch.allclose(logits, outputs.logits, atol=1e-3)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="dino_vitb16",
-        type=str,
-        help="Name of the model trained with DINO you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--base_model",
-        action="store_true",
-        help="Whether to only convert the base model (no projection head weights).",
-    )
-
-    parser.set_defaults(base_model=True)
-    args = parser.parse_args()
-    convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)
diff --git a/src/transformers/models/vit/convert_vit_timm_to_pytorch.py b/src/transformers/models/vit/convert_vit_timm_to_pytorch.py
deleted file mode 100644
index 7892842f8dc1..000000000000
--- a/src/transformers/models/vit/convert_vit_timm_to_pytorch.py
+++ /dev/null
@@ -1,254 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ViT and non-distilled DeiT checkpoints from the timm library."""
-
-import argparse
-from pathlib import Path
-
-import requests
-import timm
-import torch
-from PIL import Image
-from timm.data import ImageNetInfo, infer_imagenet_subset
-
-from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, base_model=False):
-    rename_keys = []
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"blocks.{i}.norm1.weight", f"vit.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"blocks.{i}.norm1.bias", f"vit.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append((f"blocks.{i}.attn.proj.weight", f"vit.encoder.layer.{i}.attention.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.attn.proj.bias", f"vit.encoder.layer.{i}.attention.output.dense.bias"))
-        rename_keys.append((f"blocks.{i}.norm2.weight", f"vit.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"blocks.{i}.norm2.bias", f"vit.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"vit.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"vit.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"vit.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"vit.encoder.layer.{i}.output.dense.bias"))
-
-    # projection layer + position embeddings
-    rename_keys.extend(
-        [
-            ("cls_token", "vit.embeddings.cls_token"),
-            ("patch_embed.proj.weight", "vit.embeddings.patch_embeddings.projection.weight"),
-            ("patch_embed.proj.bias", "vit.embeddings.patch_embeddings.projection.bias"),
-            ("pos_embed", "vit.embeddings.position_embeddings"),
-        ]
-    )
-
-    if base_model:
-        # layernorm
-        rename_keys.extend(
-            [
-                ("norm.weight", "layernorm.weight"),
-                ("norm.bias", "layernorm.bias"),
-            ]
-        )
-
-        # if just the base model, we should remove "vit" from all keys that start with "vit"
-        rename_keys = [(pair[0], pair[1][4:]) if pair[1].startswith("vit") else pair for pair in rename_keys]
-    else:
-        # layernorm + classification head
-        rename_keys.extend(
-            [
-                ("norm.weight", "vit.layernorm.weight"),
-                ("norm.bias", "vit.layernorm.bias"),
-                ("head.weight", "classifier.weight"),
-                ("head.bias", "classifier.bias"),
-            ]
-        )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, base_model=False):
-    for i in range(config.num_hidden_layers):
-        if base_model:
-            prefix = ""
-        else:
-            prefix = "vit."
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-def remove_classification_head_(state_dict):
-    ignore_keys = ["head.weight", "head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-# We will verify our results on an image of cute cats
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_vit_checkpoint(vit_name, pytorch_dump_folder_path):
-    """
-    Copy/paste/tweak model's weights to our ViT structure.
-    """
-
-    # define default ViT configuration
-    config = ViTConfig()
-    base_model = False
-
-    # load original model from timm
-    timm_model = timm.create_model(vit_name, pretrained=True)
-    timm_model.eval()
-
-    # detect unsupported ViT models in transformers
-    # fc_norm is present
-    if not isinstance(getattr(timm_model, "fc_norm", None), torch.nn.Identity):
-        raise ValueError(f"{vit_name} is not supported in transformers because of the presence of fc_norm.")
-
-    # use of global average pooling in combination (or without) class token
-    if getattr(timm_model, "global_pool", None) == "avg":
-        raise ValueError(f"{vit_name} is not supported in transformers because of use of global average pooling.")
-
-    # CLIP style vit with norm_pre layer present
-    if "clip" in vit_name and not isinstance(getattr(timm_model, "norm_pre", None), torch.nn.Identity):
-        raise ValueError(
-            f"{vit_name} is not supported in transformers because it's a CLIP style ViT with norm_pre layer."
-        )
-
-    # SigLIP style vit with attn_pool layer present
-    if "siglip" in vit_name and getattr(timm_model, "global_pool", None) == "map":
-        raise ValueError(
-            f"{vit_name} is not supported in transformers because it's a SigLIP style ViT with attn_pool."
-        )
-
-    # use of layer scale in ViT model blocks
-    if not isinstance(getattr(timm_model.blocks[0], "ls1", None), torch.nn.Identity) or not isinstance(
-        getattr(timm_model.blocks[0], "ls2", None), torch.nn.Identity
-    ):
-        raise ValueError(f"{vit_name} is not supported in transformers because it uses a layer scale in its blocks.")
-
-    # Hybrid ResNet-ViTs
-    if not isinstance(timm_model.patch_embed, timm.layers.PatchEmbed):
-        raise ValueError(f"{vit_name} is not supported in transformers because it is a hybrid ResNet-ViT.")
-
-    # get patch size and image size from the patch embedding submodule
-    config.patch_size = timm_model.patch_embed.patch_size[0]
-    config.image_size = timm_model.patch_embed.img_size[0]
-
-    # retrieve architecture-specific parameters from the timm model
-    config.hidden_size = timm_model.embed_dim
-    config.intermediate_size = timm_model.blocks[0].mlp.fc1.out_features
-    config.num_hidden_layers = len(timm_model.blocks)
-    config.num_attention_heads = timm_model.blocks[0].attn.num_heads
-
-    # check whether the model has a classification head or not
-    if timm_model.num_classes != 0:
-        config.num_labels = timm_model.num_classes
-        # infer ImageNet subset from timm model
-        imagenet_subset = infer_imagenet_subset(timm_model)
-        dataset_info = ImageNetInfo(imagenet_subset)
-        config.id2label = {i: dataset_info.index_to_label_name(i) for i in range(dataset_info.num_classes())}
-        config.label2id = {v: k for k, v in config.id2label.items()}
-    else:
-        print(f"{vit_name} is going to be converted as a feature extractor only.")
-        base_model = True
-
-    # load state_dict of original model
-    state_dict = timm_model.state_dict()
-
-    # remove and rename some keys in the state dict
-    if base_model:
-        remove_classification_head_(state_dict)
-    rename_keys = create_rename_keys(config, base_model)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config, base_model)
-
-    # load HuggingFace model
-    if base_model:
-        model = ViTModel(config, add_pooling_layer=False).eval()
-    else:
-        model = ViTForImageClassification(config).eval()
-    model.load_state_dict(state_dict)
-
-    # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor
-    if "deit" in vit_name:
-        image_processor = DeiTImageProcessor(size=config.image_size)
-    else:
-        image_processor = ViTImageProcessor(size=config.image_size)
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    pixel_values = encoding["pixel_values"]
-    outputs = model(pixel_values)
-
-    if base_model:
-        timm_pooled_output = timm_model.forward_features(pixel_values)
-        assert timm_pooled_output.shape == outputs.last_hidden_state.shape
-        assert torch.allclose(timm_pooled_output, outputs.last_hidden_state, atol=1e-1)
-    else:
-        timm_logits = timm_model(pixel_values)
-        assert timm_logits.shape == outputs.logits.shape
-        assert torch.allclose(timm_logits, outputs.logits, atol=1e-3)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {vit_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--vit_name",
-        default="vit_base_patch16_224",
-        type=str,
-        help="Name of the ViT timm model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/vit_mae/convert_vit_mae_to_pytorch.py b/src/transformers/models/vit_mae/convert_vit_mae_to_pytorch.py
deleted file mode 100644
index 47e77593f6fd..000000000000
--- a/src/transformers/models/vit_mae/convert_vit_mae_to_pytorch.py
+++ /dev/null
@@ -1,178 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ViT MAE checkpoints from the original repository: https://github.com/facebookresearch/mae"""
-
-import argparse
-
-import requests
-import torch
-from PIL import Image
-
-from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor
-
-
-def rename_key(name):
-    if "cls_token" in name:
-        name = name.replace("cls_token", "vit.embeddings.cls_token")
-    if "mask_token" in name:
-        name = name.replace("mask_token", "decoder.mask_token")
-    if "decoder_pos_embed" in name:
-        name = name.replace("decoder_pos_embed", "decoder.decoder_pos_embed")
-    if "pos_embed" in name and "decoder" not in name:
-        name = name.replace("pos_embed", "vit.embeddings.position_embeddings")
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "vit.embeddings.patch_embeddings.projection")
-    if "patch_embed.norm" in name:
-        name = name.replace("patch_embed.norm", "vit.embeddings.norm")
-    if "decoder_blocks" in name:
-        name = name.replace("decoder_blocks", "decoder.decoder_layers")
-    if "blocks" in name:
-        name = name.replace("blocks", "vit.encoder.layer")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name:
-        name = name.replace("attn", "attention.self")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "decoder_embed" in name:
-        name = name.replace("decoder_embed", "decoder.decoder_embed")
-    if "decoder_norm" in name:
-        name = name.replace("decoder_norm", "decoder.decoder_norm")
-    if "decoder_pred" in name:
-        name = name.replace("decoder_pred", "decoder.decoder_pred")
-    if "norm.weight" in name and "decoder" not in name:
-        name = name.replace("norm.weight", "vit.layernorm.weight")
-    if "norm.bias" in name and "decoder" not in name:
-        name = name.replace("norm.bias", "vit.layernorm.bias")
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, config):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[1])
-            if "decoder_blocks" in key:
-                dim = config.decoder_hidden_size
-                prefix = "decoder.decoder_layers."
-                if "weight" in key:
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.query.weight"] = val[:dim, :]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.key.weight"] = val[dim : dim * 2, :]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.value.weight"] = val[-dim:, :]
-                elif "bias" in key:
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.query.bias"] = val[:dim]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.key.bias"] = val[dim : dim * 2]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.value.bias"] = val[-dim:]
-            else:
-                dim = config.hidden_size
-                prefix = "vit.encoder.layer."
-                if "weight" in key:
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.query.weight"] = val[:dim, :]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.key.weight"] = val[dim : dim * 2, :]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.value.weight"] = val[-dim:, :]
-                elif "bias" in key:
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.query.bias"] = val[:dim]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.key.bias"] = val[dim : dim * 2]
-                    orig_state_dict[f"{prefix}{layer_num}.attention.attention.value.bias"] = val[-dim:]
-
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-def convert_vit_mae_checkpoint(checkpoint_url, pytorch_dump_folder_path):
-    config = ViTMAEConfig()
-    if "large" in checkpoint_url:
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-    elif "huge" in checkpoint_url:
-        config.patch_size = 14
-        config.hidden_size = 1280
-        config.intermediate_size = 5120
-        config.num_hidden_layers = 32
-        config.num_attention_heads = 16
-
-    model = ViTMAEForPreTraining(config)
-
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["model"]
-
-    image_processor = ViTMAEImageProcessor(size=config.image_size)
-
-    new_state_dict = convert_state_dict(state_dict, config)
-
-    model.load_state_dict(new_state_dict)
-    model.eval()
-
-    url = "https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg"
-
-    image = Image.open(requests.get(url, stream=True).raw)
-    image_processor = ViTMAEImageProcessor(size=config.image_size)
-    inputs = image_processor(images=image, return_tensors="pt")
-
-    # forward pass
-    torch.manual_seed(2)
-    outputs = model(**inputs)
-    logits = outputs.logits
-
-    if "large" in checkpoint_url:
-        expected_slice = torch.tensor(
-            [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]]
-        )
-    elif "huge" in checkpoint_url:
-        expected_slice = torch.tensor(
-            [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]]
-        )
-    else:
-        expected_slice = torch.tensor(
-            [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]]
-        )
-
-    # verify logits
-    assert torch.allclose(logits[0, :3, :3], expected_slice, atol=1e-4)
-
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth",
-        type=str,
-        help="URL of the checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/vit_msn/convert_msn_to_pytorch.py b/src/transformers/models/vit_msn/convert_msn_to_pytorch.py
deleted file mode 100644
index 899c74f18320..000000000000
--- a/src/transformers/models/vit_msn/convert_msn_to_pytorch.py
+++ /dev/null
@@ -1,245 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ViT MSN checkpoints from the original repository: https://github.com/facebookresearch/msn"""
-
-import argparse
-import json
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import ViTImageProcessor, ViTMSNConfig, ViTMSNModel
-from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
-
-
-torch.set_grad_enabled(False)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config, base_model=False):
-    rename_keys = []
-    for i in range(config.num_hidden_layers):
-        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
-        rename_keys.append((f"module.blocks.{i}.norm1.weight", f"vit.encoder.layer.{i}.layernorm_before.weight"))
-        rename_keys.append((f"module.blocks.{i}.norm1.bias", f"vit.encoder.layer.{i}.layernorm_before.bias"))
-        rename_keys.append(
-            (f"module.blocks.{i}.attn.proj.weight", f"vit.encoder.layer.{i}.attention.output.dense.weight")
-        )
-        rename_keys.append((f"module.blocks.{i}.attn.proj.bias", f"vit.encoder.layer.{i}.attention.output.dense.bias"))
-        rename_keys.append((f"module.blocks.{i}.norm2.weight", f"vit.encoder.layer.{i}.layernorm_after.weight"))
-        rename_keys.append((f"module.blocks.{i}.norm2.bias", f"vit.encoder.layer.{i}.layernorm_after.bias"))
-        rename_keys.append((f"module.blocks.{i}.mlp.fc1.weight", f"vit.encoder.layer.{i}.intermediate.dense.weight"))
-        rename_keys.append((f"module.blocks.{i}.mlp.fc1.bias", f"vit.encoder.layer.{i}.intermediate.dense.bias"))
-        rename_keys.append((f"module.blocks.{i}.mlp.fc2.weight", f"vit.encoder.layer.{i}.output.dense.weight"))
-        rename_keys.append((f"module.blocks.{i}.mlp.fc2.bias", f"vit.encoder.layer.{i}.output.dense.bias"))
-
-    # projection layer + position embeddings
-    rename_keys.extend(
-        [
-            ("module.cls_token", "vit.embeddings.cls_token"),
-            ("module.patch_embed.proj.weight", "vit.embeddings.patch_embeddings.projection.weight"),
-            ("module.patch_embed.proj.bias", "vit.embeddings.patch_embeddings.projection.bias"),
-            ("module.pos_embed", "vit.embeddings.position_embeddings"),
-        ]
-    )
-
-    if base_model:
-        # layernorm + pooler
-        rename_keys.extend(
-            [
-                ("module.norm.weight", "layernorm.weight"),
-                ("module.norm.bias", "layernorm.bias"),
-            ]
-        )
-
-        # if just the base model, we should remove "vit" from all keys that start with "vit"
-        rename_keys = [(pair[0], pair[1][4:]) if pair[1].startswith("vit") else pair for pair in rename_keys]
-    else:
-        # layernorm + classification head
-        rename_keys.extend(
-            [
-                ("norm.weight", "vit.layernorm.weight"),
-                ("norm.bias", "vit.layernorm.bias"),
-                ("head.weight", "classifier.weight"),
-                ("head.bias", "classifier.bias"),
-            ]
-        )
-
-    return rename_keys
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config, base_model=False):
-    for i in range(config.num_hidden_layers):
-        if base_model:
-            prefix = ""
-        else:
-            prefix = "vit."
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"module.blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"module.blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[
-            : config.hidden_size, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[
-            -config.hidden_size :, :
-        ]
-        state_dict[f"{prefix}encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-def remove_classification_head_(state_dict):
-    ignore_keys = ["head.weight", "head.bias"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def remove_projection_head(state_dict):
-    # projection head is used in the self-supervised pre-training in MSN,
-    # for downstream task it's not needed.
-    ignore_keys = [
-        "module.fc.fc1.weight",
-        "module.fc.fc1.bias",
-        "module.fc.bn1.weight",
-        "module.fc.bn1.bias",
-        "module.fc.bn1.running_mean",
-        "module.fc.bn1.running_var",
-        "module.fc.bn1.num_batches_tracked",
-        "module.fc.fc2.weight",
-        "module.fc.fc2.bias",
-        "module.fc.bn2.weight",
-        "module.fc.bn2.bias",
-        "module.fc.bn2.running_mean",
-        "module.fc.bn2.running_var",
-        "module.fc.bn2.num_batches_tracked",
-        "module.fc.fc3.weight",
-        "module.fc.fc3.bias",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def convert_vit_msn_checkpoint(checkpoint_url, pytorch_dump_folder_path):
-    config = ViTMSNConfig()
-    config.num_labels = 1000
-
-    repo_id = "datasets/huggingface/label-files"
-    filename = "imagenet-1k-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    if "s16" in checkpoint_url:
-        config.hidden_size = 384
-        config.intermediate_size = 1536
-        config.num_attention_heads = 6
-    elif "l16" in checkpoint_url:
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-        config.hidden_dropout_prob = 0.1
-    elif "b4" in checkpoint_url:
-        config.patch_size = 4
-    elif "l7" in checkpoint_url:
-        config.patch_size = 7
-        config.hidden_size = 1024
-        config.intermediate_size = 4096
-        config.num_hidden_layers = 24
-        config.num_attention_heads = 16
-        config.hidden_dropout_prob = 0.1
-
-    model = ViTMSNModel(config)
-
-    state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")["target_encoder"]
-
-    image_processor = ViTImageProcessor(size=config.image_size)
-
-    remove_projection_head(state_dict)
-    rename_keys = create_rename_keys(config, base_model=True)
-
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-    read_in_q_k_v(state_dict, config, base_model=True)
-
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-
-    image = Image.open(requests.get(url, stream=True).raw)
-    image_processor = ViTImageProcessor(
-        size=config.image_size, image_mean=IMAGENET_DEFAULT_MEAN, image_std=IMAGENET_DEFAULT_STD
-    )
-    inputs = image_processor(images=image, return_tensors="pt")
-
-    # forward pass
-    torch.manual_seed(2)
-    outputs = model(**inputs)
-    last_hidden_state = outputs.last_hidden_state
-
-    # The following Colab Notebook was used to generate these outputs:
-    # https://colab.research.google.com/gist/sayakpaul/3672419a04f5997827503fd84079bdd1/scratchpad.ipynb
-    if "s16" in checkpoint_url:
-        expected_slice = torch.tensor([[-1.0915, -1.4876, -1.1809]])
-    elif "b16" in checkpoint_url:
-        expected_slice = torch.tensor([[14.2889, -18.9045, 11.7281]])
-    elif "l16" in checkpoint_url:
-        expected_slice = torch.tensor([[41.5028, -22.8681, 45.6475]])
-    elif "b4" in checkpoint_url:
-        expected_slice = torch.tensor([[-4.3868, 5.2932, -0.4137]])
-    else:
-        expected_slice = torch.tensor([[-0.1792, -0.6465, 2.4263]])
-
-    # verify logits
-    assert torch.allclose(last_hidden_state[:, 0, :3], expected_slice, atol=1e-4)
-
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--checkpoint_url",
-        default="https://dl.fbaipublicfiles.com/msn/vits16_800ep.pth.tar",
-        type=str,
-        help="URL of the checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-
-    args = parser.parse_args()
-    convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/vitmatte/convert_vitmatte_to_hf.py b/src/transformers/models/vitmatte/convert_vitmatte_to_hf.py
deleted file mode 100644
index bcc055633371..000000000000
--- a/src/transformers/models/vitmatte/convert_vitmatte_to_hf.py
+++ /dev/null
@@ -1,170 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert VitMatte checkpoints from the original repository.
-
-URL: https://github.com/hustvl/ViTMatte
-"""
-
-import argparse
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import VitDetConfig, VitMatteConfig, VitMatteForImageMatting, VitMatteImageProcessor
-
-
-def get_config(model_name):
-    hidden_size = 384 if "small" in model_name else 768
-    num_attention_heads = 6 if "small" in model_name else 12
-
-    backbone_config = VitDetConfig(
-        num_channels=4,
-        image_size=512,
-        pretrain_image_size=224,
-        patch_size=16,
-        hidden_size=hidden_size,
-        num_attention_heads=num_attention_heads,
-        use_absolute_position_embeddings=True,
-        use_relative_position_embeddings=True,
-        window_size=14,
-        # 2, 5, 8, 11 for global attention
-        window_block_indices=[0, 1, 3, 4, 6, 7, 9, 10],
-        residual_block_indices=[2, 5, 8, 11],
-        out_features=["stage12"],
-    )
-
-    return VitMatteConfig(backbone_config=backbone_config, hidden_size=hidden_size)
-
-
-# here we list all keys to be renamed (original name on the left, our name on the right)
-def create_rename_keys(config):
-    rename_keys = []
-
-    # fmt: off
-    # stem
-    rename_keys.append(("backbone.pos_embed", "backbone.embeddings.position_embeddings"))
-    rename_keys.append(("backbone.patch_embed.proj.weight", "backbone.embeddings.projection.weight"))
-    rename_keys.append(("backbone.patch_embed.proj.bias", "backbone.embeddings.projection.bias"))
-    # fmt: on
-
-    return rename_keys
-
-
-def rename_key(dct, old, new):
-    val = dct.pop(old)
-    dct[new] = val
-
-
-def convert_vitmatte_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub):
-    config = get_config(model_name)
-
-    # load original state dict
-    model_name_to_filename = {
-        "vitmatte-small-composition-1k": "ViTMatte_S_Com.pth",
-        "vitmatte-base-composition-1k": "ViTMatte_B_Com.pth",
-        "vitmatte-small-distinctions-646": "ViTMatte_S_DIS.pth",
-        "vitmatte-base-distinctions-646": "ViTMatte_B_DIS.pth",
-    }
-
-    filename = model_name_to_filename[model_name]
-    filepath = hf_hub_download(repo_id="nielsr/vitmatte-checkpoints", filename=filename, repo_type="model")
-    state_dict = torch.load(filepath, map_location="cpu")
-
-    # rename keys
-    for key in state_dict.copy().keys():
-        val = state_dict.pop(key)
-        if "backbone.blocks" in key:
-            key = key.replace("backbone.blocks", "backbone.encoder.layer")
-        if "attn" in key:
-            key = key.replace("attn", "attention")
-        if "fusion_blks" in key:
-            key = key.replace("fusion_blks", "fusion_blocks")
-        if "bn" in key:
-            key = key.replace("bn", "batch_norm")
-        state_dict[key] = val
-
-    # rename keys
-    rename_keys = create_rename_keys(config)
-    for src, dest in rename_keys:
-        rename_key(state_dict, src, dest)
-
-    # create model
-    processor = VitMatteImageProcessor()
-    model = VitMatteForImageMatting(config)
-    model.eval()
-
-    # load state dict
-    model.load_state_dict(state_dict)
-
-    # verify on dummy image + trimap
-    url = "https://github.com/hustvl/ViTMatte/blob/main/demo/bulb_rgb.png?raw=true"
-    image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
-    url = "https://github.com/hustvl/ViTMatte/blob/main/demo/bulb_trimap.png?raw=true"
-    trimap = Image.open(requests.get(url, stream=True).raw)
-
-    pixel_values = processor(images=image, trimaps=trimap.convert("L"), return_tensors="pt").pixel_values
-
-    with torch.no_grad():
-        alphas = model(pixel_values).alphas
-
-    if model_name == "vitmatte-small-composition-1k":
-        expected_slice = torch.tensor([[0.9977, 0.9987, 0.9990], [0.9980, 0.9998, 0.9998], [0.9983, 0.9998, 0.9998]])
-    elif model_name == "vitmatte-base-composition-1k":
-        expected_slice = torch.tensor([[0.9972, 0.9971, 0.9981], [0.9948, 0.9987, 0.9994], [0.9963, 0.9992, 0.9995]])
-    elif model_name == "vitmatte-small-distinctions-646":
-        expected_slice = torch.tensor([[0.9880, 0.9970, 0.9972], [0.9960, 0.9996, 0.9997], [0.9963, 0.9996, 0.9997]])
-    elif model_name == "vitmatte-base-distinctions-646":
-        expected_slice = torch.tensor([[0.9963, 0.9998, 0.9999], [0.9995, 1.0000, 1.0000], [0.9992, 0.9999, 1.0000]])
-
-    assert torch.allclose(alphas[0, 0, :3, :3], expected_slice, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor of {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-        processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print(f"Pushing model and processor for {model_name} to hub")
-        model.push_to_hub(f"hustvl/{model_name}")
-        processor.push_to_hub(f"hustvl/{model_name}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="vitmatte-small-composition-1k",
-        type=str,
-        choices=[
-            "vitmatte-small-composition-1k",
-            "vitmatte-base-composition-1k",
-            "vitmatte-small-distinctions-646",
-            "vitmatte-base-distinctions-646",
-        ],
-        help="Name of the VitMatte model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_vitmatte_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/vitpose/convert_vitpose_to_hf.py b/src/transformers/models/vitpose/convert_vitpose_to_hf.py
deleted file mode 100644
index 0d36e332a4f0..000000000000
--- a/src/transformers/models/vitpose/convert_vitpose_to_hf.py
+++ /dev/null
@@ -1,428 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert VitPose checkpoints from the original repository.
-
-URL: https://github.com/vitae-transformer/vitpose
-
-Notebook to get the original logits: https://colab.research.google.com/drive/1QDX_2POTpl6JaZAV2WIFjuiqDsDwiqMZ?usp=sharing.
-"""
-
-import argparse
-import os
-import re
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import VitPoseBackboneConfig, VitPoseConfig, VitPoseForPoseEstimation, VitPoseImageProcessor
-
-
-ORIGINAL_TO_CONVERTED_KEY_MAPPING = {
-    r"patch_embed.proj": "embeddings.patch_embeddings.projection",
-    r"pos_embed": "embeddings.position_embeddings",
-    r"blocks": "encoder.layer",
-    r"attn.proj": "attention.output.dense",
-    r"attn": "attention.self",
-    r"norm1": "layernorm_before",
-    r"norm2": "layernorm_after",
-    r"last_norm": "layernorm",
-    r"keypoint_head": "head",
-    r"final_layer": "conv",
-}
-
-MODEL_TO_FILE_NAME_MAPPING = {
-    # VitPose models, simple decoder
-    "vitpose-base-simple": "vitpose-b-simple.pth",
-    # VitPose models, classic decoder
-    "vitpose-base": "vitpose-b.pth",
-    # VitPose models, COCO-AIC-MPII
-    "vitpose-base-coco-aic-mpii": "vitpose_base_coco_aic_mpii.pth",
-    # VitPose+ models
-    "vitpose-plus-small": "vitpose+_small.pth",
-    "vitpose-plus-base": "vitpose+_base.pth",
-    "vitpose-plus-large": "vitpose+_large.pth",
-    "vitpose-plus-huge": "vitpose+_huge.pth",
-}
-
-
-def get_config(model_name):
-    if "plus" in model_name:
-        num_experts = 6
-        if "small" in model_name:
-            part_features = 96
-            out_indices = [12]
-        elif "base" in model_name:
-            part_features = 192
-            out_indices = [12]
-        elif "large" in model_name:
-            part_features = 256
-            out_indices = [24]
-        elif "huge" in model_name:
-            part_features = 320
-            out_indices = [32]
-        else:
-            raise ValueError(f"Model {model_name} not supported")
-    else:
-        num_experts = 1
-        part_features = 0
-
-    # size of the architecture
-    if "small" in model_name:
-        hidden_size = 384
-        num_hidden_layers = 12
-        num_attention_heads = 12
-    elif "large" in model_name:
-        hidden_size = 1024
-        num_hidden_layers = 24
-        num_attention_heads = 16
-    elif "huge" in model_name:
-        hidden_size = 1280
-        num_hidden_layers = 32
-        num_attention_heads = 16
-
-    backbone_config = VitPoseBackboneConfig(
-        out_indices=out_indices,
-        hidden_size=hidden_size,
-        num_hidden_layers=num_hidden_layers,
-        num_attention_heads=num_attention_heads,
-        num_experts=num_experts,
-        part_features=part_features,
-    )
-
-    use_simple_decoder = "simple" in model_name
-
-    edges = [
-        [15, 13],
-        [13, 11],
-        [16, 14],
-        [14, 12],
-        [11, 12],
-        [5, 11],
-        [6, 12],
-        [5, 6],
-        [5, 7],
-        [6, 8],
-        [7, 9],
-        [8, 10],
-        [1, 2],
-        [0, 1],
-        [0, 2],
-        [1, 3],
-        [2, 4],
-        [3, 5],
-        [4, 6],
-    ]
-    id2label = {
-        0: "Nose",
-        1: "L_Eye",
-        2: "R_Eye",
-        3: "L_Ear",
-        4: "R_Ear",
-        5: "L_Shoulder",
-        6: "R_Shoulder",
-        7: "L_Elbow",
-        8: "R_Elbow",
-        9: "L_Wrist",
-        10: "R_Wrist",
-        11: "L_Hip",
-        12: "R_Hip",
-        13: "L_Knee",
-        14: "R_Knee",
-        15: "L_Ankle",
-        16: "R_Ankle",
-    }
-
-    label2id = {v: k for k, v in id2label.items()}
-
-    config = VitPoseConfig(
-        backbone_config=backbone_config,
-        num_labels=17,
-        use_simple_decoder=use_simple_decoder,
-        edges=edges,
-        id2label=id2label,
-        label2id=label2id,
-    )
-
-    return config
-
-
-def convert_old_keys_to_new_keys(state_dict_keys: dict = None):
-    """
-    This function should be applied only once, on the concatenated keys to efficiently rename using
-    the key mappings.
-    """
-    output_dict = {}
-    if state_dict_keys is not None:
-        old_text = "\n".join(state_dict_keys)
-        new_text = old_text
-        for pattern, replacement in ORIGINAL_TO_CONVERTED_KEY_MAPPING.items():
-            if replacement is None:
-                new_text = re.sub(pattern, "", new_text)  # an empty line
-                continue
-            new_text = re.sub(pattern, replacement, new_text)
-        output_dict = dict(zip(old_text.split("\n"), new_text.split("\n")))
-    return output_dict
-
-
-# We will verify our results on a COCO image
-def prepare_img():
-    url = "http://images.cocodataset.org/val2017/000000000139.jpg"
-    image = Image.open(requests.get(url, stream=True).raw)
-    return image
-
-
-@torch.no_grad()
-def write_model(model_name, model_path, push_to_hub, check_logits=True):
-    # ------------------------------------------------------------
-    # Vision model params and config
-    # ------------------------------------------------------------
-
-    # params from config
-    config = get_config(model_name)
-
-    # ------------------------------------------------------------
-    # Convert weights
-    # ------------------------------------------------------------
-
-    # load original state_dict
-    filename = MODEL_TO_FILE_NAME_MAPPING[model_name]
-    print(f"Fetching all parameters from the checkpoint at {filename}...")
-
-    checkpoint_path = hf_hub_download(
-        repo_id="nielsr/vitpose-original-checkpoints", filename=filename, repo_type="model"
-    )
-
-    print("Converting model...")
-    original_state_dict = torch.load(checkpoint_path, map_location="cpu")["state_dict"]
-    all_keys = list(original_state_dict.keys())
-    new_keys = convert_old_keys_to_new_keys(all_keys)
-
-    dim = config.backbone_config.hidden_size
-
-    state_dict = {}
-    for key in all_keys:
-        new_key = new_keys[key]
-        value = original_state_dict[key]
-
-        if re.search("associate_heads", new_key) or re.search("backbone.cls_token", new_key):
-            # This associated_heads is concept of auxiliary head so does not require in inference stage.
-            # backbone.cls_token is optional forward function for dynamically change of size, see detail in https://github.com/ViTAE-Transformer/ViTPose/issues/34
-            pass
-        elif re.search("qkv", new_key):
-            state_dict[new_key.replace("self.qkv", "attention.query")] = value[:dim]
-            state_dict[new_key.replace("self.qkv", "attention.key")] = value[dim : dim * 2]
-            state_dict[new_key.replace("self.qkv", "attention.value")] = value[-dim:]
-        elif re.search("head", new_key) and not config.use_simple_decoder:
-            # Pattern for deconvolution layers
-            deconv_pattern = r"deconv_layers\.(0|3)\.weight"
-            new_key = re.sub(deconv_pattern, lambda m: f"deconv{int(m.group(1)) // 3 + 1}.weight", new_key)
-            # Pattern for batch normalization layers
-            bn_patterns = [
-                (r"deconv_layers\.(\d+)\.weight", r"batchnorm\1.weight"),
-                (r"deconv_layers\.(\d+)\.bias", r"batchnorm\1.bias"),
-                (r"deconv_layers\.(\d+)\.running_mean", r"batchnorm\1.running_mean"),
-                (r"deconv_layers\.(\d+)\.running_var", r"batchnorm\1.running_var"),
-                (r"deconv_layers\.(\d+)\.num_batches_tracked", r"batchnorm\1.num_batches_tracked"),
-            ]
-
-            for pattern, replacement in bn_patterns:
-                if re.search(pattern, new_key):
-                    # Convert the layer number to the correct batch norm index
-                    layer_num = int(re.search(pattern, key).group(1))
-                    bn_num = layer_num // 3 + 1
-                    new_key = re.sub(pattern, replacement.replace(r"\1", str(bn_num)), new_key)
-            state_dict[new_key] = value
-        else:
-            state_dict[new_key] = value
-
-    print("Loading the checkpoint in a Vitpose model.")
-    model = VitPoseForPoseEstimation(config)
-    model.eval()
-    model.load_state_dict(state_dict)
-    print("Checkpoint loaded successfully.")
-
-    # create image processor
-    image_processor = VitPoseImageProcessor()
-
-    # verify image processor
-    image = prepare_img()
-    boxes = [[[412.8, 157.61, 53.05, 138.01], [384.43, 172.21, 15.12, 35.74]]]
-    pixel_values = image_processor(images=image, boxes=boxes, return_tensors="pt").pixel_values
-
-    filepath = hf_hub_download(repo_id="nielsr/test-image", filename="vitpose_batch_data.pt", repo_type="dataset")
-    original_pixel_values = torch.load(filepath, map_location="cpu")["img"]
-    # we allow for a small difference in the pixel values due to the original repository using cv2
-    assert torch.allclose(pixel_values, original_pixel_values, atol=1e-1)
-
-    dataset_index = torch.tensor([0])
-
-    with torch.no_grad():
-        print("Shape of original_pixel_values: ", original_pixel_values.shape)
-        print("First values of original_pixel_values: ", original_pixel_values[0, 0, :3, :3])
-
-        # first forward pass
-        outputs = model(original_pixel_values, dataset_index=dataset_index)
-        output_heatmap = outputs.heatmaps
-
-        print("Shape of output_heatmap: ", output_heatmap.shape)
-        print("First values: ", output_heatmap[0, 0, :3, :3])
-
-        # second forward pass (flipped)
-        # this is done since the model uses `flip_test=True` in its test config
-        original_pixel_values_flipped = torch.flip(original_pixel_values, [3])
-        outputs_flipped = model(
-            original_pixel_values_flipped,
-            dataset_index=dataset_index,
-            flip_pairs=torch.tensor([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14], [15, 16]]),
-        )
-        output_flipped_heatmap = outputs_flipped.heatmaps
-
-    outputs.heatmaps = (output_heatmap + output_flipped_heatmap) * 0.5
-
-    # Verify pose_results
-    pose_results = image_processor.post_process_pose_estimation(outputs, boxes=boxes)[0]
-
-    if check_logits:
-        # Simple decoder checkpoints
-        if model_name == "vitpose-base-simple":
-            assert torch.allclose(
-                pose_results[1]["keypoints"][0],
-                torch.tensor([3.98180511e02, 1.81808380e02]),
-                atol=5e-2,
-            )
-            assert torch.allclose(
-                pose_results[1]["scores"][0],
-                torch.tensor([8.66642594e-01]),
-                atol=5e-2,
-            )
-        # Classic decoder checkpoints
-        elif model_name == "vitpose-base":
-            assert torch.allclose(
-                pose_results[1]["keypoints"][0],
-                torch.tensor([3.9807913e02, 1.8182812e02]),
-                atol=5e-2,
-            )
-            assert torch.allclose(
-                pose_results[1]["scores"][0],
-                torch.tensor([8.8235235e-01]),
-                atol=5e-2,
-            )
-        # COCO-AIC-MPII checkpoints
-        elif model_name == "vitpose-base-coco-aic-mpii":
-            assert torch.allclose(
-                pose_results[1]["keypoints"][0],
-                torch.tensor([3.98305542e02, 1.81741592e02]),
-                atol=5e-2,
-            )
-            assert torch.allclose(
-                pose_results[1]["scores"][0],
-                torch.tensor([8.69966745e-01]),
-                atol=5e-2,
-            )
-        # VitPose+ models
-        elif model_name == "vitpose-plus-small":
-            assert torch.allclose(
-                pose_results[1]["keypoints"][0],
-                torch.tensor([398.1597, 181.6902]),
-                atol=5e-2,
-            )
-            assert torch.allclose(
-                pose_results[1]["scores"][0],
-                torch.tensor(0.9051),
-                atol=5e-2,
-            )
-        elif model_name == "vitpose-plus-base":
-            assert torch.allclose(
-                pose_results[1]["keypoints"][0],
-                torch.tensor([3.98201294e02, 1.81728302e02]),
-                atol=5e-2,
-            )
-            assert torch.allclose(
-                pose_results[1]["scores"][0],
-                torch.tensor([8.75046968e-01]),
-                atol=5e-2,
-            )
-        elif model_name == "vitpose-plus-large":
-            assert torch.allclose(
-                pose_results[1]["keypoints"][0],
-                torch.tensor([398.1409, 181.7412]),
-                atol=5e-2,
-            )
-            assert torch.allclose(
-                pose_results[1]["scores"][0],
-                torch.tensor(0.8746),
-                atol=5e-2,
-            )
-        elif model_name == "vitpose-plus-huge":
-            assert torch.allclose(
-                pose_results[1]["keypoints"][0],
-                torch.tensor([398.2079, 181.8026]),
-                atol=5e-2,
-            )
-            assert torch.allclose(
-                pose_results[1]["scores"][0],
-                torch.tensor(0.8693),
-                atol=5e-2,
-            )
-        else:
-            raise ValueError("Model not supported")
-    print("Conversion successfully done.")
-
-    if model_path is not None:
-        os.makedirs(model_path, exist_ok=True)
-        model.save_pretrained(model_path)
-        image_processor.save_pretrained(model_path)
-
-    if push_to_hub:
-        print(f"Pushing model and image processor for {model_name} to hub")
-        # we created a community organization on the hub for this model
-        # maintained by the Transformers team
-        model.push_to_hub(f"usyd-community/{model_name}")
-        image_processor.push_to_hub(f"usyd-community/{model_name}")
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="vitpose-base-simple",
-        choices=MODEL_TO_FILE_NAME_MAPPING.keys(),
-        type=str,
-        help="Name of the VitPose model you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to store the converted model."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-    parser.add_argument(
-        "--check_logits", action="store_false", help="Whether or not to verify the logits of the converted model."
-    )
-
-    args = parser.parse_args()
-    write_model(
-        model_path=args.pytorch_dump_folder_path,
-        model_name=args.model_name,
-        push_to_hub=args.push_to_hub,
-        check_logits=args.check_logits,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/transformers/models/vits/convert_original_checkpoint.py b/src/transformers/models/vits/convert_original_checkpoint.py
deleted file mode 100644
index 267f72ccd08f..000000000000
--- a/src/transformers/models/vits/convert_original_checkpoint.py
+++ /dev/null
@@ -1,390 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert VITS checkpoint."""
-
-import argparse
-import json
-import tempfile
-
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import VitsConfig, VitsModel, VitsTokenizer, logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger("transformers.models.vits")
-
-MAPPING_TEXT_ENCODER = {
-    "enc_p.emb": "text_encoder.embed_tokens",
-    "enc_p.encoder.attn_layers.*.conv_k": "text_encoder.encoder.layers.*.attention.k_proj",
-    "enc_p.encoder.attn_layers.*.conv_v": "text_encoder.encoder.layers.*.attention.v_proj",
-    "enc_p.encoder.attn_layers.*.conv_q": "text_encoder.encoder.layers.*.attention.q_proj",
-    "enc_p.encoder.attn_layers.*.conv_o": "text_encoder.encoder.layers.*.attention.out_proj",
-    "enc_p.encoder.attn_layers.*.emb_rel_k": "text_encoder.encoder.layers.*.attention.emb_rel_k",
-    "enc_p.encoder.attn_layers.*.emb_rel_v": "text_encoder.encoder.layers.*.attention.emb_rel_v",
-    "enc_p.encoder.norm_layers_1.*.gamma": "text_encoder.encoder.layers.*.layer_norm.weight",
-    "enc_p.encoder.norm_layers_1.*.beta": "text_encoder.encoder.layers.*.layer_norm.bias",
-    "enc_p.encoder.ffn_layers.*.conv_1": "text_encoder.encoder.layers.*.feed_forward.conv_1",
-    "enc_p.encoder.ffn_layers.*.conv_2": "text_encoder.encoder.layers.*.feed_forward.conv_2",
-    "enc_p.encoder.norm_layers_2.*.gamma": "text_encoder.encoder.layers.*.final_layer_norm.weight",
-    "enc_p.encoder.norm_layers_2.*.beta": "text_encoder.encoder.layers.*.final_layer_norm.bias",
-    "enc_p.proj": "text_encoder.project",
-}
-MAPPING_STOCHASTIC_DURATION_PREDICTOR = {
-    "dp.pre": "duration_predictor.conv_pre",
-    "dp.proj": "duration_predictor.conv_proj",
-    "dp.convs.convs_sep.*": "duration_predictor.conv_dds.convs_dilated.*",
-    "dp.convs.convs_1x1.*": "duration_predictor.conv_dds.convs_pointwise.*",
-    "dp.convs.norms_1.*.gamma": "duration_predictor.conv_dds.norms_1.*.weight",
-    "dp.convs.norms_1.*.beta": "duration_predictor.conv_dds.norms_1.*.bias",
-    "dp.convs.norms_2.*.gamma": "duration_predictor.conv_dds.norms_2.*.weight",
-    "dp.convs.norms_2.*.beta": "duration_predictor.conv_dds.norms_2.*.bias",
-    "dp.flows.0.logs": "duration_predictor.flows.0.log_scale",
-    "dp.flows.0.m": "duration_predictor.flows.0.translate",
-    "dp.flows.*.pre": "duration_predictor.flows.*.conv_pre",
-    "dp.flows.*.proj": "duration_predictor.flows.*.conv_proj",
-    "dp.flows.*.convs.convs_1x1.0": "duration_predictor.flows.*.conv_dds.convs_pointwise.0",
-    "dp.flows.*.convs.convs_1x1.1": "duration_predictor.flows.*.conv_dds.convs_pointwise.1",
-    "dp.flows.*.convs.convs_1x1.2": "duration_predictor.flows.*.conv_dds.convs_pointwise.2",
-    "dp.flows.*.convs.convs_sep.0": "duration_predictor.flows.*.conv_dds.convs_dilated.0",
-    "dp.flows.*.convs.convs_sep.1": "duration_predictor.flows.*.conv_dds.convs_dilated.1",
-    "dp.flows.*.convs.convs_sep.2": "duration_predictor.flows.*.conv_dds.convs_dilated.2",
-    "dp.flows.*.convs.norms_1.0.gamma": "duration_predictor.flows.*.conv_dds.norms_1.0.weight",
-    "dp.flows.*.convs.norms_1.0.beta": "duration_predictor.flows.*.conv_dds.norms_1.0.bias",
-    "dp.flows.*.convs.norms_1.1.gamma": "duration_predictor.flows.*.conv_dds.norms_1.1.weight",
-    "dp.flows.*.convs.norms_1.1.beta": "duration_predictor.flows.*.conv_dds.norms_1.1.bias",
-    "dp.flows.*.convs.norms_1.2.gamma": "duration_predictor.flows.*.conv_dds.norms_1.2.weight",
-    "dp.flows.*.convs.norms_1.2.beta": "duration_predictor.flows.*.conv_dds.norms_1.2.bias",
-    "dp.flows.*.convs.norms_2.0.gamma": "duration_predictor.flows.*.conv_dds.norms_2.0.weight",
-    "dp.flows.*.convs.norms_2.0.beta": "duration_predictor.flows.*.conv_dds.norms_2.0.bias",
-    "dp.flows.*.convs.norms_2.1.gamma": "duration_predictor.flows.*.conv_dds.norms_2.1.weight",
-    "dp.flows.*.convs.norms_2.1.beta": "duration_predictor.flows.*.conv_dds.norms_2.1.bias",
-    "dp.flows.*.convs.norms_2.2.gamma": "duration_predictor.flows.*.conv_dds.norms_2.2.weight",
-    "dp.flows.*.convs.norms_2.2.beta": "duration_predictor.flows.*.conv_dds.norms_2.2.bias",
-    "dp.post_pre": "duration_predictor.post_conv_pre",
-    "dp.post_proj": "duration_predictor.post_conv_proj",
-    "dp.post_convs.convs_sep.*": "duration_predictor.post_conv_dds.convs_dilated.*",
-    "dp.post_convs.convs_1x1.*": "duration_predictor.post_conv_dds.convs_pointwise.*",
-    "dp.post_convs.norms_1.*.gamma": "duration_predictor.post_conv_dds.norms_1.*.weight",
-    "dp.post_convs.norms_1.*.beta": "duration_predictor.post_conv_dds.norms_1.*.bias",
-    "dp.post_convs.norms_2.*.gamma": "duration_predictor.post_conv_dds.norms_2.*.weight",
-    "dp.post_convs.norms_2.*.beta": "duration_predictor.post_conv_dds.norms_2.*.bias",
-    "dp.post_flows.0.logs": "duration_predictor.post_flows.0.log_scale",
-    "dp.post_flows.0.m": "duration_predictor.post_flows.0.translate",
-    "dp.post_flows.*.pre": "duration_predictor.post_flows.*.conv_pre",
-    "dp.post_flows.*.proj": "duration_predictor.post_flows.*.conv_proj",
-    "dp.post_flows.*.convs.convs_1x1.0": "duration_predictor.post_flows.*.conv_dds.convs_pointwise.0",
-    "dp.post_flows.*.convs.convs_1x1.1": "duration_predictor.post_flows.*.conv_dds.convs_pointwise.1",
-    "dp.post_flows.*.convs.convs_1x1.2": "duration_predictor.post_flows.*.conv_dds.convs_pointwise.2",
-    "dp.post_flows.*.convs.convs_sep.0": "duration_predictor.post_flows.*.conv_dds.convs_dilated.0",
-    "dp.post_flows.*.convs.convs_sep.1": "duration_predictor.post_flows.*.conv_dds.convs_dilated.1",
-    "dp.post_flows.*.convs.convs_sep.2": "duration_predictor.post_flows.*.conv_dds.convs_dilated.2",
-    "dp.post_flows.*.convs.norms_1.0.gamma": "duration_predictor.post_flows.*.conv_dds.norms_1.0.weight",
-    "dp.post_flows.*.convs.norms_1.0.beta": "duration_predictor.post_flows.*.conv_dds.norms_1.0.bias",
-    "dp.post_flows.*.convs.norms_1.1.gamma": "duration_predictor.post_flows.*.conv_dds.norms_1.1.weight",
-    "dp.post_flows.*.convs.norms_1.1.beta": "duration_predictor.post_flows.*.conv_dds.norms_1.1.bias",
-    "dp.post_flows.*.convs.norms_1.2.gamma": "duration_predictor.post_flows.*.conv_dds.norms_1.2.weight",
-    "dp.post_flows.*.convs.norms_1.2.beta": "duration_predictor.post_flows.*.conv_dds.norms_1.2.bias",
-    "dp.post_flows.*.convs.norms_2.0.gamma": "duration_predictor.post_flows.*.conv_dds.norms_2.0.weight",
-    "dp.post_flows.*.convs.norms_2.0.beta": "duration_predictor.post_flows.*.conv_dds.norms_2.0.bias",
-    "dp.post_flows.*.convs.norms_2.1.gamma": "duration_predictor.post_flows.*.conv_dds.norms_2.1.weight",
-    "dp.post_flows.*.convs.norms_2.1.beta": "duration_predictor.post_flows.*.conv_dds.norms_2.1.bias",
-    "dp.post_flows.*.convs.norms_2.2.gamma": "duration_predictor.post_flows.*.conv_dds.norms_2.2.weight",
-    "dp.post_flows.*.convs.norms_2.2.beta": "duration_predictor.post_flows.*.conv_dds.norms_2.2.bias",
-    "dp.cond": "duration_predictor.cond",  # num_speakers > 1
-}
-MAPPING_FLOW = {
-    "flow.flows.*.pre": "flow.flows.*.conv_pre",
-    "flow.flows.*.enc.in_layers.0": "flow.flows.*.wavenet.in_layers.0",
-    "flow.flows.*.enc.in_layers.1": "flow.flows.*.wavenet.in_layers.1",
-    "flow.flows.*.enc.in_layers.2": "flow.flows.*.wavenet.in_layers.2",
-    "flow.flows.*.enc.in_layers.3": "flow.flows.*.wavenet.in_layers.3",
-    "flow.flows.*.enc.res_skip_layers.0": "flow.flows.*.wavenet.res_skip_layers.0",
-    "flow.flows.*.enc.res_skip_layers.1": "flow.flows.*.wavenet.res_skip_layers.1",
-    "flow.flows.*.enc.res_skip_layers.2": "flow.flows.*.wavenet.res_skip_layers.2",
-    "flow.flows.*.enc.res_skip_layers.3": "flow.flows.*.wavenet.res_skip_layers.3",
-    "flow.flows.*.enc.cond_layer": "flow.flows.*.wavenet.cond_layer",  # num_speakers > 1
-    "flow.flows.*.post": "flow.flows.*.conv_post",
-}
-MAPPING_GENERATOR = {
-    "dec.conv_pre": "decoder.conv_pre",
-    "dec.ups.0": "decoder.upsampler.0",
-    "dec.ups.1": "decoder.upsampler.1",
-    "dec.ups.2": "decoder.upsampler.2",
-    "dec.ups.3": "decoder.upsampler.3",
-    "dec.resblocks.*.convs1.0": "decoder.resblocks.*.convs1.0",
-    "dec.resblocks.*.convs1.1": "decoder.resblocks.*.convs1.1",
-    "dec.resblocks.*.convs1.2": "decoder.resblocks.*.convs1.2",
-    "dec.resblocks.*.convs2.0": "decoder.resblocks.*.convs2.0",
-    "dec.resblocks.*.convs2.1": "decoder.resblocks.*.convs2.1",
-    "dec.resblocks.*.convs2.2": "decoder.resblocks.*.convs2.2",
-    "dec.conv_post": "decoder.conv_post",
-    "dec.cond": "decoder.cond",  # num_speakers > 1
-}
-MAPPING_POSTERIOR_ENCODER = {
-    "enc_q.pre": "posterior_encoder.conv_pre",
-    "enc_q.enc.in_layers.*": "posterior_encoder.wavenet.in_layers.*",
-    "enc_q.enc.res_skip_layers.*": "posterior_encoder.wavenet.res_skip_layers.*",
-    "enc_q.enc.cond_layer": "posterior_encoder.wavenet.cond_layer",  # num_speakers > 1
-    "enc_q.proj": "posterior_encoder.conv_proj",
-}
-MAPPING = {
-    **MAPPING_TEXT_ENCODER,
-    **MAPPING_STOCHASTIC_DURATION_PREDICTOR,
-    **MAPPING_FLOW,
-    **MAPPING_GENERATOR,
-    **MAPPING_POSTERIOR_ENCODER,
-    "emb_g": "embed_speaker",  # num_speakers > 1
-}
-TOP_LEVEL_KEYS = []
-IGNORE_KEYS = []
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    # strip off the kernel dimension at the end (original weights are Conv1d)
-    if key.endswith(".k_proj") or key.endswith(".v_proj") or key.endswith(".q_proj") or key.endswith(".out_proj"):
-        value = value.squeeze(-1)
-
-    if hf_shape != value.shape:
-        raise ValueError(
-            f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-            f" {value.shape} for {full_name}"
-        )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    elif weight_type == "running_mean":
-        hf_pointer.running_mean.data = value
-    elif weight_type == "running_var":
-        hf_pointer.running_var.data = value
-    elif weight_type == "num_batches_tracked":
-        hf_pointer.num_batches_tracked.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}.")
-
-
-def should_ignore(name, ignore_keys):
-    for key in ignore_keys:
-        if key.endswith(".*"):
-            if name.startswith(key[:-1]):
-                return True
-        elif ".*." in key:
-            prefix, suffix = key.split(".*.")
-            if prefix in name and suffix in name:
-                return True
-        elif key in name:
-            return True
-    return False
-
-
-def recursively_load_weights(fairseq_dict, hf_model):
-    unused_weights = []
-
-    for name, value in fairseq_dict.items():
-        if should_ignore(name, IGNORE_KEYS):
-            logger.info(f"{name} was ignored")
-            continue
-
-        is_used = False
-        for key, mapped_key in MAPPING.items():
-            if key.endswith(".*"):
-                key = key[:-1]
-            elif "*" in key:
-                prefix, suffix = key.split(".*.")
-                if prefix in name and suffix in name:
-                    key = suffix
-
-            if key in name:
-                is_used = True
-                if mapped_key.endswith(".*"):
-                    layer_index = name.split(key)[-1].split(".")[0]
-                    mapped_key = mapped_key.replace("*", layer_index)
-                elif "*" in mapped_key:
-                    layer_index = name.split(key)[0].split(".")[-2]
-
-                    # remap the layer index since we removed the Flip layers
-                    if "flow.flows" in mapped_key:
-                        layer_index = str(int(layer_index) // 2)
-                    if "duration_predictor.flows" in mapped_key or "duration_predictor.post_flows" in mapped_key:
-                        layer_index = str(int(layer_index) // 2 + 1)
-
-                    mapped_key = mapped_key.replace("*", layer_index)
-                if "weight_g" in name:
-                    weight_type = "weight_g"
-                elif "weight_v" in name:
-                    weight_type = "weight_v"
-                elif "bias" in name:
-                    weight_type = "bias"
-                elif "weight" in name:
-                    weight_type = "weight"
-                elif "running_mean" in name:
-                    weight_type = "running_mean"
-                elif "running_var" in name:
-                    weight_type = "running_var"
-                elif "num_batches_tracked" in name:
-                    weight_type = "num_batches_tracked"
-                else:
-                    weight_type = None
-                set_recursively(hf_model, mapped_key, value, name, weight_type)
-            continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-@torch.no_grad()
-def convert_checkpoint(
-    pytorch_dump_folder_path,
-    checkpoint_path=None,
-    config_path=None,
-    vocab_path=None,
-    language=None,
-    num_speakers=None,
-    sampling_rate=None,
-    repo_id=None,
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = VitsConfig.from_pretrained(config_path)
-    else:
-        config = VitsConfig()
-
-    if num_speakers:
-        config.num_speakers = num_speakers
-        config.speaker_embedding_size = 256
-
-    if sampling_rate:
-        config.sampling_rate = sampling_rate
-
-    if checkpoint_path is None:
-        logger.info(f"***Converting model: facebook/mms-tts {language}***")
-
-        vocab_path = hf_hub_download(
-            repo_id="facebook/mms-tts",
-            filename="vocab.txt",
-            subfolder=f"models/{language}",
-        )
-        config_file = hf_hub_download(
-            repo_id="facebook/mms-tts",
-            filename="config.json",
-            subfolder=f"models/{language}",
-        )
-        checkpoint_path = hf_hub_download(
-            repo_id="facebook/mms-tts",
-            filename="G_100000.pth",
-            subfolder=f"models/{language}",
-        )
-
-        with open(config_file, "r") as f:
-            data = f.read()
-            hps = json.loads(data)
-
-        is_uroman = hps["data"]["training_files"].split(".")[-1] == "uroman"
-        if is_uroman:
-            logger.warning("For this checkpoint, you should use `uroman` to convert input text before tokenizing it!")
-    else:
-        logger.info(f"***Converting model: {checkpoint_path}***")
-        is_uroman = False
-
-    # original VITS checkpoint
-    if vocab_path is None:
-        _pad = "_"
-        _punctuation = ';:,.!?¡¿—…"«»“” '
-        _letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-        _letters_ipa = "ɑɐɒæɓʙβɔɕçɗɖðʤəɘɚɛɜɝɞɟʄɡɠɢʛɦɧħɥʜɨɪʝɭɬɫɮʟɱɯɰŋɳɲɴøɵɸθœɶʘɹɺɾɻʀʁɽʂʃʈʧʉʊʋⱱʌɣɤʍχʎʏʑʐʒʔʡʕʢǀǁǂǃˈˌːˑʼʴʰʱʲʷˠˤ˞↓↑→↗↘'̩'ᵻ"
-        symbols = _pad + _punctuation + _letters + _letters_ipa
-        symbol_to_id = {s: i for i, s in enumerate(symbols)}
-        phonemize = True
-    else:
-        # Save vocab as temporary json file
-        symbols = [line.replace("\n", "") for line in open(vocab_path, encoding="utf-8").readlines()]
-        symbol_to_id = {s: i for i, s in enumerate(symbols)}
-        # MMS-TTS does not use a <pad> token, so we set to the token used to space characters
-        _pad = symbols[0]
-        phonemize = False
-
-    with tempfile.NamedTemporaryFile() as tf:
-        with open(tf.name, "w", encoding="utf-8") as f:
-            f.write(json.dumps(symbol_to_id, indent=2, sort_keys=True, ensure_ascii=False) + "\n")
-
-        tokenizer = VitsTokenizer(tf.name, language=language, phonemize=phonemize, is_uroman=is_uroman, pad_token=_pad)
-
-    config.vocab_size = len(symbols)
-    model = VitsModel(config)
-
-    model.decoder.apply_weight_norm()
-
-    orig_checkpoint = torch.load(checkpoint_path, map_location=torch.device("cpu"))
-    recursively_load_weights(orig_checkpoint["model"], model)
-
-    model.decoder.remove_weight_norm()
-
-    model.save_pretrained(pytorch_dump_folder_path)
-    tokenizer.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        print("Pushing to the hub...")
-        tokenizer.push_to_hub(repo_id)
-        model.push_to_hub(repo_id)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Local path to original checkpoint")
-    parser.add_argument("--vocab_path", default=None, type=str, help="Path to vocab.txt")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument("--language", default=None, type=str, help="Tokenizer language (three-letter code)")
-    parser.add_argument("--num_speakers", default=None, type=int, help="Number of speakers")
-    parser.add_argument(
-        "--sampling_rate", default=None, type=int, help="Sampling rate on which the model was trained."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_checkpoint(
-        args.pytorch_dump_folder_path,
-        args.checkpoint_path,
-        args.config_path,
-        args.vocab_path,
-        args.language,
-        args.num_speakers,
-        args.sampling_rate,
-        args.push_to_hub,
-    )
diff --git a/src/transformers/models/vivit/convert_vivit_flax_to_pytorch.py b/src/transformers/models/vivit/convert_vivit_flax_to_pytorch.py
deleted file mode 100644
index f4b5e1cfda31..000000000000
--- a/src/transformers/models/vivit/convert_vivit_flax_to_pytorch.py
+++ /dev/null
@@ -1,231 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Flax ViViT checkpoints from the original repository to PyTorch. URL:
-https://github.com/google-research/scenic/tree/main/scenic/projects/vivit
-"""
-
-import argparse
-import json
-import os.path
-from collections import OrderedDict
-
-import numpy as np
-import requests
-import torch
-from flax.training.checkpoints import restore_checkpoint
-from huggingface_hub import hf_hub_download
-
-from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
-from transformers.image_utils import PILImageResampling
-
-
-def download_checkpoint(path):
-    url = "https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"
-
-    with open(path, "wb") as f:
-        with requests.get(url, stream=True) as req:
-            for chunk in req.iter_content(chunk_size=2048):
-                f.write(chunk)
-
-
-def get_vivit_config() -> VivitConfig:
-    config = VivitConfig()
-
-    config.num_labels = 400
-    repo_id = "huggingface/label-files"
-    filename = "kinetics400-id2label.json"
-
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-    return config
-
-
-# We will verify our results on a video of eating spaghetti
-# Frame indices used: [ 47, 51, 55, 59, 63, 67, 71, 75, 80, 84, 88, 92, 96, 100, 104, 108, 113, 117,
-# 121, 125, 129, 133, 137, 141, 146, 150, 154, 158, 162, 166, 170, 174]
-def prepare_video():
-    file = hf_hub_download(
-        repo_id="hf-internal-testing/spaghetti-video", filename="eating_spaghetti_32_frames.npy", repo_type="dataset"
-    )
-    video = np.load(file)
-    return list(video)
-
-
-def transform_attention(current: np.ndarray):
-    if np.ndim(current) == 2:
-        return transform_attention_bias(current)
-
-    elif np.ndim(current) == 3:
-        return transform_attention_kernel(current)
-
-    else:
-        raise Exception(f"Invalid number of dimensions: {np.ndim(current)}")
-
-
-def transform_attention_bias(current: np.ndarray):
-    return current.flatten()
-
-
-def transform_attention_kernel(current: np.ndarray):
-    return np.reshape(current, (current.shape[0], current.shape[1] * current.shape[2])).T
-
-
-def transform_attention_output_weight(current: np.ndarray):
-    return np.reshape(current, (current.shape[0] * current.shape[1], current.shape[2])).T
-
-
-def transform_state_encoder_block(state_dict, i):
-    state = state_dict["optimizer"]["target"]["Transformer"][f"encoderblock_{i}"]
-
-    prefix = f"encoder.layer.{i}."
-    new_state = {
-        prefix + "intermediate.dense.bias": state["MlpBlock_0"]["Dense_0"]["bias"],
-        prefix + "intermediate.dense.weight": np.transpose(state["MlpBlock_0"]["Dense_0"]["kernel"]),
-        prefix + "output.dense.bias": state["MlpBlock_0"]["Dense_1"]["bias"],
-        prefix + "output.dense.weight": np.transpose(state["MlpBlock_0"]["Dense_1"]["kernel"]),
-        prefix + "layernorm_before.bias": state["LayerNorm_0"]["bias"],
-        prefix + "layernorm_before.weight": state["LayerNorm_0"]["scale"],
-        prefix + "layernorm_after.bias": state["LayerNorm_1"]["bias"],
-        prefix + "layernorm_after.weight": state["LayerNorm_1"]["scale"],
-        prefix + "attention.attention.query.bias": transform_attention(
-            state["MultiHeadDotProductAttention_0"]["query"]["bias"]
-        ),
-        prefix + "attention.attention.query.weight": transform_attention(
-            state["MultiHeadDotProductAttention_0"]["query"]["kernel"]
-        ),
-        prefix + "attention.attention.key.bias": transform_attention(
-            state["MultiHeadDotProductAttention_0"]["key"]["bias"]
-        ),
-        prefix + "attention.attention.key.weight": transform_attention(
-            state["MultiHeadDotProductAttention_0"]["key"]["kernel"]
-        ),
-        prefix + "attention.attention.value.bias": transform_attention(
-            state["MultiHeadDotProductAttention_0"]["value"]["bias"]
-        ),
-        prefix + "attention.attention.value.weight": transform_attention(
-            state["MultiHeadDotProductAttention_0"]["value"]["kernel"]
-        ),
-        prefix + "attention.output.dense.bias": state["MultiHeadDotProductAttention_0"]["out"]["bias"],
-        prefix + "attention.output.dense.weight": transform_attention_output_weight(
-            state["MultiHeadDotProductAttention_0"]["out"]["kernel"]
-        ),
-    }
-
-    return new_state
-
-
-def get_n_layers(state_dict):
-    return sum([1 if "encoderblock_" in k else 0 for k in state_dict["optimizer"]["target"]["Transformer"].keys()])
-
-
-def transform_state(state_dict, classification_head=False):
-    transformer_layers = get_n_layers(state_dict)
-
-    new_state = OrderedDict()
-
-    new_state["layernorm.bias"] = state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["bias"]
-    new_state["layernorm.weight"] = state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["scale"]
-
-    new_state["embeddings.patch_embeddings.projection.weight"] = np.transpose(
-        state_dict["optimizer"]["target"]["embedding"]["kernel"], (4, 3, 0, 1, 2)
-    )
-    new_state["embeddings.patch_embeddings.projection.bias"] = state_dict["optimizer"]["target"]["embedding"]["bias"]
-
-    new_state["embeddings.cls_token"] = state_dict["optimizer"]["target"]["cls"]
-    new_state["embeddings.position_embeddings"] = state_dict["optimizer"]["target"]["Transformer"]["posembed_input"][
-        "pos_embedding"
-    ]
-
-    for i in range(transformer_layers):
-        new_state.update(transform_state_encoder_block(state_dict, i))
-
-    if classification_head:
-        new_state = {"vivit." + k: v for k, v in new_state.items()}
-        new_state["classifier.weight"] = np.transpose(state_dict["optimizer"]["target"]["output_projection"]["kernel"])
-        new_state["classifier.bias"] = np.transpose(state_dict["optimizer"]["target"]["output_projection"]["bias"])
-
-    return {k: torch.tensor(v) for k, v in new_state.items()}
-
-
-# checks that image processor settings are the same as in the original implementation
-# original: https://github.com/google-research/scenic/blob/main/scenic/projects/vivit/data/video_tfrecord_dataset.py
-# dataset specific config:
-# https://github.com/google-research/scenic/blob/main/scenic/projects/vivit/configs/kinetics400/vivit_base_k400.py
-def get_processor() -> VivitImageProcessor:
-    extractor = VivitImageProcessor()
-
-    assert extractor.do_resize is True
-    assert extractor.size == {"shortest_edge": 256}
-    assert extractor.do_center_crop is True
-    assert extractor.crop_size == {"width": 224, "height": 224}
-    assert extractor.resample == PILImageResampling.BILINEAR
-
-    # here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
-    # one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
-    # which effectively means no normalization (and ViViT does not overwrite those when calling this func)
-    assert extractor.do_normalize is False
-    assert extractor.do_rescale is True
-    assert extractor.rescale_factor == 1 / 255
-
-    # zero-centering = True in original implementation
-    assert extractor.do_zero_centering is True
-
-    return extractor
-
-
-def convert(output_path: str):
-    flax_model_path = "checkpoint"
-
-    if not os.path.exists(flax_model_path):
-        download_checkpoint(flax_model_path)
-
-    state_dict = restore_checkpoint(flax_model_path, None)
-    new_state = transform_state(state_dict, classification_head=True)
-
-    config = get_vivit_config()
-
-    assert config.image_size == 224
-    assert config.num_frames == 32
-
-    model = VivitForVideoClassification(config)
-    model.load_state_dict(new_state)
-    model.eval()
-
-    extractor = get_processor()
-
-    video = prepare_video()
-    inputs = extractor(video, return_tensors="pt")
-
-    outputs = model(**inputs)
-
-    expected_shape = torch.Size([1, 400])
-    expected_slice = torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658])
-
-    assert outputs.logits.shape == expected_shape
-    assert torch.allclose(outputs.logits[0, :5], expected_slice, atol=1e-4), outputs.logits[0, :5]
-
-    model.save_pretrained(output_path)
-    extractor.save_pretrained(output_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument("--output_model_name", "-o", type=str, help="Output path for the converted HuggingFace model")
-
-    args = parser.parse_args()
-    convert(args.output_model_name)
diff --git a/src/transformers/models/wav2vec2/convert_wav2vec2_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/wav2vec2/convert_wav2vec2_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 5613f83a86b4..000000000000
--- a/src/transformers/models/wav2vec2/convert_wav2vec2_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,385 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Wav2Vec2 checkpoint."""
-
-import argparse
-import json
-import os
-
-import fairseq
-import torch
-from fairseq.data import Dictionary
-
-from transformers import (
-    Wav2Vec2Config,
-    Wav2Vec2CTCTokenizer,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2ForCTC,
-    Wav2Vec2ForPreTraining,
-    Wav2Vec2Processor,
-    logging,
-)
-from transformers.models.wav2vec2.modeling_wav2vec2 import Wav2Vec2ForSequenceClassification
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "adapter_layer": "encoder.layers.*.adapter_layer",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "quantizer.weight_proj": "quantizer.weight_proj",
-    "quantizer.vars": "quantizer.codevectors",
-    "project_q": "project_q",
-    "final_proj": "project_hid",
-    "w2v_encoder.proj": "lm_head",
-    "mask_emb": "masked_spec_embed",
-    "pooling_layer.linear": "projector",
-    "pooling_layer.projection": "classifier",
-}
-TOP_LEVEL_KEYS = [
-    "lm_head",
-    "quantizer.weight_proj",
-    "quantizer.codevectors",
-    "project_q",
-    "project_hid",
-    "projector",
-    "classifier",
-]
-
-
-def read_txt_into_dict(filename):
-    result = {}
-    with open(filename, "r") as file:
-        for line_number, line in enumerate(file):
-            line = line.strip()
-            if line:
-                words = line.split()
-                key = line_number
-                value = words[0]
-                result[key] = value
-    return result
-
-
-def set_recursively(key, value, full_name, weight_type, hf_pointer):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    hf_param_name = None
-    for param_key in PARAM_MAPPING.keys():
-        if full_name.endswith(param_key):
-            hf_param_name = PARAM_MAPPING[full_name.split(".")[-1]]
-            weight_type = "param"
-
-    # fairseq uses nn.utils.weight_norm() while transformers switches to nn.utils.parametrizations.weight_norm()
-    # the mapping between two versions:
-    # https://github.com/pytorch/pytorch/blob/56935684c3dfad7841c83c719eeebecb560fe466/torch/nn/utils/parametrizations.py#L389-L395
-
-    if weight_type is not None and weight_type != "param":
-        if weight_type == "weight_g" and not hasattr(hf_pointer, "weight_g"):
-            hf_shape = hf_pointer.parametrizations.weight.original0.shape
-        elif weight_type == "weight_v" and not hasattr(hf_pointer, "weight_v"):
-            hf_shape = hf_pointer.parametrizations.weight.original1.shape
-        else:
-            hf_shape = getattr(hf_pointer, weight_type).shape
-    elif weight_type is not None and weight_type == "param":
-        shape_pointer = hf_pointer
-        for attribute in hf_param_name.split("."):
-            shape_pointer = getattr(shape_pointer, attribute)
-        hf_shape = shape_pointer.shape
-
-        # let's reduce dimension
-        value = value[0]
-    else:
-        hf_shape = hf_pointer.shape
-
-    if hf_shape != value.shape:
-        raise ValueError(
-            f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-            f" {value.shape} for {full_name}"
-        )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        if hasattr(hf_pointer, "weight_g"):
-            hf_pointer.weight_g.data = value
-        else:
-            hf_pointer.parametrizations.weight.original0.data = value
-    elif weight_type == "weight_v":
-        if hasattr(hf_pointer, "weight_v"):
-            hf_pointer.weight_v.data = value
-        else:
-            hf_pointer.parametrizations.weight.original1.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    elif weight_type == "param":
-        for attribute in hf_param_name.split("."):
-            hf_pointer = getattr(hf_pointer, attribute)
-        hf_pointer.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def rename_dict(key, value, full_name, weight_type, hf_dict):
-    hf_param_name = None
-    for param_key in PARAM_MAPPING.keys():
-        if full_name.endswith(param_key):
-            hf_param_name = PARAM_MAPPING[full_name.split(".")[-1]]
-            weight_type = "param"
-
-    if weight_type is not None and weight_type != "param":
-        full_key = ".".join([key, weight_type])
-    elif weight_type is not None and weight_type == "param":
-        full_key = ".".join([key, hf_param_name])
-    else:
-        full_key = key
-
-    hf_dict[full_key] = value if "lm_head" in full_key else value[0]
-
-
-PARAM_MAPPING = {
-    "W_a": "linear_1.weight",
-    "W_b": "linear_2.weight",
-    "b_a": "linear_1.bias",
-    "b_b": "linear_2.bias",
-    "ln_W": "norm.weight",
-    "ln_b": "norm.bias",
-}
-
-
-def load_wav2vec2_layer(name, value, hf_model=None, hf_dict=None):
-    is_used = False
-    for key, mapped_key in MAPPING.items():
-        mapped_key = "wav2vec2." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
-        if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-            is_used = True
-            if "*" in mapped_key:
-                layer_index = name.split(key)[0].split(".")[-2]
-                mapped_key = mapped_key.replace("*", layer_index)
-            if "weight_g" in name:
-                weight_type = "weight_g"
-            elif "weight_v" in name:
-                weight_type = "weight_v"
-            elif "bias" in name:
-                weight_type = "bias"
-            elif "weight" in name:
-                # TODO: don't match quantizer.weight_proj
-                weight_type = "weight"
-            else:
-                weight_type = None
-            if hf_dict is not None:
-                rename_dict(mapped_key, value, name, weight_type, hf_dict)
-            else:
-                set_recursively(mapped_key, value, name, weight_type, hf_model)
-            return is_used
-    return is_used
-
-
-def recursively_load_weights(fairseq_model, hf_model, is_headless):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.wav2vec2.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            is_used = load_wav2vec2_layer(name, value, hf_model)
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-@torch.no_grad()
-def convert_wav2vec2_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, config_path=None, dict_path=None, is_finetuned=True, is_seq_class=False
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = Wav2Vec2Config.from_pretrained(config_path)
-    else:
-        config = Wav2Vec2Config()
-
-    if is_seq_class:
-        id2label = read_txt_into_dict(dict_path)
-        config.id2label = id2label
-        hf_wav2vec = Wav2Vec2ForSequenceClassification(config)
-        feature_extractor = Wav2Vec2FeatureExtractor(
-            feature_size=1,
-            sampling_rate=16000,
-            padding_value=0,
-            do_normalize=True,
-            return_attention_mask=True,
-        )
-        feature_extractor.save_pretrained(pytorch_dump_folder_path)
-
-    elif is_finetuned:
-        if dict_path:
-            target_dict = Dictionary.load(dict_path)
-
-            # important change bos & pad token id since CTC symbol is <pad> and
-            # not <s> as in fairseq
-            config.bos_token_id = target_dict.pad_index
-            config.pad_token_id = target_dict.bos_index
-            config.eos_token_id = target_dict.eos_index
-            config.vocab_size = len(target_dict.symbols)
-            vocab_path = os.path.join(pytorch_dump_folder_path, "vocab.json")
-            if not os.path.isdir(pytorch_dump_folder_path):
-                logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(pytorch_dump_folder_path))
-                return
-            os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-            vocab_dict = target_dict.indices
-
-            # fairseq has the <pad> and <s> switched
-            vocab_dict["<pad>"] = 0
-            vocab_dict["<s>"] = 1
-            with open(vocab_path, "w", encoding="utf-8") as vocab_handle:
-                json.dump(vocab_dict, vocab_handle)
-            tokenizer = Wav2Vec2CTCTokenizer(
-                vocab_path,
-                unk_token=target_dict.unk_word,
-                pad_token=target_dict.pad_word,
-                bos_token=target_dict.bos_word,
-                eos_token=target_dict.eos_word,
-                word_delimiter_token="|",
-                do_lower_case=False,
-            )
-            return_attention_mask = True if config.feat_extract_norm == "layer" else False
-            feature_extractor = Wav2Vec2FeatureExtractor(
-                feature_size=1,
-                sampling_rate=16000,
-                padding_value=0,
-                do_normalize=True,
-                return_attention_mask=return_attention_mask,
-            )
-            processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
-            processor.save_pretrained(pytorch_dump_folder_path)
-
-        hf_wav2vec = Wav2Vec2ForCTC(config)
-    else:
-        hf_wav2vec = Wav2Vec2ForPreTraining(config)
-
-    if is_finetuned or is_seq_class:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-            [checkpoint_path], arg_overrides={"data": "/".join(dict_path.split("/")[:-1])}
-        )
-    else:
-        task_arg = argparse.Namespace(task="audio_pretraining")
-        task = fairseq.tasks.setup_task(task_arg)
-
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path], task=task)
-
-    model = model[0].eval()
-
-    recursively_load_weights(model, hf_wav2vec, not is_finetuned)
-
-    hf_wav2vec.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
-    )
-    parser.add_argument(
-        "--is_seq_class",
-        action="store_true",
-        help="Whether the model to convert is a fine-tuned sequence classification model or not",
-    )
-    args = parser.parse_args()
-
-    is_finetuned = not args.not_finetuned and not args.is_seq_class
-    convert_wav2vec2_checkpoint(
-        args.checkpoint_path,
-        args.pytorch_dump_folder_path,
-        args.config_path,
-        args.dict_path,
-        is_finetuned,
-        args.is_seq_class,
-    )
diff --git a/src/transformers/models/wav2vec2/convert_wav2vec2_original_s3prl_checkpoint_to_pytorch.py b/src/transformers/models/wav2vec2/convert_wav2vec2_original_s3prl_checkpoint_to_pytorch.py
deleted file mode 100644
index 1702bc5a4732..000000000000
--- a/src/transformers/models/wav2vec2/convert_wav2vec2_original_s3prl_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Hubert checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import (
-    Wav2Vec2Config,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2ForAudioFrameClassification,
-    Wav2Vec2ForSequenceClassification,
-    Wav2Vec2ForXVector,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def convert_classification(base_model_name, hf_config, downstream_dict):
-    model = Wav2Vec2ForSequenceClassification.from_pretrained(base_model_name, config=hf_config)
-    model.projector.weight.data = downstream_dict["projector.weight"]
-    model.projector.bias.data = downstream_dict["projector.bias"]
-    model.classifier.weight.data = downstream_dict["model.post_net.linear.weight"]
-    model.classifier.bias.data = downstream_dict["model.post_net.linear.bias"]
-    return model
-
-
-def convert_diarization(base_model_name, hf_config, downstream_dict):
-    model = Wav2Vec2ForAudioFrameClassification.from_pretrained(base_model_name, config=hf_config)
-    model.classifier.weight.data = downstream_dict["model.linear.weight"]
-    model.classifier.bias.data = downstream_dict["model.linear.bias"]
-    return model
-
-
-def convert_xvector(base_model_name, hf_config, downstream_dict):
-    model = Wav2Vec2ForXVector.from_pretrained(base_model_name, config=hf_config)
-    model.projector.weight.data = downstream_dict["connector.weight"]
-    model.projector.bias.data = downstream_dict["connector.bias"]
-    for i, kernel_size in enumerate(hf_config.tdnn_kernel):
-        model.tdnn[i].kernel.weight.data = downstream_dict[
-            f"model.framelevel_feature_extractor.module.{i}.kernel.weight"
-        ]
-        model.tdnn[i].kernel.bias.data = downstream_dict[f"model.framelevel_feature_extractor.module.{i}.kernel.bias"]
-
-    model.feature_extractor.weight.data = downstream_dict["model.utterancelevel_feature_extractor.linear1.weight"]
-    model.feature_extractor.bias.data = downstream_dict["model.utterancelevel_feature_extractor.linear1.bias"]
-    model.classifier.weight.data = downstream_dict["model.utterancelevel_feature_extractor.linear2.weight"]
-    model.classifier.bias.data = downstream_dict["model.utterancelevel_feature_extractor.linear2.bias"]
-    model.objective.weight.data = downstream_dict["objective.W"]
-    return model
-
-
-@torch.no_grad()
-def convert_s3prl_checkpoint(base_model_name, config_path, checkpoint_path, model_dump_path):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    checkpoint = torch.load(checkpoint_path, map_location="cpu")
-
-    downstream_dict = checkpoint["Downstream"]
-
-    hf_config = Wav2Vec2Config.from_pretrained(config_path)
-    hf_feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
-        base_model_name, return_attention_mask=True, do_normalize=False
-    )
-
-    arch = hf_config.architectures[0]
-    if arch.endswith("ForSequenceClassification"):
-        hf_model = convert_classification(base_model_name, hf_config, downstream_dict)
-    elif arch.endswith("ForAudioFrameClassification"):
-        hf_model = convert_diarization(base_model_name, hf_config, downstream_dict)
-    elif arch.endswith("ForXVector"):
-        hf_model = convert_xvector(base_model_name, hf_config, downstream_dict)
-    else:
-        raise NotImplementedError(f"S3PRL weights conversion is not supported for {arch}")
-
-    if hf_config.use_weighted_layer_sum:
-        hf_model.layer_weights.data = checkpoint["Featurizer"]["weights"]
-
-    hf_feature_extractor.save_pretrained(model_dump_path)
-    hf_model.save_pretrained(model_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--base_model_name", default=None, type=str, help="Name of the huggingface pretrained base model."
-    )
-    parser.add_argument("--config_path", default=None, type=str, help="Path to the huggingface classifier config.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to the s3prl checkpoint.")
-    parser.add_argument("--model_dump_path", default=None, type=str, help="Path to the final converted model.")
-    args = parser.parse_args()
-    convert_s3prl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
diff --git a/src/transformers/models/wav2vec2_bert/convert_wav2vec2_seamless_checkpoint.py b/src/transformers/models/wav2vec2_bert/convert_wav2vec2_seamless_checkpoint.py
deleted file mode 100644
index 33510654dcca..000000000000
--- a/src/transformers/models/wav2vec2_bert/convert_wav2vec2_seamless_checkpoint.py
+++ /dev/null
@@ -1,217 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Wav2Vec2Bert BERT checkpoint."""
-
-import argparse
-
-import torch
-import torchaudio
-from fairseq2.data import Collater
-from fairseq2.data.audio import WaveformToFbankConverter
-from fairseq2.nn.padding import get_seqs_and_padding_mask
-from seamless_communication.models.conformer_shaw import load_conformer_shaw_model
-
-from transformers import (
-    SeamlessM4TFeatureExtractor,
-    Wav2Vec2BertConfig,
-    Wav2Vec2BertModel,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-wav2vec_convert_list = [
-    ("encoder_frontend.model_dim_proj", "feature_projection.projection"),
-    ("encoder_frontend.post_extract_layer_norm", "feature_projection.layer_norm"),
-    ("encoder_frontend.pos_encoder.conv", "encoder.pos_conv_embed.conv"),
-    ("encoder.inner.layers", "encoder.layers"),
-    ("encoder.inner_layer_norm", "encoder.layer_norm"),
-    ("encoder.adaptor_layers", "adapter.layers"),
-    ("inner_proj", "intermediate_dense"),
-    ("self_attn.output_proj", "self_attn.linear_out"),
-    ("output_proj", "output_dense"),
-    ("self_attn.k_proj", "self_attn.linear_k"),
-    ("self_attn.v_proj", "self_attn.linear_v"),
-    ("self_attn.q_proj", "self_attn.linear_q"),
-    ("self_attn.sdpa.u_bias", "self_attn.pos_bias_u"),
-    ("self_attn.sdpa.v_bias", "self_attn.pos_bias_v"),
-    ("self_attn.sdpa.rel_k_embed", "self_attn.distance_embedding"),
-    ("self_attn.sdpa.r_proj", "self_attn.linear_pos"),
-    ("conv.pointwise_conv1", "conv_module.pointwise_conv1"),
-    ("conv.pointwise_conv2", "conv_module.pointwise_conv2"),
-    ("conv.depthwise_conv", "conv_module.depthwise_conv"),
-    ("conv.layer_norm", "conv_module.depthwise_layer_norm"),
-    ("conv_layer_norm", "conv_module.layer_norm"),
-    ("encoder.proj1", "intermediate_ffn.intermediate_dense"),
-    ("encoder.proj2", "intermediate_ffn.output_dense"),
-    ("encoder.layer_norm", "inner_layer_norm"),
-    ("masker.temporal_mask_embed", "masked_spec_embed"),
-]
-
-keys_to_remove = {
-    "quantizer.entry_proj",
-    "final_proj",
-    "final_target_proj",
-    "quantizer.entries",
-    "quantizer.num_updates",
-}
-
-
-def param_count(model):
-    return sum(p[1].numel() for p in model.named_parameters() if "final_proj" not in p[0])
-
-
-def _convert_model(
-    original_model,
-    hf_model,
-    convert_list,
-):
-    state_dict = original_model.state_dict()
-
-    for k, v in list(state_dict.items()):
-        new_key = k
-        for old_layer_name, new_layer_name in convert_list:
-            if old_layer_name in new_key:
-                new_key = new_key.replace(old_layer_name, new_layer_name)
-
-        # must do it by hand
-        if ".layer_norm" in new_key and new_key.split(".layer_norm")[0][-1].isnumeric():
-            new_key = new_key.replace("layer_norm", "final_layer_norm")
-
-        add_key = True
-        for key in keys_to_remove:
-            if key in new_key:
-                state_dict.pop(k)
-                add_key = False
-                break
-
-        if add_key:
-            state_dict[new_key] = state_dict.pop(k)
-
-    extra_keys = set(state_dict.keys()) - set(hf_model.state_dict().keys())
-    extra_keys = set({k for k in extra_keys if "num_updates" not in k})  # filter unecessary param
-    missing_keys = set(hf_model.state_dict().keys()) - set(state_dict.keys())
-    if len(extra_keys) != 0:
-        raise ValueError(f"extra keys found: {extra_keys}")
-    if len(missing_keys) != 0:
-        raise ValueError(f"missing keys: {missing_keys}")
-    hf_model.load_state_dict(state_dict, strict=True)
-    n_params = param_count(hf_model)
-
-    logger.info(f"model loaded: {round(n_params / 1e6, 1)}M params")
-
-    hf_model.eval()
-    del state_dict
-
-    return hf_model
-
-
-@torch.no_grad()
-def convert_wav2vec2_bert_checkpoint(
-    checkpoint_path,
-    pytorch_dump_folder_path,
-    config_path=None,
-    repo_id=None,
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = Wav2Vec2BertConfig.from_pretrained(config_path, hidden_act="swish")
-    else:
-        config = Wav2Vec2BertConfig(apply_spec_augment=False)
-
-    hf_wav2vec = Wav2Vec2BertModel(config)
-
-    model = load_conformer_shaw_model(checkpoint_path, dtype=torch.float32)
-    model.eval()
-
-    hf_wav2vec = _convert_model(model, hf_wav2vec, wav2vec_convert_list)
-
-    hf_wav2vec.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        hf_wav2vec.push_to_hub(repo_id, create_pr=True)
-
-    # save feature extractor
-    fe = SeamlessM4TFeatureExtractor(padding_value=1)
-    fe._set_processor_class("Wav2Vec2BertProcessor")
-    fe.save_pretrained(pytorch_dump_folder_path)
-
-    if repo_id:
-        fe.push_to_hub(repo_id, create_pr=True)
-
-    if args.audio_path:
-        waveform, sample_rate = torchaudio.load(args.audio_path)
-        waveform = torchaudio.functional.resample(waveform, sample_rate, fe.sampling_rate)
-
-        fbank_converter = WaveformToFbankConverter(
-            num_mel_bins=80,
-            waveform_scale=2**15,
-            channel_last=True,
-            standardize=True,
-            dtype=torch.float32,
-        )
-        collater = Collater(pad_value=1)
-
-        decoded_audio = {"waveform": waveform.T, "sample_rate": fe.sampling_rate, "format": -1}
-        src = collater(fbank_converter(decoded_audio))["fbank"]
-        seqs, padding_mask = get_seqs_and_padding_mask(src)
-
-        with torch.inference_mode():
-            seqs, padding_mask = model.encoder_frontend(seqs, padding_mask)
-            original_output, padding_mask = model.encoder(seqs, padding_mask)
-
-        hf_wav2vec.eval()
-
-        inputs = fe(waveform, return_tensors="pt", padding=True)
-        with torch.no_grad():
-            outputs = hf_wav2vec(**inputs)
-
-        torch.testing.assert_close(original_output, outputs.last_hidden_state, rtol=5e-3, atol=5e-3)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        help="Path to the output PyTorch model.",
-    )
-    parser.add_argument(
-        "--checkpoint_path", default="conformer_shaw", type=str, help="Path to seamless communication checkpoint"
-    )
-    parser.add_argument(
-        "--config_path",
-        default=None,
-        type=str,
-        help="Path to hf config.json of model to convert",
-    )
-    parser.add_argument("--repo_id", default=None, type=str, help="Push to this repo id if precised.")
-    parser.add_argument(
-        "--audio_path",
-        default=None,
-        type=str,
-        help="If specified, check that the original model and the converted model produce the same outputs.",
-    )
-
-    args = parser.parse_args()
-    convert_wav2vec2_bert_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.repo_id
-    )
diff --git a/src/transformers/models/wav2vec2_conformer/convert_wav2vec2_conformer_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/wav2vec2_conformer/convert_wav2vec2_conformer_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 8c435c6cd920..000000000000
--- a/src/transformers/models/wav2vec2_conformer/convert_wav2vec2_conformer_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,309 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Wav2Vec2Conformer checkpoint."""
-
-import argparse
-import json
-import os
-
-import fairseq
-import torch
-from fairseq.data import Dictionary
-
-from transformers import (
-    Wav2Vec2ConformerConfig,
-    Wav2Vec2ConformerForCTC,
-    Wav2Vec2ConformerForPreTraining,
-    Wav2Vec2CTCTokenizer,
-    Wav2Vec2FeatureExtractor,
-    Wav2Vec2Processor,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.linear_k": "encoder.layers.*.self_attn.linear_k",
-    "self_attn.linear_v": "encoder.layers.*.self_attn.linear_v",
-    "self_attn.linear_q": "encoder.layers.*.self_attn.linear_q",
-    "self_attn.pos_bias_u": "encoder.layers.*.self_attn.pos_bias_u",
-    "self_attn.pos_bias_v": "encoder.layers.*.self_attn.pos_bias_v",
-    "self_attn.linear_out": "encoder.layers.*.self_attn.linear_out",
-    "self_attn.linear_pos": "encoder.layers.*.self_attn.linear_pos",
-    "self_attn.rotary_emb": "encoder.embed_positions",
-    "self_attn_layer_norm": "encoder.layers.*.self_attn_layer_norm",
-    "conv_module.pointwise_conv1": "encoder.layers.*.conv_module.pointwise_conv1",
-    "conv_module.pointwise_conv2": "encoder.layers.*.conv_module.pointwise_conv2",
-    "conv_module.depthwise_conv": "encoder.layers.*.conv_module.depthwise_conv",
-    "conv_module.batch_norm": "encoder.layers.*.conv_module.batch_norm",
-    "conv_module.layer_norm": "encoder.layers.*.conv_module.layer_norm",
-    "ffn1.w_1": "encoder.layers.*.ffn1.intermediate_dense",
-    "ffn1.w_2": "encoder.layers.*.ffn1.output_dense",
-    "ffn1.layer_norm": "encoder.layers.*.ffn1_layer_norm",
-    "ffn2.w_1": "encoder.layers.*.ffn2.intermediate_dense",
-    "ffn2.w_2": "encoder.layers.*.ffn2.output_dense",
-    "ffn2.layer_norm": "encoder.layers.*.ffn2_layer_norm",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "quantizer.weight_proj": "quantizer.weight_proj",
-    "quantizer.vars": "quantizer.codevectors",
-    "project_q": "project_q",
-    "final_proj": "project_hid",
-    "w2v_encoder.proj": "lm_head",
-    "mask_emb": "masked_spec_embed",
-}
-TOP_LEVEL_KEYS = [
-    "lm_head",
-    "quantizer.weight_proj",
-    "quantizer.codevectors",
-    "project_q",
-    "project_hid",
-]
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    if hf_shape != value.shape:
-        raise ValueError(
-            f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-            f" {value.shape} for {full_name}"
-        )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    elif weight_type == "running_mean":
-        hf_pointer.running_mean.data = value
-    elif weight_type == "running_var":
-        hf_pointer.running_var.data = value
-    elif weight_type == "num_batches_tracked":
-        hf_pointer.num_batches_tracked.data = value
-    elif weight_type == "inv_freq":
-        hf_pointer.inv_freq.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model, is_headless):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.wav2vec2_conformer.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                mapped_key = "wav2vec2_conformer." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "pos_bias_u" in name:
-                        weight_type = None
-                    elif "pos_bias_v" in name:
-                        weight_type = None
-                    elif "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "bias" in name:
-                        weight_type = "bias"
-                    elif "weight" in name:
-                        # TODO: don't match quantizer.weight_proj
-                        weight_type = "weight"
-                    elif "running_mean" in name:
-                        weight_type = "running_mean"
-                    elif "inv_freq" in name:
-                        weight_type = "inv_freq"
-                    elif "running_var" in name:
-                        weight_type = "running_var"
-                    elif "num_batches_tracked" in name:
-                        weight_type = "num_batches_tracked"
-                    else:
-                        weight_type = None
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-# Copied from transformers.models.wav2vec2.convert_wav2vec2_original_pytorch_checkpoint_to_pytorch.load_conv_layer
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
-                raise ValueError(
-                    f"{full_name} has size {value.shape}, but"
-                    f" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found."
-                )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-@torch.no_grad()
-def convert_wav2vec2_conformer_checkpoint(
-    checkpoint_path, pytorch_dump_folder_path, config_path=None, dict_path=None, is_finetuned=True
-):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    if config_path is not None:
-        config = Wav2Vec2ConformerConfig.from_pretrained(config_path, hidden_act="swish")
-    else:
-        config = Wav2Vec2ConformerConfig()
-
-    if "rope" in checkpoint_path:
-        config.position_embeddings_type = "rotary"
-
-    if is_finetuned:
-        if dict_path:
-            target_dict = Dictionary.load(dict_path)
-
-            # important change bos & pad token id since CTC symbol is <pad> and
-            # not <s> as in fairseq
-            config.bos_token_id = target_dict.pad_index
-            config.pad_token_id = target_dict.bos_index
-            config.eos_token_id = target_dict.eos_index
-            config.vocab_size = len(target_dict.symbols)
-            vocab_path = os.path.join(pytorch_dump_folder_path, "vocab.json")
-            if not os.path.isdir(pytorch_dump_folder_path):
-                logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(pytorch_dump_folder_path))
-                return
-            os.makedirs(pytorch_dump_folder_path, exist_ok=True)
-            vocab_dict = target_dict.indices
-
-            # fairseq has the <pad> and <s> switched
-            vocab_dict["<pad>"] = 0
-            vocab_dict["<s>"] = 1
-            with open(vocab_path, "w", encoding="utf-8") as vocab_handle:
-                json.dump(vocab_dict, vocab_handle)
-            tokenizer = Wav2Vec2CTCTokenizer(
-                vocab_path,
-                unk_token=target_dict.unk_word,
-                pad_token=target_dict.pad_word,
-                bos_token=target_dict.bos_word,
-                eos_token=target_dict.eos_word,
-                word_delimiter_token="|",
-                do_lower_case=False,
-            )
-            return_attention_mask = True if config.feat_extract_norm == "layer" else False
-            feature_extractor = Wav2Vec2FeatureExtractor(
-                feature_size=1,
-                sampling_rate=16000,
-                padding_value=0,
-                do_normalize=True,
-                return_attention_mask=return_attention_mask,
-            )
-            processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
-            processor.save_pretrained(pytorch_dump_folder_path)
-
-        hf_wav2vec = Wav2Vec2ConformerForCTC(config)
-    else:
-        hf_wav2vec = Wav2Vec2ConformerForPreTraining(config)
-
-    if is_finetuned:
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
-            [checkpoint_path], arg_overrides={"data": "/".join(dict_path.split("/")[:-1])}
-        )
-    else:
-        task_arg = argparse.Namespace(task="audio_pretraining")
-        task = fairseq.tasks.setup_task(task_arg)
-
-        model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path], task=task)
-
-    model = model[0].eval()
-
-    recursively_load_weights(model, hf_wav2vec, not is_finetuned)
-
-    hf_wav2vec.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    parser.add_argument(
-        "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
-    )
-    args = parser.parse_args()
-    convert_wav2vec2_conformer_checkpoint(
-        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
-    )
diff --git a/src/transformers/models/wavlm/convert_wavlm_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/wavlm/convert_wavlm_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index e41ae0881d97..000000000000
--- a/src/transformers/models/wavlm/convert_wavlm_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,206 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert WavLM checkpoint."""
-
-import argparse
-
-import torch
-
-# Step 1. clone https://github.com/microsoft/unilm
-# Step 2. git checkout to https://github.com/microsoft/unilm/commit/b94ec76c36f02fb2b0bf0dcb0b8554a2185173cd
-# Step 3. cd unilm
-# Step 4. ln -s $(realpath wavlm/modules.py) ./  # create simlink
-# import classes
-from unilm.wavlm.WavLM import WavLM as WavLMOrig
-from unilm.wavlm.WavLM import WavLMConfig as WavLMConfigOrig
-
-from transformers import WavLMConfig, WavLMModel, logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-MAPPING = {
-    "post_extract_proj": "feature_projection.projection",
-    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
-    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
-    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
-    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
-    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
-    "self_attn.grep_linear": "encoder.layers.*.attention.gru_rel_pos_linear",
-    "self_attn.relative_attention_bias": "encoder.layers.*.attention.rel_attn_embed",
-    "self_attn.grep_a": "encoder.layers.*.attention.gru_rel_pos_const",
-    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
-    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
-    "fc2": "encoder.layers.*.feed_forward.output_dense",
-    "final_layer_norm": "encoder.layers.*.final_layer_norm",
-    "encoder.layer_norm": "encoder.layer_norm",
-    "w2v_model.layer_norm": "feature_projection.layer_norm",
-    "quantizer.weight_proj": "quantizer.weight_proj",
-    "quantizer.vars": "quantizer.codevectors",
-    "project_q": "project_q",
-    "final_proj": "project_hid",
-    "w2v_encoder.proj": "ctc_proj",
-    "mask_emb": "masked_spec_embed",
-}
-TOP_LEVEL_KEYS = [
-    "ctc_proj",
-    "quantizer.weight_proj",
-    "quantizer.codevectors",
-    "project_q",
-    "project_hid",
-]
-
-
-def set_recursively(hf_pointer, key, value, full_name, weight_type):
-    for attribute in key.split("."):
-        hf_pointer = getattr(hf_pointer, attribute)
-
-    if weight_type is not None:
-        hf_shape = getattr(hf_pointer, weight_type).shape
-    else:
-        hf_shape = hf_pointer.shape
-
-    assert hf_shape == value.shape, (
-        f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
-        f" {value.shape} for {full_name}"
-    )
-
-    if weight_type == "weight":
-        hf_pointer.weight.data = value
-    elif weight_type == "weight_g":
-        hf_pointer.weight_g.data = value
-    elif weight_type == "weight_v":
-        hf_pointer.weight_v.data = value
-    elif weight_type == "bias":
-        hf_pointer.bias.data = value
-    else:
-        hf_pointer.data = value
-
-    logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.")
-
-
-def recursively_load_weights(fairseq_model, hf_model):
-    unused_weights = []
-    fairseq_dict = fairseq_model.state_dict()
-
-    feature_extractor = hf_model.feature_extractor
-
-    for name, value in fairseq_dict.items():
-        is_used = False
-        if "conv_layers" in name:
-            load_conv_layer(
-                name,
-                value,
-                feature_extractor,
-                unused_weights,
-                hf_model.config.feat_extract_norm == "group",
-            )
-            is_used = True
-        else:
-            for key, mapped_key in MAPPING.items():
-                if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
-                    is_used = True
-                    if "*" in mapped_key:
-                        layer_index = name.split(key)[0].split(".")[-2]
-                        mapped_key = mapped_key.replace("*", layer_index)
-                    if "weight_g" in name:
-                        weight_type = "weight_g"
-                    elif "weight_v" in name:
-                        weight_type = "weight_v"
-                    elif "bias" in name and "relative_attention_bias" not in name:
-                        weight_type = "bias"
-                    elif "weight" in name:
-                        # TODO: don't match quantizer.weight_proj
-                        weight_type = "weight"
-                    else:
-                        weight_type = None
-
-                    set_recursively(hf_model, mapped_key, value, name, weight_type)
-                continue
-        if not is_used:
-            unused_weights.append(name)
-
-    logger.warning(f"Unused weights: {unused_weights}")
-
-
-def load_conv_layer(full_name, value, feature_extractor, unused_weights, use_group_norm):
-    name = full_name.split("conv_layers.")[-1]
-    items = name.split(".")
-    layer_id = int(items[0])
-    type_id = int(items[1])
-
-    if type_id == 0:
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.bias.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].conv.weight.data = value
-            logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
-    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
-        if "bias" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
-                f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
-                " found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.bias.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-        elif "weight" in name:
-            assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
-                f"{full_name} has size {value.shape}, but"
-                f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
-            )
-            feature_extractor.conv_layers[layer_id].layer_norm.weight.data = value
-            logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
-    else:
-        unused_weights.append(full_name)
-
-
-@torch.no_grad()
-def convert_wavlm_checkpoint(checkpoint_path, pytorch_dump_folder_path, config_path=None):
-    # load the pre-trained checkpoints
-    checkpoint = torch.load(checkpoint_path)
-    cfg = WavLMConfigOrig(checkpoint["cfg"])
-    model = WavLMOrig(cfg)
-    model.load_state_dict(checkpoint["model"])
-    model.eval()
-
-    if config_path is not None:
-        config = WavLMConfig.from_pretrained(config_path)
-    else:
-        config = WavLMConfig()
-
-    hf_wavlm = WavLMModel(config)
-
-    recursively_load_weights(model, hf_wavlm)
-
-    hf_wavlm.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
-    parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
-    args = parser.parse_args()
-    convert_wavlm_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
diff --git a/src/transformers/models/wavlm/convert_wavlm_original_s3prl_checkpoint_to_pytorch.py b/src/transformers/models/wavlm/convert_wavlm_original_s3prl_checkpoint_to_pytorch.py
deleted file mode 100644
index 447d4db67fc4..000000000000
--- a/src/transformers/models/wavlm/convert_wavlm_original_s3prl_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Hubert checkpoint."""
-
-import argparse
-
-import torch
-
-from transformers import (
-    Wav2Vec2FeatureExtractor,
-    WavLMConfig,
-    WavLMForAudioFrameClassification,
-    WavLMForSequenceClassification,
-    WavLMForXVector,
-    logging,
-)
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def convert_classification(base_model_name, hf_config, downstream_dict):
-    model = WavLMForSequenceClassification.from_pretrained(base_model_name, config=hf_config)
-    model.projector.weight.data = downstream_dict["projector.weight"]
-    model.projector.bias.data = downstream_dict["projector.bias"]
-    model.classifier.weight.data = downstream_dict["model.post_net.linear.weight"]
-    model.classifier.bias.data = downstream_dict["model.post_net.linear.bias"]
-    return model
-
-
-def convert_diarization(base_model_name, hf_config, downstream_dict):
-    model = WavLMForAudioFrameClassification.from_pretrained(base_model_name, config=hf_config)
-    model.classifier.weight.data = downstream_dict["model.linear.weight"]
-    model.classifier.bias.data = downstream_dict["model.linear.bias"]
-    return model
-
-
-def convert_xvector(base_model_name, hf_config, downstream_dict):
-    model = WavLMForXVector.from_pretrained(base_model_name, config=hf_config)
-    model.projector.weight.data = downstream_dict["connector.weight"]
-    model.projector.bias.data = downstream_dict["connector.bias"]
-    for i, kernel_size in enumerate(hf_config.tdnn_kernel):
-        model.tdnn[i].kernel.weight.data = downstream_dict[
-            f"model.framelevel_feature_extractor.module.{i}.kernel.weight"
-        ]
-        model.tdnn[i].kernel.bias.data = downstream_dict[f"model.framelevel_feature_extractor.module.{i}.kernel.bias"]
-
-    model.feature_extractor.weight.data = downstream_dict["model.utterancelevel_feature_extractor.linear1.weight"]
-    model.feature_extractor.bias.data = downstream_dict["model.utterancelevel_feature_extractor.linear1.bias"]
-    model.classifier.weight.data = downstream_dict["model.utterancelevel_feature_extractor.linear2.weight"]
-    model.classifier.bias.data = downstream_dict["model.utterancelevel_feature_extractor.linear2.bias"]
-    model.objective.weight.data = downstream_dict["objective.W"]
-    return model
-
-
-@torch.no_grad()
-def convert_s3prl_checkpoint(base_model_name, config_path, checkpoint_path, model_dump_path):
-    """
-    Copy/paste/tweak model's weights to transformers design.
-    """
-    checkpoint = torch.load(checkpoint_path, map_location="cpu")
-
-    downstream_dict = checkpoint["Downstream"]
-
-    hf_config = WavLMConfig.from_pretrained(config_path)
-    hf_feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
-        base_model_name, return_attention_mask=True, do_normalize=False
-    )
-
-    arch = hf_config.architectures[0]
-    if arch.endswith("ForSequenceClassification"):
-        hf_model = convert_classification(base_model_name, hf_config, downstream_dict)
-    elif arch.endswith("ForAudioFrameClassification"):
-        hf_model = convert_diarization(base_model_name, hf_config, downstream_dict)
-    elif arch.endswith("ForXVector"):
-        hf_model = convert_xvector(base_model_name, hf_config, downstream_dict)
-    else:
-        raise NotImplementedError(f"S3PRL weights conversion is not supported for {arch}")
-
-    if hf_config.use_weighted_layer_sum:
-        hf_model.layer_weights.data = checkpoint["Featurizer"]["weights"]
-
-    hf_feature_extractor.save_pretrained(model_dump_path)
-    hf_model.save_pretrained(model_dump_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--base_model_name", default=None, type=str, help="Name of the huggingface pretrained base model."
-    )
-    parser.add_argument("--config_path", default=None, type=str, help="Path to the huggingface classifier config.")
-    parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to the s3prl checkpoint.")
-    parser.add_argument("--model_dump_path", default=None, type=str, help="Path to the final converted model.")
-    args = parser.parse_args()
-    convert_s3prl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
diff --git a/src/transformers/models/whisper/convert_openai_to_hf.py b/src/transformers/models/whisper/convert_openai_to_hf.py
deleted file mode 100755
index bb63cd24cd61..000000000000
--- a/src/transformers/models/whisper/convert_openai_to_hf.py
+++ /dev/null
@@ -1,370 +0,0 @@
-#!/usr/bin/env python
-"""Converts a Whisper model in OpenAI format to Hugging Face format."""
-# Copyright 2022 The HuggingFace Inc. team and the OpenAI team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import io
-import json
-import os
-import tempfile
-import urllib
-import warnings
-from typing import Any, List, Optional, Tuple
-
-import torch
-from huggingface_hub.utils import insecure_hashlib
-from torch import nn
-from tqdm import tqdm
-
-from transformers import (
-    GenerationConfig,
-    WhisperConfig,
-    WhisperFeatureExtractor,
-    WhisperForConditionalGeneration,
-    WhisperProcessor,
-    WhisperTokenizer,
-    WhisperTokenizerFast,
-)
-from transformers.models.whisper.tokenization_whisper import LANGUAGES, bytes_to_unicode
-from transformers.utils.import_utils import _is_package_available
-
-
-_MODELS = {
-    "tiny.en": "https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt",
-    "tiny": "https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt",
-    "base.en": "https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt",
-    "base": "https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt",
-    "small.en": "https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt",
-    "small": "https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt",
-    "medium.en": "https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt",
-    "medium": "https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt",
-    "large": "https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt",
-    "large-v2": "https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt",
-    "large-v3": "https://openaipublic.azureedge.net/main/whisper/models/e5b1a55b89c1367dacf97e3e19bfd829a01529dbfdeefa8caeb59b3f1b81dadb/large-v3.pt",
-}
-
-
-_TOKENIZERS = {
-    "multilingual": "https://raw.githubusercontent.com/openai/whisper/main/whisper/assets/multilingual.tiktoken",
-    "english": "https://raw.githubusercontent.com/openai/whisper/main/whisper/assets/gpt2.tiktoken",
-}
-
-
-def _get_generation_config(
-    is_multilingual: bool,
-    num_languages: int = 100,
-    openai_version: Optional[str] = None,
-) -> GenerationConfig:
-    """
-    Loads the appropriate generation config from HF repo
-    """
-    if openai_version is not None:
-        repo = f"openai/whisper-{openai_version}"
-    elif not is_multilingual:
-        repo = "openai/whisper-medium.en"
-    elif num_languages < 100:
-        repo = "openai/whisper-large-v2"
-    else:
-        repo = "openai/whisper-large-v3"
-
-    gen_cfg = GenerationConfig.from_pretrained(repo)
-    if openai_version is None:
-        gen_cfg.alignment_heads = None
-        warnings.warn(
-            "Alignment heads have not been included in the generation config, since they are available "
-            "only for the original OpenAI checkpoints."
-            "If you want to use word-level timestamps with a custom version of Whisper,"
-            "see https://github.com/openai/whisper/blob/main/notebooks/Multilingual_ASR.ipynb"
-            "for the example of how to produce word-level timestamps manually."
-        )
-
-    return gen_cfg
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = ["layers", "blocks"]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-WHISPER_MAPPING = {
-    "blocks": "layers",
-    "mlp.0": "fc1",
-    "mlp.2": "fc2",
-    "mlp_ln": "final_layer_norm",
-    ".attn.query": ".self_attn.q_proj",
-    ".attn.key": ".self_attn.k_proj",
-    ".attn.value": ".self_attn.v_proj",
-    ".attn_ln": ".self_attn_layer_norm",
-    ".attn.out": ".self_attn.out_proj",
-    ".cross_attn.query": ".encoder_attn.q_proj",
-    ".cross_attn.key": ".encoder_attn.k_proj",
-    ".cross_attn.value": ".encoder_attn.v_proj",
-    ".cross_attn_ln": ".encoder_attn_layer_norm",
-    ".cross_attn.out": ".encoder_attn.out_proj",
-    "decoder.ln.": "decoder.layer_norm.",
-    "encoder.ln.": "encoder.layer_norm.",
-    "token_embedding": "embed_tokens",
-    "encoder.positional_embedding": "encoder.embed_positions.weight",
-    "decoder.positional_embedding": "decoder.embed_positions.weight",
-    "ln_post": "layer_norm",
-}
-
-
-def rename_keys(s_dict):
-    keys = list(s_dict.keys())
-    for key in keys:
-        new_key = key
-        for k, v in WHISPER_MAPPING.items():
-            if k in key:
-                new_key = new_key.replace(k, v)
-
-        print(f"{key} -> {new_key}")
-
-        s_dict[new_key] = s_dict.pop(key)
-    return s_dict
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-def _download(url: str, root: str) -> Any:
-    os.makedirs(root, exist_ok=True)
-    filename = os.path.basename(url)
-
-    expected_sha256 = url.split("/")[-2]
-    download_target = os.path.join(root, filename)
-
-    if os.path.exists(download_target) and not os.path.isfile(download_target):
-        raise RuntimeError(f"{download_target} exists and is not a regular file")
-
-    if os.path.isfile(download_target):
-        model_bytes = open(download_target, "rb").read()
-        if insecure_hashlib.sha256(model_bytes).hexdigest() == expected_sha256:
-            return torch.load(io.BytesIO(model_bytes))
-        else:
-            warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file")
-
-    with urllib.request.urlopen(url) as source, open(download_target, "wb") as output:
-        with tqdm(
-            total=int(source.info().get("Content-Length")), ncols=80, unit="iB", unit_scale=True, unit_divisor=1024
-        ) as loop:
-            while True:
-                buffer = source.read(8192)
-                if not buffer:
-                    break
-
-                output.write(buffer)
-                loop.update(len(buffer))
-
-    model_bytes = open(download_target, "rb").read()
-    if insecure_hashlib.sha256(model_bytes).hexdigest() != expected_sha256:
-        raise RuntimeError(
-            "Model has been downloaded but the SHA256 checksum does not match. Please retry loading the model."
-        )
-
-    return torch.load(io.BytesIO(model_bytes))
-
-
-def convert_openai_whisper_to_tfms(
-    checkpoint_path, pytorch_dump_folder_path
-) -> Tuple[WhisperForConditionalGeneration, bool, int]:
-    if ".pt" not in checkpoint_path:
-        root = os.path.dirname(pytorch_dump_folder_path) or "."
-        original_checkpoint = _download(_MODELS[checkpoint_path], root)
-        openai_version = checkpoint_path
-    else:
-        original_checkpoint = torch.load(checkpoint_path, map_location="cpu")
-        openai_version = None
-
-    dimensions = original_checkpoint["dims"]
-    state_dict = original_checkpoint["model_state_dict"]
-    proj_out_weights = state_dict["decoder.token_embedding.weight"]
-    remove_ignore_keys_(state_dict)
-    rename_keys(state_dict)
-    tie_embeds = True
-    ffn_dim = state_dict["decoder.layers.0.fc1.weight"].shape[0]
-
-    # a hacky way to properly set up the bos/eos/pad token ids in the model
-    endoftext_id = 50257 if dimensions["n_vocab"] > 51865 else 50256
-
-    config = WhisperConfig(
-        vocab_size=dimensions["n_vocab"],
-        encoder_ffn_dim=ffn_dim,
-        decoder_ffn_dim=ffn_dim,
-        num_mel_bins=dimensions["n_mels"],
-        d_model=dimensions["n_audio_state"],
-        max_target_positions=dimensions["n_text_ctx"],
-        encoder_layers=dimensions["n_audio_layer"],
-        encoder_attention_heads=dimensions["n_audio_head"],
-        decoder_layers=dimensions["n_text_layer"],
-        decoder_attention_heads=dimensions["n_text_head"],
-        max_source_positions=dimensions["n_audio_ctx"],
-        eos_token_id=endoftext_id,
-        bos_token_id=endoftext_id,
-        pad_token_id=endoftext_id,
-        decoder_start_token_id=endoftext_id + 1,
-    )
-
-    model = WhisperForConditionalGeneration(config)
-    missing, unexpected = model.model.load_state_dict(state_dict, strict=False)
-    if len(missing) > 0 and not set(missing) <= {
-        "encoder.embed_positions.weights",
-        "decoder.embed_positions.weights",
-    }:
-        raise ValueError(
-            "Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,"
-            f" but all the following weights are missing {missing}"
-        )
-
-    if tie_embeds:
-        model.proj_out = make_linear_from_emb(model.model.decoder.embed_tokens)
-    else:
-        model.proj_out.weight.data = proj_out_weights
-
-    # determine those parameters from a model checkpoint as Whisper repo does
-    is_multilingual = model.config.vocab_size >= 51865
-    num_languages = model.config.vocab_size - 51765 - int(is_multilingual)
-
-    model.generation_config = _get_generation_config(
-        is_multilingual,
-        num_languages,
-        openai_version,
-    )
-
-    return model, is_multilingual, num_languages
-
-
-# Adapted from https://github.com/openai/tiktoken/issues/60#issuecomment-1499977960
-def _bpe(mergeable_ranks, token: bytes, max_rank=None) -> List[bytes]:
-    parts = [bytes([b]) for b in token]
-    while True:
-        min_idx = None
-        min_rank = None
-        for i, pair in enumerate(zip(parts[:-1], parts[1:])):
-            rank = mergeable_ranks.get(pair[0] + pair[1])
-            if rank is not None and (min_rank is None or rank < min_rank):
-                min_idx = i
-                min_rank = rank
-        if min_rank is None or (max_rank is not None and min_rank >= max_rank):
-            break
-        assert min_idx is not None
-        parts = parts[:min_idx] + [parts[min_idx] + parts[min_idx + 1]] + parts[min_idx + 2 :]
-    return parts
-
-
-def convert_tiktoken_bpe_to_hf(tiktoken_url: str):
-    bpe_ranks = load_tiktoken_bpe(tiktoken_url)
-    byte_encoder = bytes_to_unicode()
-
-    def token_bytes_to_string(b):
-        return "".join([byte_encoder[ord(char)] for char in b.decode("latin-1")])
-
-    merges = []
-    vocab = {}
-    for token, rank in bpe_ranks.items():
-        vocab[token_bytes_to_string(token)] = rank
-        if len(token) == 1:
-            continue
-        merged = tuple(_bpe(bpe_ranks, token, max_rank=rank))
-        if len(merged) == 2:  # account for empty token
-            merges.append(" ".join(map(token_bytes_to_string, merged)))
-    return vocab, merges
-
-
-def convert_tiktoken_to_hf(
-    multilingual: bool = True, num_languages: int = 100, time_precision=0.02
-) -> WhisperTokenizer:
-    # requires whisper, unless we use the path to the tiktoken file
-    tiktoken_tokenizer_path = _TOKENIZERS["multilingual" if multilingual else "english"]
-    start_of_transcript = ["<|endoftext|>", "<|startoftranscript|>"]
-    control_tokens = [
-        "<|translate|>",
-        "<|transcribe|>",
-        "<|startoflm|>",
-        "<|startofprev|>",
-        "<|nospeech|>",
-        "<|notimestamps|>",
-    ]
-    # these are special tokens, not normalized
-    language_tokens = [f"<|{k}|>" for k in list(LANGUAGES)[:num_languages]]
-    # These are not special but normalized
-    timestamp_tokens = [("<|%.2f|>" % (i * time_precision)) for i in range(1500 + 1)]
-
-    vocab, merges = convert_tiktoken_bpe_to_hf(tiktoken_tokenizer_path)
-
-    with tempfile.TemporaryDirectory() as tmpdirname:
-        vocab_file = f"{tmpdirname}/vocab.json"
-        merge_file = f"{tmpdirname}/merges.txt"
-        with open(vocab_file, "w", encoding="utf-8") as f:
-            f.write(json.dumps(vocab, indent=2, sort_keys=True, ensure_ascii=False) + "\n")
-
-        with open(merge_file, "w", encoding="utf-8") as writer:
-            writer.write("#version: 0.2\n")
-            for bpe_tokens in merges:
-                writer.write(bpe_tokens + "\n")
-
-        hf_tokenizer = WhisperTokenizer(vocab_file, merge_file)
-
-    hf_tokenizer.add_tokens(start_of_transcript + language_tokens + control_tokens, special_tokens=True)
-    hf_tokenizer.add_tokens(timestamp_tokens, special_tokens=False)
-    return hf_tokenizer
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # # Required parameters
-    parser.add_argument("--checkpoint_path", type=str, help="Path to the downloaded checkpoints")
-    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    parser.add_argument(
-        "--convert_preprocessor",
-        type=bool,
-        default=False,
-        help="Whether or not the preprocessor (tokenizer + feature extractor) should be converted along with the model.",
-    )
-    args = parser.parse_args()
-
-    model, is_multilingual, num_languages = convert_openai_whisper_to_tfms(
-        args.checkpoint_path, args.pytorch_dump_folder_path
-    )
-
-    if args.convert_preprocessor:
-        try:
-            if not _is_package_available("tiktoken"):
-                raise ModuleNotFoundError(
-                    """`tiktoken` is not installed, use `pip install tiktoken` to convert the tokenizer"""
-                )
-        except Exception as e:
-            print(e)
-        else:
-            from tiktoken.load import load_tiktoken_bpe
-
-            tokenizer = convert_tiktoken_to_hf(is_multilingual, num_languages)
-            feature_extractor = WhisperFeatureExtractor(
-                feature_size=model.config.num_mel_bins,
-                # the rest of default parameters are the same as hardcoded in openai/whisper
-            )
-            processor = WhisperProcessor(tokenizer=tokenizer, feature_extractor=feature_extractor)
-            processor.save_pretrained(args.pytorch_dump_folder_path)
-
-            # save fast tokenizer as well
-            fast_tokenizer = WhisperTokenizerFast.from_pretrained(args.pytorch_dump_folder_path)
-            fast_tokenizer.save_pretrained(args.pytorch_dump_folder_path, legacy_format=False)
-
-    model.save_pretrained(args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/x_clip/convert_x_clip_original_pytorch_to_hf.py b/src/transformers/models/x_clip/convert_x_clip_original_pytorch_to_hf.py
deleted file mode 100644
index 8ff878f2cc9f..000000000000
--- a/src/transformers/models/x_clip/convert_x_clip_original_pytorch_to_hf.py
+++ /dev/null
@@ -1,386 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-
-import gdown
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_download
-
-from transformers import (
-    CLIPTokenizer,
-    CLIPTokenizerFast,
-    VideoMAEImageProcessor,
-    XCLIPConfig,
-    XCLIPModel,
-    XCLIPProcessor,
-    XCLIPTextConfig,
-    XCLIPVisionConfig,
-)
-
-
-def get_xclip_config(model_name, num_frames):
-    text_config = XCLIPTextConfig()
-
-    # derive patch size from model name
-    start_idx = model_name.find("patch")
-    patch_size = int(model_name[start_idx + len("patch") : start_idx + len("patch") + 2])
-    vision_config = XCLIPVisionConfig(patch_size=patch_size, num_frames=num_frames)
-
-    if "large" in model_name:
-        text_config.hidden_size = 768
-        text_config.intermediate_size = 3072
-        text_config.num_attention_heads = 12
-
-        vision_config.hidden_size = 1024
-        vision_config.intermediate_size = 4096
-        vision_config.num_attention_heads = 16
-        vision_config.num_hidden_layers = 24
-        vision_config.mit_hidden_size = 768
-        vision_config.mit_intermediate_size = 3072
-
-    if model_name == "xclip-large-patch14-16-frames":
-        vision_config.image_size = 336
-
-    config = XCLIPConfig.from_text_vision_configs(text_config, vision_config)
-
-    if "large" in model_name:
-        config.projection_dim = 768
-
-    return config
-
-
-def rename_key(name):
-    # text encoder
-    if name == "token_embedding.weight":
-        name = name.replace("token_embedding.weight", "text_model.embeddings.token_embedding.weight")
-    if name == "positional_embedding":
-        name = name.replace("positional_embedding", "text_model.embeddings.position_embedding.weight")
-    if "ln_1" in name:
-        name = name.replace("ln_1", "layer_norm1")
-    if "ln_2" in name:
-        name = name.replace("ln_2", "layer_norm2")
-    if "c_fc" in name:
-        name = name.replace("c_fc", "fc1")
-    if "c_proj" in name:
-        name = name.replace("c_proj", "fc2")
-    if name.startswith("transformer.resblocks"):
-        name = name.replace("transformer.resblocks", "text_model.encoder.layers")
-    if "attn.out_proj" in name and "message" not in name:
-        name = name.replace("attn.out_proj", "self_attn.out_proj")
-    if "ln_final" in name:
-        name = name.replace("ln_final", "text_model.final_layer_norm")
-    # visual encoder
-    if name == "visual.class_embedding":
-        name = name.replace("visual.class_embedding", "vision_model.embeddings.class_embedding")
-    if name == "visual.positional_embedding":
-        name = name.replace("visual.positional_embedding", "vision_model.embeddings.position_embedding.weight")
-    if name.startswith("visual.transformer.resblocks"):
-        name = name.replace("visual.transformer.resblocks", "vision_model.encoder.layers")
-    if "visual.conv1" in name:
-        name = name.replace("visual.conv1", "vision_model.embeddings.patch_embedding")
-    if "visual.ln_pre" in name:
-        name = name.replace("visual.ln_pre", "vision_model.pre_layernorm")
-    if "visual.ln_post" in name:
-        name = name.replace("visual.ln_post", "vision_model.post_layernorm")
-    if "visual.proj" in name:
-        name = name.replace("visual.proj", "visual_projection.weight")
-    if "text_projection" in name:
-        name = name.replace("text_projection", "text_projection.weight")
-    # things on top
-    if "prompts_visual_proj" in name:
-        name = name.replace("prompts_visual_proj", "prompts_visual_projection")
-    if "prompts_visual_ln" in name:
-        name = name.replace("prompts_visual_ln", "prompts_visual_layernorm")
-    # mit
-    if name == "mit.positional_embedding":
-        name = name.replace("positional", "position")
-    if name.startswith("mit.resblocks"):
-        name = name.replace("mit.resblocks", "mit.encoder.layers")
-    # prompts generator
-    if name.startswith("prompts_generator.norm"):
-        name = name.replace("prompts_generator.norm", "prompts_generator.layernorm")
-
-    return name
-
-
-def convert_state_dict(orig_state_dict, config):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "attn.in_proj" in key:
-            key_split = key.split(".")
-            if key.startswith("visual"):
-                layer_num = key_split[3]
-                dim = config.vision_config.hidden_size
-                if "message_attn" in key:
-                    if "weight" in key:
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.message_attn.q_proj.weight"] = val[
-                            :dim, :
-                        ]
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.message_attn.k_proj.weight"] = val[
-                            dim : dim * 2, :
-                        ]
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.message_attn.v_proj.weight"] = val[
-                            -dim:, :
-                        ]
-                    else:
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.message_attn.q_proj.bias"] = val[
-                            :dim
-                        ]
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.message_attn.k_proj.bias"] = val[
-                            dim : dim * 2
-                        ]
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.message_attn.v_proj.bias"] = val[
-                            -dim:
-                        ]
-                else:
-                    if "weight" in key:
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.self_attn.q_proj.weight"] = val[
-                            :dim, :
-                        ]
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.self_attn.k_proj.weight"] = val[
-                            dim : dim * 2, :
-                        ]
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.self_attn.v_proj.weight"] = val[
-                            -dim:, :
-                        ]
-                    else:
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.self_attn.q_proj.bias"] = val[:dim]
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.self_attn.k_proj.bias"] = val[
-                            dim : dim * 2
-                        ]
-                        orig_state_dict[f"vision_model.encoder.layers.{layer_num}.self_attn.v_proj.bias"] = val[-dim:]
-            elif key.startswith("mit"):
-                layer_num = key_split[2]
-                dim = config.vision_config.mit_hidden_size
-                if "weight" in key:
-                    orig_state_dict[f"mit.encoder.layers.{layer_num}.self_attn.q_proj.weight"] = val[:dim, :]
-                    orig_state_dict[f"mit.encoder.layers.{layer_num}.self_attn.k_proj.weight"] = val[dim : dim * 2, :]
-                    orig_state_dict[f"mit.encoder.layers.{layer_num}.self_attn.v_proj.weight"] = val[-dim:, :]
-                else:
-                    orig_state_dict[f"mit.encoder.layers.{layer_num}.self_attn.q_proj.bias"] = val[:dim]
-                    orig_state_dict[f"mit.encoder.layers.{layer_num}.self_attn.k_proj.bias"] = val[dim : dim * 2]
-                    orig_state_dict[f"mit.encoder.layers.{layer_num}.self_attn.v_proj.bias"] = val[-dim:]
-            else:
-                layer_num = key_split[2]
-                dim = config.text_config.hidden_size
-                if "weight" in key:
-                    orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.q_proj.weight"] = val[:dim, :]
-                    orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.k_proj.weight"] = val[
-                        dim : dim * 2, :
-                    ]
-                    orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.v_proj.weight"] = val[-dim:, :]
-                else:
-                    orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.q_proj.bias"] = val[:dim]
-                    orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.k_proj.bias"] = val[
-                        dim : dim * 2
-                    ]
-                    orig_state_dict[f"text_model.encoder.layers.{layer_num}.self_attn.v_proj.bias"] = val[-dim:]
-        else:
-            new_key_name = rename_key(key)
-            if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
-                val = val.T
-            orig_state_dict[new_key_name] = val
-
-    return orig_state_dict
-
-
-def prepare_video(num_frames):
-    if num_frames == 8:
-        filename = "eating_spaghetti_8_frames.npy"
-    elif num_frames == 16:
-        filename = "eating_spaghetti.npy"
-    elif num_frames == 32:
-        filename = "eating_spaghetti_32_frames.npy"
-    file = hf_hub_download(
-        repo_id="hf-internal-testing/spaghetti-video",
-        filename=filename,
-        repo_type="dataset",
-    )
-    video = np.load(file)
-    return list(video)
-
-
-def convert_xclip_checkpoint(model_name, pytorch_dump_folder_path=None, push_to_hub=False):
-    model_to_url = {
-        # fully supervised kinetics-400 checkpoints
-        "xclip-base-patch32": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth",
-        "xclip-base-patch32-16-frames": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth"
-        ),
-        "xclip-base-patch16": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth",
-        "xclip-base-patch16-16-frames": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth"
-        ),
-        "xclip-large-patch14": "https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb",
-        "xclip-large-patch14-16-frames": "https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f",
-        # fully supervised kinetics-600 checkpoints
-        "xclip-base-patch16-kinetics-600": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth"
-        ),
-        "xclip-base-patch16-kinetics-600-16-frames": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth"
-        ),
-        "xclip-large-patch14-kinetics-600": "https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be",
-        # few shot
-        "xclip-base-patch16-hmdb-2-shot": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth"
-        ),
-        "xclip-base-patch16-hmdb-4-shot": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth"
-        ),
-        "xclip-base-patch16-hmdb-8-shot": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth"
-        ),
-        "xclip-base-patch16-hmdb-16-shot": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth"
-        ),
-        "xclip-base-patch16-ucf-2-shot": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth"
-        ),
-        "xclip-base-patch16-ucf-4-shot": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth"
-        ),
-        "xclip-base-patch16-ucf-8-shot": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth"
-        ),
-        "xclip-base-patch16-ucf-16-shot": (
-            "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth"
-        ),
-        # zero shot
-        "xclip-base-patch16-zero-shot": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth",
-    }
-
-    checkpoint_url = model_to_url[model_name]
-    num_frames = 8
-    if "16-frames" in model_name:
-        num_frames = 16
-    elif "shot" in model_name:
-        num_frames = 32
-
-    config = get_xclip_config(model_name, num_frames)
-    model = XCLIPModel(config)
-    model.eval()
-
-    if "drive" in checkpoint_url:
-        output = "pytorch_model.bin"
-        gdown.cached_download(checkpoint_url, output, quiet=False)
-        state_dict = torch.load(output, map_location="cpu")["model"]
-    else:
-        state_dict = torch.hub.load_state_dict_from_url(checkpoint_url)["model"]
-
-    state_dict = convert_state_dict(state_dict, config)
-
-    model = XCLIPModel(config)
-    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
-    assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
-    model.eval()
-
-    size = 336 if model_name == "xclip-large-patch14-16-frames" else 224
-    image_processor = VideoMAEImageProcessor(size=size)
-    slow_tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32")
-    fast_tokenizer = CLIPTokenizerFast.from_pretrained("openai/clip-vit-base-patch32")
-    processor = XCLIPProcessor(image_processor=image_processor, tokenizer=fast_tokenizer)
-
-    video = prepare_video(num_frames)
-    inputs = processor(
-        text=["playing sports", "eating spaghetti", "go shopping"], videos=video, return_tensors="pt", padding=True
-    )
-
-    print("Shape of pixel values:", inputs.pixel_values.shape)
-
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    # Verify outputs
-    logits_per_video = outputs.logits_per_video
-    probs = logits_per_video.softmax(dim=1)
-    print("Probs:", probs)
-    # kinetics-400
-    if model_name == "xclip-base-patch32":
-        expected_probs = torch.tensor([[0.0019, 0.9951, 0.0030]])
-    elif model_name == "xclip-base-patch32-16-frames":
-        expected_probs = torch.tensor([[7.0999e-04, 9.9883e-01, 4.5580e-04]])
-    elif model_name == "xclip-base-patch16":
-        expected_probs = torch.tensor([[0.0083, 0.9681, 0.0236]])
-    elif model_name == "xclip-base-patch16-16-frames":
-        expected_probs = torch.tensor([[7.6937e-04, 9.9728e-01, 1.9473e-03]])
-    elif model_name == "xclip-large-patch14":
-        expected_probs = torch.tensor([[0.0062, 0.9864, 0.0075]])
-    elif model_name == "xclip-large-patch14-16-frames":
-        expected_probs = torch.tensor([[3.3877e-04, 9.9937e-01, 2.8888e-04]])
-    # kinetics-600
-    elif model_name == "xclip-base-patch16-kinetics-600":
-        expected_probs = torch.tensor([[0.0555, 0.8914, 0.0531]])
-    elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
-        expected_probs = torch.tensor([[3.8554e-04, 9.9929e-01, 3.2754e-04]])
-    elif model_name == "xclip-large-patch14-kinetics-600":
-        expected_probs = torch.tensor([[0.0036, 0.9920, 0.0045]])
-    # few shot
-    elif model_name == "xclip-base-patch16-hmdb-2-shot":
-        expected_probs = torch.tensor([[7.1890e-06, 9.9994e-01, 5.6559e-05]])
-    elif model_name == "xclip-base-patch16-hmdb-4-shot":
-        expected_probs = torch.tensor([[1.0320e-05, 9.9993e-01, 6.2435e-05]])
-    elif model_name == "xclip-base-patch16-hmdb-8-shot":
-        expected_probs = torch.tensor([[4.1377e-06, 9.9990e-01, 9.8386e-05]])
-    elif model_name == "xclip-base-patch16-hmdb-16-shot":
-        expected_probs = torch.tensor([[4.1347e-05, 9.9962e-01, 3.3411e-04]])
-    elif model_name == "xclip-base-patch16-ucf-2-shot":
-        expected_probs = torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]])
-    elif model_name == "xclip-base-patch16-ucf-4-shot":
-        expected_probs = torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]])
-    elif model_name == "xclip-base-patch16-ucf-8-shot":
-        expected_probs = torch.tensor([[0.0027, 0.9904, 0.0070]])
-    elif model_name == "xclip-base-patch16-ucf-16-shot":
-        expected_probs = torch.tensor([[9.8219e-04, 9.9593e-01, 3.0863e-03]])
-    # zero shot
-    elif model_name == "xclip-base-patch16-zero-shot":
-        expected_probs = torch.tensor([[3.5082e-04, 9.9785e-01, 1.7966e-03]])
-    else:
-        raise ValueError(f"Model name {model_name} not supported")
-    assert torch.allclose(probs, expected_probs, atol=1e-3)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
-        model.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        print("Pushing model, processor and slow tokenizer files to the hub...")
-        model.push_to_hub(model_name, organization="nielsr")
-        processor.push_to_hub(model_name, organization="nielsr")
-        slow_tokenizer.push_to_hub(model_name, organization="nielsr")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="xclip-base-patch32",
-        type=str,
-        help="Name of the model.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/xglm/convert_xglm_original_ckpt_to_trfms.py b/src/transformers/models/xglm/convert_xglm_original_ckpt_to_trfms.py
deleted file mode 100644
index f8b5dba3c1e4..000000000000
--- a/src/transformers/models/xglm/convert_xglm_original_ckpt_to_trfms.py
+++ /dev/null
@@ -1,68 +0,0 @@
-import argparse
-from argparse import Namespace
-
-import torch
-from torch import nn
-
-from transformers import XGLMConfig, XGLMForCausalLM
-
-
-def remove_ignore_keys_(state_dict):
-    ignore_keys = [
-        "decoder.version",
-        "decoder.output_projection.weight",
-        "_float_tensor",
-        "decoder.embed_positions._float_tensor",
-    ]
-    for k in ignore_keys:
-        state_dict.pop(k, None)
-
-
-def make_linear_from_emb(emb):
-    vocab_size, emb_size = emb.weight.shape
-    lin_layer = nn.Linear(vocab_size, emb_size, bias=False)
-    lin_layer.weight.data = emb.weight.data
-    return lin_layer
-
-
-def convert_fairseq_xglm_checkpoint_from_disk(checkpoint_path):
-    checkpoint = torch.load(checkpoint_path, map_location="cpu")
-    args = Namespace(**checkpoint["cfg"]["model"])
-    state_dict = checkpoint["model"]
-    remove_ignore_keys_(state_dict)
-    vocab_size = state_dict["decoder.embed_tokens.weight"].shape[0]
-
-    state_dict = {key.replace("decoder", "model"): val for key, val in state_dict.items()}
-
-    config = XGLMConfig(
-        vocab_size=vocab_size,
-        max_position_embeddings=args.max_target_positions,
-        num_layers=args.decoder_layers,
-        attention_heads=args.decoder_attention_heads,
-        ffn_dim=args.decoder_ffn_embed_dim,
-        d_model=args.decoder_embed_dim,
-        layerdrop=args.decoder_layerdrop,
-        dropout=args.dropout,
-        attention_dropout=args.attention_dropout,
-        activation_dropout=args.activation_dropout,
-        activation_function="gelu",
-        scale_embedding=not args.no_scale_embedding,
-        tie_word_embeddings=args.share_decoder_input_output_embed,
-    )
-
-    model = XGLMForCausalLM(config)
-    missing = model.load_state_dict(state_dict, strict=False)
-    print(missing)
-    model.lm_head = make_linear_from_emb(model.model.embed_tokens)
-
-    return model
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument("fairseq_path", type=str, help="path to a model.pt on local filesystem.")
-    parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
-    args = parser.parse_args()
-    model = convert_fairseq_xglm_checkpoint_from_disk(args.fairseq_path)
-    model.save_pretrained(args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/xlm/convert_xlm_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/xlm/convert_xlm_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100755
index 71c3a1f989fd..000000000000
--- a/src/transformers/models/xlm/convert_xlm_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert OpenAI GPT checkpoint."""
-
-import argparse
-import json
-
-import numpy
-import torch
-
-from transformers.models.xlm.tokenization_xlm import VOCAB_FILES_NAMES
-from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging
-
-
-logging.set_verbosity_info()
-
-
-def convert_xlm_checkpoint_to_pytorch(xlm_checkpoint_path, pytorch_dump_folder_path):
-    # Load checkpoint
-    chkpt = torch.load(xlm_checkpoint_path, map_location="cpu")
-
-    state_dict = chkpt["model"]
-
-    # We have the base model one level deeper than the original XLM repository
-    two_levels_state_dict = {}
-    for k, v in state_dict.items():
-        if "pred_layer" in k:
-            two_levels_state_dict[k] = v
-        else:
-            two_levels_state_dict["transformer." + k] = v
-
-    config = chkpt["params"]
-    config = {n: v for n, v in config.items() if not isinstance(v, (torch.FloatTensor, numpy.ndarray))}
-
-    vocab = chkpt["dico_word2id"]
-    vocab = {s + "</w>" if s.find("@@") == -1 and i > 13 else s.replace("@@", ""): i for s, i in vocab.items()}
-
-    # Save pytorch-model
-    pytorch_weights_dump_path = pytorch_dump_folder_path + "/" + WEIGHTS_NAME
-    pytorch_config_dump_path = pytorch_dump_folder_path + "/" + CONFIG_NAME
-    pytorch_vocab_dump_path = pytorch_dump_folder_path + "/" + VOCAB_FILES_NAMES["vocab_file"]
-
-    print(f"Save PyTorch model to {pytorch_weights_dump_path}")
-    torch.save(two_levels_state_dict, pytorch_weights_dump_path)
-
-    print(f"Save configuration file to {pytorch_config_dump_path}")
-    with open(pytorch_config_dump_path, "w", encoding="utf-8") as f:
-        f.write(json.dumps(config, indent=2) + "\n")
-
-    print(f"Save vocab file to {pytorch_config_dump_path}")
-    with open(pytorch_vocab_dump_path, "w", encoding="utf-8") as f:
-        f.write(json.dumps(vocab, indent=2) + "\n")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--xlm_checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_xlm_checkpoint_to_pytorch(args.xlm_checkpoint_path, args.pytorch_dump_folder_path)
diff --git a/src/transformers/models/xlm_roberta_xl/convert_xlm_roberta_xl_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/xlm_roberta_xl/convert_xlm_roberta_xl_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 7f0fec32c387..000000000000
--- a/src/transformers/models/xlm_roberta_xl/convert_xlm_roberta_xl_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,183 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert RoBERTa checkpoint."""
-
-import argparse
-import pathlib
-
-import fairseq
-import torch
-from fairseq.models.roberta import RobertaModel as FairseqRobertaModel
-from fairseq.modules import TransformerSentenceEncoderLayer
-from packaging import version
-
-from transformers import XLMRobertaConfig, XLMRobertaXLForMaskedLM, XLMRobertaXLForSequenceClassification
-from transformers.models.bert.modeling_bert import (
-    BertIntermediate,
-    BertLayer,
-    BertOutput,
-    BertSelfAttention,
-    BertSelfOutput,
-)
-from transformers.models.roberta.modeling_roberta import RobertaAttention
-from transformers.utils import logging
-
-
-if version.parse(fairseq.__version__) < version.parse("1.0.0a"):
-    raise Exception("requires fairseq >= 1.0.0a")
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-SAMPLE_TEXT = "Hello world! cécé herlolip"
-
-
-def convert_xlm_roberta_xl_checkpoint_to_pytorch(
-    roberta_checkpoint_path: str, pytorch_dump_folder_path: str, classification_head: bool
-):
-    """
-    Copy/paste/tweak roberta's weights to our BERT structure.
-    """
-    roberta = FairseqRobertaModel.from_pretrained(roberta_checkpoint_path)
-    roberta.eval()  # disable dropout
-    roberta_sent_encoder = roberta.model.encoder.sentence_encoder
-    config = XLMRobertaConfig(
-        vocab_size=roberta_sent_encoder.embed_tokens.num_embeddings,
-        hidden_size=roberta.cfg.model.encoder_embed_dim,
-        num_hidden_layers=roberta.cfg.model.encoder_layers,
-        num_attention_heads=roberta.cfg.model.encoder_attention_heads,
-        intermediate_size=roberta.cfg.model.encoder_ffn_embed_dim,
-        max_position_embeddings=514,
-        type_vocab_size=1,
-        layer_norm_eps=1e-5,  # PyTorch default used in fairseq
-    )
-    if classification_head:
-        config.num_labels = roberta.model.classification_heads["mnli"].out_proj.weight.shape[0]
-
-    print("Our RoBERTa config:", config)
-
-    model = XLMRobertaXLForSequenceClassification(config) if classification_head else XLMRobertaXLForMaskedLM(config)
-    model.eval()
-
-    # Now let's copy all the weights.
-    # Embeddings
-    model.roberta.embeddings.word_embeddings.weight = roberta_sent_encoder.embed_tokens.weight
-    model.roberta.embeddings.position_embeddings.weight = roberta_sent_encoder.embed_positions.weight
-    model.roberta.embeddings.token_type_embeddings.weight.data = torch.zeros_like(
-        model.roberta.embeddings.token_type_embeddings.weight
-    )  # just zero them out b/c RoBERTa doesn't use them.
-
-    model.roberta.encoder.LayerNorm.weight = roberta_sent_encoder.layer_norm.weight
-    model.roberta.encoder.LayerNorm.bias = roberta_sent_encoder.layer_norm.bias
-
-    for i in range(config.num_hidden_layers):
-        # Encoder: start of layer
-        layer: BertLayer = model.roberta.encoder.layer[i]
-        roberta_layer: TransformerSentenceEncoderLayer = roberta_sent_encoder.layers[i]
-
-        attention: RobertaAttention = layer.attention
-        attention.self_attn_layer_norm.weight = roberta_layer.self_attn_layer_norm.weight
-        attention.self_attn_layer_norm.bias = roberta_layer.self_attn_layer_norm.bias
-
-        # self attention
-        self_attn: BertSelfAttention = layer.attention.self
-        assert (
-            roberta_layer.self_attn.k_proj.weight.data.shape
-            == roberta_layer.self_attn.q_proj.weight.data.shape
-            == roberta_layer.self_attn.v_proj.weight.data.shape
-            == torch.Size((config.hidden_size, config.hidden_size))
-        )
-
-        self_attn.query.weight.data = roberta_layer.self_attn.q_proj.weight
-        self_attn.query.bias.data = roberta_layer.self_attn.q_proj.bias
-        self_attn.key.weight.data = roberta_layer.self_attn.k_proj.weight
-        self_attn.key.bias.data = roberta_layer.self_attn.k_proj.bias
-        self_attn.value.weight.data = roberta_layer.self_attn.v_proj.weight
-        self_attn.value.bias.data = roberta_layer.self_attn.v_proj.bias
-
-        # self-attention output
-        self_output: BertSelfOutput = layer.attention.output
-        assert self_output.dense.weight.shape == roberta_layer.self_attn.out_proj.weight.shape
-        self_output.dense.weight = roberta_layer.self_attn.out_proj.weight
-        self_output.dense.bias = roberta_layer.self_attn.out_proj.bias
-
-        # this one is final layer norm
-        layer.LayerNorm.weight = roberta_layer.final_layer_norm.weight
-        layer.LayerNorm.bias = roberta_layer.final_layer_norm.bias
-
-        # intermediate
-        intermediate: BertIntermediate = layer.intermediate
-        assert intermediate.dense.weight.shape == roberta_layer.fc1.weight.shape
-        intermediate.dense.weight = roberta_layer.fc1.weight
-        intermediate.dense.bias = roberta_layer.fc1.bias
-
-        # output
-        bert_output: BertOutput = layer.output
-        assert bert_output.dense.weight.shape == roberta_layer.fc2.weight.shape
-        bert_output.dense.weight = roberta_layer.fc2.weight
-        bert_output.dense.bias = roberta_layer.fc2.bias
-        # end of layer
-
-    if classification_head:
-        model.classifier.dense.weight = roberta.model.classification_heads["mnli"].dense.weight
-        model.classifier.dense.bias = roberta.model.classification_heads["mnli"].dense.bias
-        model.classifier.out_proj.weight = roberta.model.classification_heads["mnli"].out_proj.weight
-        model.classifier.out_proj.bias = roberta.model.classification_heads["mnli"].out_proj.bias
-    else:
-        # LM Head
-        model.lm_head.dense.weight = roberta.model.encoder.lm_head.dense.weight
-        model.lm_head.dense.bias = roberta.model.encoder.lm_head.dense.bias
-        model.lm_head.layer_norm.weight = roberta.model.encoder.lm_head.layer_norm.weight
-        model.lm_head.layer_norm.bias = roberta.model.encoder.lm_head.layer_norm.bias
-        model.lm_head.decoder.weight = roberta.model.encoder.lm_head.weight
-        model.lm_head.decoder.bias = roberta.model.encoder.lm_head.bias
-
-    # Let's check that we get the same results.
-    input_ids: torch.Tensor = roberta.encode(SAMPLE_TEXT).unsqueeze(0)  # batch of size 1
-
-    our_output = model(input_ids)[0]
-    if classification_head:
-        their_output = roberta.model.classification_heads["mnli"](roberta.extract_features(input_ids))
-    else:
-        their_output = roberta.model(input_ids)[0]
-    print(our_output.shape, their_output.shape)
-    max_absolute_diff = torch.max(torch.abs(our_output - their_output)).item()
-    print(f"max_absolute_diff = {max_absolute_diff}")  # ~ 1e-7
-    success = torch.allclose(our_output, their_output, atol=1e-3)
-    print("Do both models output the same tensors?", "🔥" if success else "💩")
-    if not success:
-        raise Exception("Something went wRoNg")
-
-    pathlib.Path(pytorch_dump_folder_path).mkdir(parents=True, exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--roberta_checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--classification_head", action="store_true", help="Whether to convert a final classification head."
-    )
-    args = parser.parse_args()
-    convert_xlm_roberta_xl_checkpoint_to_pytorch(
-        args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
-    )
diff --git a/src/transformers/models/xlnet/convert_xlnet_original_tf_checkpoint_to_pytorch.py b/src/transformers/models/xlnet/convert_xlnet_original_tf_checkpoint_to_pytorch.py
deleted file mode 100755
index a15c5f22ad68..000000000000
--- a/src/transformers/models/xlnet/convert_xlnet_original_tf_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,113 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert BERT checkpoint."""
-
-import argparse
-import os
-
-import torch
-
-from transformers import (
-    XLNetConfig,
-    XLNetForQuestionAnswering,
-    XLNetForSequenceClassification,
-    XLNetLMHeadModel,
-    load_tf_weights_in_xlnet,
-)
-from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging
-
-
-GLUE_TASKS_NUM_LABELS = {
-    "cola": 2,
-    "mnli": 3,
-    "mrpc": 2,
-    "sst-2": 2,
-    "sts-b": 1,
-    "qqp": 2,
-    "qnli": 2,
-    "rte": 2,
-    "wnli": 2,
-}
-
-
-logging.set_verbosity_info()
-
-
-def convert_xlnet_checkpoint_to_pytorch(
-    tf_checkpoint_path, bert_config_file, pytorch_dump_folder_path, finetuning_task=None
-):
-    # Initialise PyTorch model
-    config = XLNetConfig.from_json_file(bert_config_file)
-
-    finetuning_task = finetuning_task.lower() if finetuning_task is not None else ""
-    if finetuning_task in GLUE_TASKS_NUM_LABELS:
-        print(f"Building PyTorch XLNetForSequenceClassification model from configuration: {config}")
-        config.finetuning_task = finetuning_task
-        config.num_labels = GLUE_TASKS_NUM_LABELS[finetuning_task]
-        model = XLNetForSequenceClassification(config)
-    elif "squad" in finetuning_task:
-        config.finetuning_task = finetuning_task
-        model = XLNetForQuestionAnswering(config)
-    else:
-        model = XLNetLMHeadModel(config)
-
-    # Load weights from tf checkpoint
-    load_tf_weights_in_xlnet(model, config, tf_checkpoint_path)
-
-    # Save pytorch-model
-    pytorch_weights_dump_path = os.path.join(pytorch_dump_folder_path, WEIGHTS_NAME)
-    pytorch_config_dump_path = os.path.join(pytorch_dump_folder_path, CONFIG_NAME)
-    print(f"Save PyTorch model to {os.path.abspath(pytorch_weights_dump_path)}")
-    torch.save(model.state_dict(), pytorch_weights_dump_path)
-    print(f"Save configuration file to {os.path.abspath(pytorch_config_dump_path)}")
-    with open(pytorch_config_dump_path, "w", encoding="utf-8") as f:
-        f.write(config.to_json_string())
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
-    )
-    parser.add_argument(
-        "--xlnet_config_file",
-        default=None,
-        type=str,
-        required=True,
-        help=(
-            "The config json file corresponding to the pre-trained XLNet model. \n"
-            "This specifies the model architecture."
-        ),
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=True,
-        help="Path to the folder to store the PyTorch model or dataset/vocab.",
-    )
-    parser.add_argument(
-        "--finetuning_task",
-        default=None,
-        type=str,
-        help="Name of a task on which the XLNet TensorFlow model was fine-tuned",
-    )
-    args = parser.parse_args()
-    print(args)
-
-    convert_xlnet_checkpoint_to_pytorch(
-        args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
-    )
diff --git a/src/transformers/models/xmod/convert_xmod_original_pytorch_checkpoint_to_pytorch.py b/src/transformers/models/xmod/convert_xmod_original_pytorch_checkpoint_to_pytorch.py
deleted file mode 100644
index 6352b7130055..000000000000
--- a/src/transformers/models/xmod/convert_xmod_original_pytorch_checkpoint_to_pytorch.py
+++ /dev/null
@@ -1,212 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert X-MOD checkpoint."""
-
-import argparse
-from pathlib import Path
-
-import fairseq
-import torch
-from fairseq.models.xmod import XMODModel as FairseqXmodModel
-from packaging import version
-
-from transformers import XmodConfig, XmodForMaskedLM, XmodForSequenceClassification
-from transformers.utils import logging
-
-
-if version.parse(fairseq.__version__) < version.parse("0.12.2"):
-    raise Exception("requires fairseq >= 0.12.2")
-if version.parse(fairseq.__version__) > version.parse("2"):
-    raise Exception("requires fairseq < v2")
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-SAMPLE_TEXT = "Hello, World!"
-SAMPLE_LANGUAGE = "en_XX"
-
-
-def convert_xmod_checkpoint_to_pytorch(
-    xmod_checkpoint_path: str, pytorch_dump_folder_path: str, classification_head: bool
-):
-    data_dir = Path("data_bin")
-    xmod = FairseqXmodModel.from_pretrained(
-        model_name_or_path=str(Path(xmod_checkpoint_path).parent),
-        checkpoint_file=Path(xmod_checkpoint_path).name,
-        _name="xmod_base",
-        arch="xmod_base",
-        task="multilingual_masked_lm",
-        data_name_or_path=str(data_dir),
-        bpe="sentencepiece",
-        sentencepiece_model=str(Path(xmod_checkpoint_path).parent / "sentencepiece.bpe.model"),
-        src_dict=str(data_dir / "dict.txt"),
-    )
-    xmod.eval()  # disable dropout
-    print(xmod)
-
-    xmod_sent_encoder = xmod.model.encoder.sentence_encoder
-    config = XmodConfig(
-        vocab_size=xmod_sent_encoder.embed_tokens.num_embeddings,
-        hidden_size=xmod.cfg.model.encoder_embed_dim,
-        num_hidden_layers=xmod.cfg.model.encoder_layers,
-        num_attention_heads=xmod.cfg.model.encoder_attention_heads,
-        intermediate_size=xmod.cfg.model.encoder_ffn_embed_dim,
-        max_position_embeddings=514,
-        type_vocab_size=1,
-        layer_norm_eps=1e-5,  # PyTorch default used in fairseq
-        pre_norm=xmod.cfg.model.encoder_normalize_before,
-        adapter_reduction_factor=getattr(xmod.cfg.model, "bottleneck", 2),
-        adapter_layer_norm=xmod.cfg.model.adapter_layer_norm,
-        adapter_reuse_layer_norm=xmod.cfg.model.adapter_reuse_layer_norm,
-        ln_before_adapter=xmod.cfg.model.ln_before_adapter,
-        languages=xmod.cfg.model.languages,
-    )
-    if classification_head:
-        config.num_labels = xmod.model.classification_heads["mnli"].out_proj.weight.shape[0]
-
-    print("Our X-MOD config:", config)
-
-    model = XmodForSequenceClassification(config) if classification_head else XmodForMaskedLM(config)
-    model.eval()
-
-    # Now let's copy all the weights.
-    # Embeddings
-    model.roberta.embeddings.word_embeddings.weight = xmod_sent_encoder.embed_tokens.weight
-    model.roberta.embeddings.position_embeddings.weight = xmod_sent_encoder.embed_positions.weight
-    model.roberta.embeddings.token_type_embeddings.weight.data = torch.zeros_like(
-        model.roberta.embeddings.token_type_embeddings.weight
-    )  # just zero them out b/c xmod doesn't use them.
-
-    model.roberta.embeddings.LayerNorm.weight = xmod_sent_encoder.layernorm_embedding.weight
-    model.roberta.embeddings.LayerNorm.bias = xmod_sent_encoder.layernorm_embedding.bias
-
-    for i in range(config.num_hidden_layers):
-        # Encoder: start of layer
-        layer = model.roberta.encoder.layer[i]
-        xmod_layer = xmod_sent_encoder.layers[i]
-
-        # self attention
-        self_attn = layer.attention.self
-        if not (
-            xmod_layer.self_attn.k_proj.weight.data.shape
-            == xmod_layer.self_attn.q_proj.weight.data.shape
-            == xmod_layer.self_attn.v_proj.weight.data.shape
-            == torch.Size((config.hidden_size, config.hidden_size))
-        ):
-            raise AssertionError("Dimensions of self-attention weights do not match.")
-
-        self_attn.query.weight.data = xmod_layer.self_attn.q_proj.weight
-        self_attn.query.bias.data = xmod_layer.self_attn.q_proj.bias
-        self_attn.key.weight.data = xmod_layer.self_attn.k_proj.weight
-        self_attn.key.bias.data = xmod_layer.self_attn.k_proj.bias
-        self_attn.value.weight.data = xmod_layer.self_attn.v_proj.weight
-        self_attn.value.bias.data = xmod_layer.self_attn.v_proj.bias
-
-        # self-attention output
-        self_output = layer.attention.output
-        if self_output.dense.weight.shape != xmod_layer.self_attn.out_proj.weight.shape:
-            raise AssertionError("Dimensions of self-attention output weights do not match.")
-        self_output.dense.weight = xmod_layer.self_attn.out_proj.weight
-        self_output.dense.bias = xmod_layer.self_attn.out_proj.bias
-        self_output.LayerNorm.weight = xmod_layer.self_attn_layer_norm.weight
-        self_output.LayerNorm.bias = xmod_layer.self_attn_layer_norm.bias
-
-        # intermediate
-        intermediate = layer.intermediate
-        if intermediate.dense.weight.shape != xmod_layer.fc1.weight.shape:
-            raise AssertionError("Dimensions of intermediate weights do not match.")
-        intermediate.dense.weight = xmod_layer.fc1.weight
-        intermediate.dense.bias = xmod_layer.fc1.bias
-
-        # output
-        bert_output = layer.output
-        if bert_output.dense.weight.shape != xmod_layer.fc2.weight.shape:
-            raise AssertionError("Dimensions of feed-forward weights do not match.")
-        bert_output.dense.weight = xmod_layer.fc2.weight
-        bert_output.dense.bias = xmod_layer.fc2.bias
-        bert_output.LayerNorm.weight = xmod_layer.final_layer_norm.weight
-        bert_output.LayerNorm.bias = xmod_layer.final_layer_norm.bias
-        if bert_output.adapter_layer_norm is not None:
-            bert_output.adapter_layer_norm.weight = xmod_layer.adapter_layer_norm.weight
-            bert_output.adapter_layer_norm.bias = xmod_layer.adapter_layer_norm.bias
-
-        if sorted(bert_output.adapter_modules.keys()) != sorted(xmod_layer.adapter_modules.keys()):
-            raise AssertionError("Lists of language adapters do not match.")
-        for lang_code, adapter in xmod_layer.adapter_modules.items():
-            to_adapter = bert_output.adapter_modules[lang_code]
-            from_adapter = xmod_layer.adapter_modules[lang_code]
-            to_adapter.dense1.weight = from_adapter.fc1.weight
-            to_adapter.dense1.bias = from_adapter.fc1.bias
-            to_adapter.dense2.weight = from_adapter.fc2.weight
-            to_adapter.dense2.bias = from_adapter.fc2.bias
-
-        # end of layer
-
-    if xmod_sent_encoder.layer_norm is not None:
-        model.roberta.encoder.LayerNorm.weight = xmod_sent_encoder.layer_norm.weight
-        model.roberta.encoder.LayerNorm.bias = xmod_sent_encoder.layer_norm.bias
-
-    if classification_head:
-        model.classifier.dense.weight = xmod.model.classification_heads["mnli"].dense.weight
-        model.classifier.dense.bias = xmod.model.classification_heads["mnli"].dense.bias
-        model.classifier.out_proj.weight = xmod.model.classification_heads["mnli"].out_proj.weight
-        model.classifier.out_proj.bias = xmod.model.classification_heads["mnli"].out_proj.bias
-    else:
-        # LM Head
-        model.lm_head.dense.weight = xmod.model.encoder.lm_head.dense.weight
-        model.lm_head.dense.bias = xmod.model.encoder.lm_head.dense.bias
-        model.lm_head.layer_norm.weight = xmod.model.encoder.lm_head.layer_norm.weight
-        model.lm_head.layer_norm.bias = xmod.model.encoder.lm_head.layer_norm.bias
-        model.lm_head.decoder.weight = xmod.model.encoder.lm_head.weight
-        model.lm_head.decoder.bias = xmod.model.encoder.lm_head.bias
-
-    # Let's check that we get the same results.
-    input_ids = xmod.encode(SAMPLE_TEXT).unsqueeze(0)  # batch of size 1
-    model.roberta.set_default_language(SAMPLE_LANGUAGE)
-
-    our_output = model(input_ids)[0]
-    if classification_head:
-        their_output = xmod.model.classification_heads["mnli"](xmod.extract_features(input_ids))
-    else:
-        their_output = xmod.model(input_ids, lang_id=[SAMPLE_LANGUAGE])[0]
-    print(our_output.shape, their_output.shape)
-    max_absolute_diff = torch.max(torch.abs(our_output - their_output)).item()
-    print(f"max_absolute_diff = {max_absolute_diff}")  # ~ 1e-7
-    success = torch.allclose(our_output, their_output, atol=1e-3)
-    print("Do both models output the same tensors?", "🔥" if success else "💩")
-    if not success:
-        raise Exception("Something went wRoNg")
-
-    Path(pytorch_dump_folder_path).mkdir(parents=True, exist_ok=True)
-    print(f"Saving model to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--xmod_checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    parser.add_argument(
-        "--classification_head", action="store_true", help="Whether to convert a final classification head."
-    )
-    args = parser.parse_args()
-    convert_xmod_checkpoint_to_pytorch(
-        args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
-    )
diff --git a/src/transformers/models/yolos/convert_yolos_to_pytorch.py b/src/transformers/models/yolos/convert_yolos_to_pytorch.py
deleted file mode 100644
index 6cddc606614c..000000000000
--- a/src/transformers/models/yolos/convert_yolos_to_pytorch.py
+++ /dev/null
@@ -1,267 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert YOLOS checkpoints from the original repository. URL: https://github.com/hustvl/YOLOS"""
-
-import argparse
-import json
-from pathlib import Path
-
-import requests
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import YolosConfig, YolosForObjectDetection, YolosImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_yolos_config(yolos_name: str) -> YolosConfig:
-    config = YolosConfig()
-
-    # size of the architecture
-    if "yolos_ti" in yolos_name:
-        config.hidden_size = 192
-        config.intermediate_size = 768
-        config.num_hidden_layers = 12
-        config.num_attention_heads = 3
-        config.image_size = [800, 1333]
-        config.use_mid_position_embeddings = False
-    elif yolos_name == "yolos_s_dWr":
-        config.hidden_size = 330
-        config.num_hidden_layers = 14
-        config.num_attention_heads = 6
-        config.intermediate_size = 1320
-    elif "yolos_s" in yolos_name:
-        config.hidden_size = 384
-        config.intermediate_size = 1536
-        config.num_hidden_layers = 12
-        config.num_attention_heads = 6
-    elif "yolos_b" in yolos_name:
-        config.image_size = [800, 1344]
-
-    config.num_labels = 91
-    repo_id = "huggingface/label-files"
-    filename = "coco-detection-id2label.json"
-    id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
-    id2label = {int(k): v for k, v in id2label.items()}
-    config.id2label = id2label
-    config.label2id = {v: k for k, v in id2label.items()}
-
-    return config
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict: dict, config: YolosConfig, base_model: bool = False):
-    for i in range(config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"blocks.{i}.attn.qkv.weight")
-        in_proj_bias = state_dict.pop(f"blocks.{i}.attn.qkv.bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[: config.hidden_size, :]
-        state_dict[f"encoder.layer.{i}.attention.attention.query.bias"] = in_proj_bias[: config.hidden_size]
-        state_dict[f"encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            config.hidden_size : config.hidden_size * 2, :
-        ]
-        state_dict[f"encoder.layer.{i}.attention.attention.key.bias"] = in_proj_bias[
-            config.hidden_size : config.hidden_size * 2
-        ]
-        state_dict[f"encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[-config.hidden_size :, :]
-        state_dict[f"encoder.layer.{i}.attention.attention.value.bias"] = in_proj_bias[-config.hidden_size :]
-
-
-def rename_key(name: str) -> str:
-    if "backbone" in name:
-        name = name.replace("backbone", "vit")
-    if "cls_token" in name:
-        name = name.replace("cls_token", "embeddings.cls_token")
-    if "det_token" in name:
-        name = name.replace("det_token", "embeddings.detection_tokens")
-    if "mid_pos_embed" in name:
-        name = name.replace("mid_pos_embed", "encoder.mid_position_embeddings")
-    if "pos_embed" in name:
-        name = name.replace("pos_embed", "embeddings.position_embeddings")
-    if "patch_embed.proj" in name:
-        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
-    if "blocks" in name:
-        name = name.replace("blocks", "encoder.layer")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn" in name:
-        name = name.replace("attn", "attention.self")
-    if "norm1" in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "class_embed" in name:
-        name = name.replace("class_embed", "class_labels_classifier")
-    if "bbox_embed" in name:
-        name = name.replace("bbox_embed", "bbox_predictor")
-    if "vit.norm" in name:
-        name = name.replace("vit.norm", "vit.layernorm")
-
-    return name
-
-
-def convert_state_dict(orig_state_dict: dict, model: YolosForObjectDetection) -> dict:
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if "qkv" in key:
-            key_split = key.split(".")
-            layer_num = int(key_split[2])
-            dim = model.vit.encoder.layer[layer_num].attention.attention.all_head_size
-            if "weight" in key:
-                orig_state_dict[f"vit.encoder.layer.{layer_num}.attention.attention.query.weight"] = val[:dim, :]
-                orig_state_dict[f"vit.encoder.layer.{layer_num}.attention.attention.key.weight"] = val[
-                    dim : dim * 2, :
-                ]
-                orig_state_dict[f"vit.encoder.layer.{layer_num}.attention.attention.value.weight"] = val[-dim:, :]
-            else:
-                orig_state_dict[f"vit.encoder.layer.{layer_num}.attention.attention.query.bias"] = val[:dim]
-                orig_state_dict[f"vit.encoder.layer.{layer_num}.attention.attention.key.bias"] = val[dim : dim * 2]
-                orig_state_dict[f"vit.encoder.layer.{layer_num}.attention.attention.value.bias"] = val[-dim:]
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    return orig_state_dict
-
-
-# We will verify our results on an image of cute cats
-def prepare_img() -> torch.Tensor:
-    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    im = Image.open(requests.get(url, stream=True).raw)
-    return im
-
-
-@torch.no_grad()
-def convert_yolos_checkpoint(
-    yolos_name: str, checkpoint_path: str, pytorch_dump_folder_path: str, push_to_hub: bool = False
-):
-    """
-    Copy/paste/tweak model's weights to our YOLOS structure.
-    """
-    config = get_yolos_config(yolos_name)
-
-    # load original state_dict
-    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
-
-    # load 🤗 model
-    model = YolosForObjectDetection(config)
-    model.eval()
-    new_state_dict = convert_state_dict(state_dict, model)
-    model.load_state_dict(new_state_dict)
-
-    # Check outputs on an image, prepared by YolosImageProcessor
-    size = 800 if yolos_name != "yolos_ti" else 512
-    image_processor = YolosImageProcessor(format="coco_detection", size=size)
-    encoding = image_processor(images=prepare_img(), return_tensors="pt")
-    outputs = model(**encoding)
-    logits, pred_boxes = outputs.logits, outputs.pred_boxes
-
-    expected_slice_logits, expected_slice_boxes = None, None
-    if yolos_name == "yolos_ti":
-        expected_slice_logits = torch.tensor(
-            [[-39.5022, -11.9820, -17.6888], [-29.9574, -9.9769, -17.7691], [-42.3281, -20.7200, -30.6294]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.4021, 0.0836, 0.7979], [0.0184, 0.2609, 0.0364], [0.1781, 0.2004, 0.2095]]
-        )
-    elif yolos_name == "yolos_s_200_pre":
-        expected_slice_logits = torch.tensor(
-            [[-24.0248, -10.3024, -14.8290], [-42.0392, -16.8200, -27.4334], [-27.2743, -11.8154, -18.7148]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.2559, 0.5455, 0.4706], [0.2989, 0.7279, 0.1875], [0.7732, 0.4017, 0.4462]]
-        )
-    elif yolos_name == "yolos_s_300_pre":
-        expected_slice_logits = torch.tensor(
-            [[-36.2220, -14.4385, -23.5457], [-35.6970, -14.7583, -21.3935], [-31.5939, -13.6042, -16.8049]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.7614, 0.2316, 0.4728], [0.7168, 0.4495, 0.3855], [0.4996, 0.1466, 0.9996]]
-        )
-    elif yolos_name == "yolos_s_dWr":
-        expected_slice_logits = torch.tensor(
-            [[-42.8668, -24.1049, -41.1690], [-34.7456, -14.1274, -24.9194], [-33.7898, -12.1946, -25.6495]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.5587, 0.2773, 0.0605], [0.5004, 0.3014, 0.9994], [0.4999, 0.1548, 0.9994]]
-        )
-    elif yolos_name == "yolos_base":
-        expected_slice_logits = torch.tensor(
-            [[-40.6064, -24.3084, -32.6447], [-55.1990, -30.7719, -35.5877], [-51.4311, -33.3507, -35.6462]]
-        )
-        expected_slice_boxes = torch.tensor(
-            [[0.5555, 0.2794, 0.0655], [0.9049, 0.2664, 0.1894], [0.9183, 0.1984, 0.1635]]
-        )
-    else:
-        raise ValueError(f"Unknown yolos_name: {yolos_name}")
-
-    assert torch.allclose(logits[0, :3, :3], expected_slice_logits, atol=1e-4)
-    assert torch.allclose(pred_boxes[0, :3, :3], expected_slice_boxes, atol=1e-4)
-
-    Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-    print(f"Saving model {yolos_name} to {pytorch_dump_folder_path}")
-    model.save_pretrained(pytorch_dump_folder_path)
-    print(f"Saving image processor to {pytorch_dump_folder_path}")
-    image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model_mapping = {
-            "yolos_ti": "yolos-tiny",
-            "yolos_s_200_pre": "yolos-small",
-            "yolos_s_300_pre": "yolos-small-300",
-            "yolos_s_dWr": "yolos-small-dwr",
-            "yolos_base": "yolos-base",
-        }
-
-        print("Pushing to the hub...")
-        model_name = model_mapping[yolos_name]
-        image_processor.push_to_hub(model_name, organization="hustvl")
-        model.push_to_hub(model_name, organization="hustvl")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--yolos_name",
-        default="yolos_s_200_pre",
-        type=str,
-        help=(
-            "Name of the YOLOS model you'd like to convert. Should be one of 'yolos_ti', 'yolos_s_200_pre',"
-            " 'yolos_s_300_pre', 'yolos_s_dWr', 'yolos_base'."
-        ),
-    )
-    parser.add_argument(
-        "--checkpoint_path", default=None, type=str, help="Path to the original state dict (.pth file)."
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
-    )
-    parser.add_argument(
-        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
-    )
-
-    args = parser.parse_args()
-    convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/src/transformers/models/yoso/convert_yoso_pytorch_to_pytorch.py b/src/transformers/models/yoso/convert_yoso_pytorch_to_pytorch.py
deleted file mode 100644
index be46a4de81b3..000000000000
--- a/src/transformers/models/yoso/convert_yoso_pytorch_to_pytorch.py
+++ /dev/null
@@ -1,108 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert YOSO checkpoints from the original repository. URL: https://github.com/mlpen/YOSO"""
-
-import argparse
-
-import torch
-
-from transformers import YosoConfig, YosoForMaskedLM
-
-
-def rename_key(orig_key):
-    if "model" in orig_key:
-        orig_key = orig_key.replace("model.", "")
-    if "norm1" in orig_key:
-        orig_key = orig_key.replace("norm1", "attention.output.LayerNorm")
-    if "norm2" in orig_key:
-        orig_key = orig_key.replace("norm2", "output.LayerNorm")
-    if "norm" in orig_key:
-        orig_key = orig_key.replace("norm", "LayerNorm")
-    if "transformer" in orig_key:
-        layer_num = orig_key.split(".")[0].split("_")[-1]
-        orig_key = orig_key.replace(f"transformer_{layer_num}", f"encoder.layer.{layer_num}")
-    if "mha.attn" in orig_key:
-        orig_key = orig_key.replace("mha.attn", "attention.self")
-    if "mha" in orig_key:
-        orig_key = orig_key.replace("mha", "attention")
-    if "W_q" in orig_key:
-        orig_key = orig_key.replace("W_q", "self.query")
-    if "W_k" in orig_key:
-        orig_key = orig_key.replace("W_k", "self.key")
-    if "W_v" in orig_key:
-        orig_key = orig_key.replace("W_v", "self.value")
-    if "ff1" in orig_key:
-        orig_key = orig_key.replace("ff1", "intermediate.dense")
-    if "ff2" in orig_key:
-        orig_key = orig_key.replace("ff2", "output.dense")
-    if "ff" in orig_key:
-        orig_key = orig_key.replace("ff", "output.dense")
-    if "mlm_class" in orig_key:
-        orig_key = orig_key.replace("mlm.mlm_class", "cls.predictions.decoder")
-    if "mlm" in orig_key:
-        orig_key = orig_key.replace("mlm", "cls.predictions.transform")
-    if "cls" not in orig_key:
-        orig_key = "yoso." + orig_key
-
-    return orig_key
-
-
-def convert_checkpoint_helper(max_position_embeddings, orig_state_dict):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        if ("pooler" in key) or ("sen_class" in key):
-            continue
-        else:
-            orig_state_dict[rename_key(key)] = val
-
-    orig_state_dict["cls.predictions.bias"] = orig_state_dict["cls.predictions.decoder.bias"]
-    orig_state_dict["yoso.embeddings.position_ids"] = torch.arange(max_position_embeddings).expand((1, -1)) + 2
-
-    return orig_state_dict
-
-
-def convert_yoso_checkpoint(checkpoint_path, yoso_config_file, pytorch_dump_path):
-    orig_state_dict = torch.load(checkpoint_path, map_location="cpu")["model_state_dict"]
-    config = YosoConfig.from_json_file(yoso_config_file)
-    model = YosoForMaskedLM(config)
-
-    new_state_dict = convert_checkpoint_helper(config.max_position_embeddings, orig_state_dict)
-
-    print(model.load_state_dict(new_state_dict))
-    model.eval()
-    model.save_pretrained(pytorch_dump_path)
-
-    print(f"Checkpoint successfuly converted. Model saved at {pytorch_dump_path}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--pytorch_model_path", default=None, type=str, required=True, help="Path to YOSO pytorch checkpoint."
-    )
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The json file for YOSO model config.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
-    )
-    args = parser.parse_args()
-    convert_yoso_checkpoint(args.pytorch_model_path, args.config_file, args.pytorch_dump_path)
diff --git a/src/transformers/models/zoedepth/convert_zoedepth_to_hf.py b/src/transformers/models/zoedepth/convert_zoedepth_to_hf.py
deleted file mode 100644
index 9a6701c35bcd..000000000000
--- a/src/transformers/models/zoedepth/convert_zoedepth_to_hf.py
+++ /dev/null
@@ -1,426 +0,0 @@
-# coding=utf-8
-# Copyright 2024 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert ZoeDepth checkpoints from the original repository. URL: https://github.com/isl-org/ZoeDepth.
-
-Original logits where obtained by running the following code:
-!git clone -b understanding_zoedepth https://github.com/NielsRogge/ZoeDepth
-!python inference.py
-"""
-
-import argparse
-from pathlib import Path
-
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from transformers import BeitConfig, ZoeDepthConfig, ZoeDepthForDepthEstimation, ZoeDepthImageProcessor
-from transformers.utils import logging
-
-
-logging.set_verbosity_info()
-logger = logging.get_logger(__name__)
-
-
-def get_zoedepth_config(model_name):
-    image_size = 384
-    backbone_config = BeitConfig(
-        image_size=image_size,
-        num_hidden_layers=24,
-        hidden_size=1024,
-        intermediate_size=4096,
-        num_attention_heads=16,
-        use_relative_position_bias=True,
-        reshape_hidden_states=False,
-        out_features=["stage6", "stage12", "stage18", "stage24"],  # beit-large-512 uses [5, 11, 17, 23],
-    )
-
-    neck_hidden_sizes = [256, 512, 1024, 1024]
-    bin_centers_type = "softplus" if model_name in ["ZoeD_N", "ZoeD_NK"] else "normed"
-    if model_name == "ZoeD_NK":
-        bin_configurations = [
-            {"name": "nyu", "n_bins": 64, "min_depth": 1e-3, "max_depth": 10.0},
-            {"name": "kitti", "n_bins": 64, "min_depth": 1e-3, "max_depth": 80.0},
-        ]
-    elif model_name in ["ZoeD_N", "ZoeD_K"]:
-        bin_configurations = [
-            {"name": "nyu", "n_bins": 64, "min_depth": 1e-3, "max_depth": 10.0},
-        ]
-    config = ZoeDepthConfig(
-        backbone_config=backbone_config,
-        neck_hidden_sizes=neck_hidden_sizes,
-        bin_centers_type=bin_centers_type,
-        bin_configurations=bin_configurations,
-        num_patch_transformer_layers=4 if model_name == "ZoeD_NK" else None,
-        patch_transformer_hidden_size=128 if model_name == "ZoeD_NK" else None,
-        patch_transformer_intermediate_size=1024 if model_name == "ZoeD_NK" else None,
-        patch_transformer_num_attention_heads=4 if model_name == "ZoeD_NK" else None,
-    )
-
-    return config, image_size
-
-
-def rename_key(name):
-    # Transformer backbone
-    if "core.core.pretrained.model.blocks" in name:
-        name = name.replace("core.core.pretrained.model.blocks", "backbone.encoder.layer")
-    if "core.core.pretrained.model.patch_embed.proj" in name:
-        name = name.replace(
-            "core.core.pretrained.model.patch_embed.proj", "backbone.embeddings.patch_embeddings.projection"
-        )
-    if "core.core.pretrained.model.cls_token" in name:
-        name = name.replace("core.core.pretrained.model.cls_token", "backbone.embeddings.cls_token")
-    if "norm1" in name and "patch_transformer" not in name:
-        name = name.replace("norm1", "layernorm_before")
-    if "norm2" in name and "patch_transformer" not in name:
-        name = name.replace("norm2", "layernorm_after")
-    if "mlp.fc1" in name:
-        name = name.replace("mlp.fc1", "intermediate.dense")
-    if "mlp.fc2" in name:
-        name = name.replace("mlp.fc2", "output.dense")
-    if "gamma_1" in name:
-        name = name.replace("gamma_1", "lambda_1")
-    if "gamma_2" in name:
-        name = name.replace("gamma_2", "lambda_2")
-    if "attn.proj" in name:
-        name = name.replace("attn.proj", "attention.output.dense")
-    if "attn.relative_position_bias_table" in name:
-        name = name.replace(
-            "attn.relative_position_bias_table",
-            "attention.attention.relative_position_bias.relative_position_bias_table",
-        )
-    if "attn.relative_position_index" in name:
-        name = name.replace(
-            "attn.relative_position_index", "attention.attention.relative_position_bias.relative_position_index"
-        )
-
-    # activation postprocessing (readout projections + resize blocks)
-    if "core.core.pretrained.act_postprocess1.0.project" in name:
-        name = name.replace(
-            "core.core.pretrained.act_postprocess1.0.project", "neck.reassemble_stage.readout_projects.0"
-        )
-    if "core.core.pretrained.act_postprocess2.0.project" in name:
-        name = name.replace(
-            "core.core.pretrained.act_postprocess2.0.project", "neck.reassemble_stage.readout_projects.1"
-        )
-    if "core.core.pretrained.act_postprocess3.0.project" in name:
-        name = name.replace(
-            "core.core.pretrained.act_postprocess3.0.project", "neck.reassemble_stage.readout_projects.2"
-        )
-    if "core.core.pretrained.act_postprocess4.0.project" in name:
-        name = name.replace(
-            "core.core.pretrained.act_postprocess4.0.project", "neck.reassemble_stage.readout_projects.3"
-        )
-
-    if "core.core.pretrained.act_postprocess1.3" in name:
-        name = name.replace("core.core.pretrained.act_postprocess1.3", "neck.reassemble_stage.layers.0.projection")
-    if "core.core.pretrained.act_postprocess2.3" in name:
-        name = name.replace("core.core.pretrained.act_postprocess2.3", "neck.reassemble_stage.layers.1.projection")
-    if "core.core.pretrained.act_postprocess3.3" in name:
-        name = name.replace("core.core.pretrained.act_postprocess3.3", "neck.reassemble_stage.layers.2.projection")
-    if "core.core.pretrained.act_postprocess4.3" in name:
-        name = name.replace("core.core.pretrained.act_postprocess4.3", "neck.reassemble_stage.layers.3.projection")
-
-    if "core.core.pretrained.act_postprocess1.4" in name:
-        name = name.replace("core.core.pretrained.act_postprocess1.4", "neck.reassemble_stage.layers.0.resize")
-    if "core.core.pretrained.act_postprocess2.4" in name:
-        name = name.replace("core.core.pretrained.act_postprocess2.4", "neck.reassemble_stage.layers.1.resize")
-    if "core.core.pretrained.act_postprocess4.4" in name:
-        name = name.replace("core.core.pretrained.act_postprocess4.4", "neck.reassemble_stage.layers.3.resize")
-
-    # scratch convolutions
-    if "core.core.scratch.layer1_rn.weight" in name:
-        name = name.replace("core.core.scratch.layer1_rn.weight", "neck.convs.0.weight")
-    if "core.core.scratch.layer2_rn.weight" in name:
-        name = name.replace("core.core.scratch.layer2_rn.weight", "neck.convs.1.weight")
-    if "core.core.scratch.layer3_rn.weight" in name:
-        name = name.replace("core.core.scratch.layer3_rn.weight", "neck.convs.2.weight")
-    if "core.core.scratch.layer4_rn.weight" in name:
-        name = name.replace("core.core.scratch.layer4_rn.weight", "neck.convs.3.weight")
-
-    # fusion layers
-    # tricky here: mapping = {1:3, 2:2, 3:1, 4:0}
-    if "core.core.scratch.refinenet1" in name:
-        name = name.replace("core.core.scratch.refinenet1", "neck.fusion_stage.layers.3")
-    if "core.core.scratch.refinenet2" in name:
-        name = name.replace("core.core.scratch.refinenet2", "neck.fusion_stage.layers.2")
-    if "core.core.scratch.refinenet3" in name:
-        name = name.replace("core.core.scratch.refinenet3", "neck.fusion_stage.layers.1")
-    if "core.core.scratch.refinenet4" in name:
-        name = name.replace("core.core.scratch.refinenet4", "neck.fusion_stage.layers.0")
-
-    if "resConfUnit1" in name:
-        name = name.replace("resConfUnit1", "residual_layer1")
-
-    if "resConfUnit2" in name:
-        name = name.replace("resConfUnit2", "residual_layer2")
-
-    if "conv1" in name:
-        name = name.replace("conv1", "convolution1")
-
-    if "conv2" in name and "residual_layer" in name:
-        name = name.replace("conv2", "convolution2")
-
-    if "out_conv" in name:
-        name = name.replace("out_conv", "projection")
-
-    # relative depth estimation head
-    if "core.core.scratch.output_conv.0" in name:
-        name = name.replace("core.core.scratch.output_conv.0", "relative_head.conv1")
-
-    if "core.core.scratch.output_conv.2" in name:
-        name = name.replace("core.core.scratch.output_conv.2", "relative_head.conv2")
-
-    if "core.core.scratch.output_conv.4" in name:
-        name = name.replace("core.core.scratch.output_conv.4", "relative_head.conv3")
-
-    # patch transformer
-    if "patch_transformer" in name:
-        name = name.replace("patch_transformer", "metric_head.patch_transformer")
-
-    if "mlp_classifier.0" in name:
-        name = name.replace("mlp_classifier.0", "metric_head.mlp_classifier.linear1")
-    if "mlp_classifier.2" in name:
-        name = name.replace("mlp_classifier.2", "metric_head.mlp_classifier.linear2")
-
-    if "projectors" in name:
-        name = name.replace("projectors", "metric_head.projectors")
-
-    if "seed_bin_regressors" in name:
-        name = name.replace("seed_bin_regressors", "metric_head.seed_bin_regressors")
-
-    if "seed_bin_regressor" in name and "seed_bin_regressors" not in name:
-        name = name.replace("seed_bin_regressor", "metric_head.seed_bin_regressor")
-
-    if "seed_projector" in name:
-        name = name.replace("seed_projector", "metric_head.seed_projector")
-
-    if "_net.0" in name:
-        name = name.replace("_net.0", "conv1")
-
-    if "_net.2" in name:
-        name = name.replace("_net.2", "conv2")
-
-    if "attractors" in name:
-        name = name.replace("attractors", "metric_head.attractors")
-
-    if "conditional_log_binomial" in name:
-        name = name.replace("conditional_log_binomial", "metric_head.conditional_log_binomial")
-
-    # metric depth estimation head
-    if "conv2" in name and "metric_head" not in name and "attractors" not in name and "relative_head" not in name:
-        name = name.replace("conv2", "metric_head.conv2")
-
-    if "transformer_encoder.layers" in name:
-        name = name.replace("transformer_encoder.layers", "transformer_encoder")
-
-    return name
-
-
-def read_in_q_k_v_metric_head(state_dict):
-    hidden_size = 128
-    for i in range(4):
-        # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"patch_transformer.transformer_encoder.layers.{i}.self_attn.in_proj_weight")
-        in_proj_bias = state_dict.pop(f"patch_transformer.transformer_encoder.layers.{i}.self_attn.in_proj_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"patch_transformer.transformer_encoder.{i}.self_attn.query.weight"] = in_proj_weight[
-            :hidden_size, :
-        ]
-        state_dict[f"patch_transformer.transformer_encoder.{i}.self_attn.query.bias"] = in_proj_bias[:hidden_size]
-
-        state_dict[f"patch_transformer.transformer_encoder.{i}.self_attn.key.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"patch_transformer.transformer_encoder.{i}.self_attn.key.bias"] = in_proj_bias[
-            hidden_size : hidden_size * 2
-        ]
-
-        state_dict[f"patch_transformer.transformer_encoder.{i}.self_attn.value.weight"] = in_proj_weight[
-            -hidden_size:, :
-        ]
-        state_dict[f"patch_transformer.transformer_encoder.{i}.self_attn.value.bias"] = in_proj_bias[-hidden_size:]
-
-
-def convert_state_dict(orig_state_dict):
-    for key in orig_state_dict.copy().keys():
-        val = orig_state_dict.pop(key)
-
-        # rename key
-        new_name = rename_key(key)
-        orig_state_dict[new_name] = val
-
-    return orig_state_dict
-
-
-def remove_ignore_keys(state_dict):
-    for key, _ in state_dict.copy().items():
-        if (
-            "fc_norm" in key
-            or "relative_position_index" in key
-            or "k_idx" in key
-            or "K_minus_1" in key
-            or "core.core.pretrained.model.head" in key
-        ):
-            state_dict.pop(key, None)
-
-
-# we split up the matrix of each encoder layer into queries, keys and values
-def read_in_q_k_v(state_dict, config):
-    hidden_size = config.backbone_config.hidden_size
-    for i in range(config.backbone_config.num_hidden_layers):
-        # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
-        in_proj_weight = state_dict.pop(f"core.core.pretrained.model.blocks.{i}.attn.qkv.weight")
-        q_bias = state_dict.pop(f"core.core.pretrained.model.blocks.{i}.attn.q_bias")
-        v_bias = state_dict.pop(f"core.core.pretrained.model.blocks.{i}.attn.v_bias")
-        # next, add query, keys and values (in that order) to the state dict
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.query.weight"] = in_proj_weight[:hidden_size, :]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.query.bias"] = q_bias
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.key.weight"] = in_proj_weight[
-            hidden_size : hidden_size * 2, :
-        ]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.value.weight"] = in_proj_weight[-hidden_size:, :]
-        state_dict[f"backbone.encoder.layer.{i}.attention.attention.value.bias"] = v_bias
-
-
-# We will verify our results on an image
-def prepare_img():
-    filepath = hf_hub_download(repo_id="shariqfarooq/ZoeDepth", filename="examples/person_1.jpeg", repo_type="space")
-    image = Image.open(filepath).convert("RGB")
-    return image
-
-
-@torch.no_grad()
-def convert_zoedepth_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub):
-    """
-    Copy/paste/tweak model's weights to our ZoeDepth structure.
-    """
-
-    # define ZoeDepth configuration based on URL
-    config, _ = get_zoedepth_config(model_name)
-
-    # load original model
-    original_model = torch.hub.load(
-        "NielsRogge/ZoeDepth:understanding_zoedepth", model_name, pretrained=True, force_reload=True
-    )
-    original_model.eval()
-    state_dict = original_model.state_dict()
-
-    print("Original state dict:")
-    for name, param in state_dict.items():
-        print(name, param.shape)
-
-    # read in qkv matrices
-    read_in_q_k_v(state_dict, config)
-    if model_name == "ZoeD_NK":
-        read_in_q_k_v_metric_head(state_dict)
-
-    # rename keys
-    state_dict = convert_state_dict(state_dict)
-    # remove certain keys
-    remove_ignore_keys(state_dict)
-
-    # load HuggingFace model
-    model = ZoeDepthForDepthEstimation(config)
-    model.load_state_dict(state_dict)
-    model.eval()
-
-    # verify image processor
-    image = prepare_img()
-
-    image_processor = ZoeDepthImageProcessor()
-    pixel_values = image_processor(image, return_tensors="pt").pixel_values
-    filepath = hf_hub_download(
-        repo_id="nielsr/test-image",
-        filename="zoedepth_pixel_values.pt",
-        repo_type="dataset",
-    )
-    original_pixel_values = torch.load(filepath, map_location="cpu")
-    assert torch.allclose(pixel_values, original_pixel_values)
-
-    # verify logits
-    # this was done on a resized version of the cats image (384x384)
-    filepath = hf_hub_download(
-        repo_id="nielsr/test-image",
-        filename="zoedepth_pixel_values.pt",
-        repo_type="dataset",
-        revision="1865dbb81984f01c89e83eec10f8d07efd10743d",
-    )
-    cats_pixel_values = torch.load(filepath, map_location="cpu")
-    depth = model(cats_pixel_values).predicted_depth
-
-    # Verify logits
-    # These were obtained by inserting the pixel_values at the patch embeddings of BEiT
-    if model_name == "ZoeD_N":
-        expected_shape = torch.Size([1, 384, 384])
-        expected_slice = torch.tensor([[1.0328, 1.0604, 1.0747], [1.0816, 1.1293, 1.1456], [1.1117, 1.1629, 1.1766]])
-    elif model_name == "ZoeD_K":
-        expected_shape = torch.Size([1, 384, 384])
-        expected_slice = torch.tensor([[1.6567, 1.6852, 1.7065], [1.6707, 1.6764, 1.6713], [1.7195, 1.7166, 1.7118]])
-    elif model_name == "ZoeD_NK":
-        expected_shape = torch.Size([1, 384, 384])
-        expected_slice = torch.tensor([[1.1228, 1.1079, 1.1382], [1.1807, 1.1658, 1.1891], [1.2344, 1.2094, 1.2317]])
-
-    print("Shape of depth:", depth.shape)
-    print("First 3x3 slice of depth:", depth[0, :3, :3])
-
-    assert depth.shape == torch.Size(expected_shape)
-    assert torch.allclose(depth[0, :3, :3], expected_slice, atol=1e-4)
-    print("Looks ok!")
-
-    if pytorch_dump_folder_path is not None:
-        print(f"Saving model and processor to {pytorch_dump_folder_path}")
-        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
-        model.save_pretrained(pytorch_dump_folder_path)
-        image_processor.save_pretrained(pytorch_dump_folder_path)
-
-    if push_to_hub:
-        model_name_to_repo_id = {
-            "ZoeD_N": "zoedepth-nyu",
-            "ZoeD_K": "zoedepth-kitti",
-            "ZoeD_NK": "zoedepth-nyu-kitti",
-        }
-
-        print("Pushing model and processor to the hub...")
-        repo_id = model_name_to_repo_id[model_name]
-        model.push_to_hub(f"Intel/{repo_id}")
-        image_processor = ZoeDepthImageProcessor()
-        image_processor.push_to_hub(f"Intel/{repo_id}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # Required parameters
-    parser.add_argument(
-        "--model_name",
-        default="ZoeD_N",
-        choices=["ZoeD_N", "ZoeD_K", "ZoeD_NK"],
-        type=str,
-        help="Name of the original ZoeDepth checkpoint you'd like to convert.",
-    )
-    parser.add_argument(
-        "--pytorch_dump_folder_path",
-        default=None,
-        type=str,
-        required=False,
-        help="Path to the output PyTorch model directory.",
-    )
-    parser.add_argument(
-        "--push_to_hub",
-        action="store_true",
-    )
-
-    args = parser.parse_args()
-    convert_zoedepth_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)", "url": "https://github.com/huggingface/transformers/commit/0720e206c6ba28887e4d60ef60a6a089f6c1cc76.patch" } ]
CWE-1333 Inefficient Regular Expression Complexity
GHSA-qjq9-rwgx-jjhc
null
[ { "commit_message": "[PATCH] CVE-2013-6401: Change hash function, randomize hashes Thanks to Florian Weimer and Eric Sesterhenn for reporting, reviewing and testing. CMakeLists.txt | 49 ++- cmake/config.h.cmake | 46 ++- configure.ac | 50 ++- src/Makefile.am | 1 + src/hashtable.c | 67 ++-- src/hashtable.h | 3 +- src/hashtable_seed.c | 278 +++++++++++++ src/jansson.def | 1 + src/jansson.h | 1 + src/lookup3.h | 366 ++++++++++++++++++ src/utf.h | 20 +- src/value.c | 16 + test/bin/json_process.c | 16 +- test/suites/api/test_memory_funcs.c | 6 +- test/suites/api/test_object.c | 64 +-- test/suites/encoding-flags/compact-object/env | 3 +- .../encoding-flags/indent-compact-object/env | 3 +- test/suites/encoding-flags/indent-object/env | 3 +- test/suites/encoding-flags/object/env | 2 + 19 files changed, 873 insertions(+), 122 deletions(-) create mode 100644 src/hashtable_seed.c create mode 100644 src/lookup3.h create mode 100644 test/suites/encoding-flags/object/env", "patch_text_b64": "From 8f80c2d83808150724d31793e6ade92749b1faa4 Mon Sep 17 00:00:00 2001
From: Petri Lehtinen <petri@digip.org>
Date: Tue, 14 Jan 2014 11:16:39 +0200
Subject: [PATCH] CVE-2013-6401: Change hash function, randomize hashes

Thanks to Florian Weimer and Eric Sesterhenn for reporting, reviewing
and testing.
---
 CMakeLists.txt                                |  49 ++-
 cmake/config.h.cmake                          |  46 ++-
 configure.ac                                  |  50 ++-
 src/Makefile.am                               |   1 +
 src/hashtable.c                               |  67 ++--
 src/hashtable.h                               |   3 +-
 src/hashtable_seed.c                          | 278 +++++++++++++
 src/jansson.def                               |   1 +
 src/jansson.h                                 |   1 +
 src/lookup3.h                                 | 366 ++++++++++++++++++
 src/utf.h                                     |  20 +-
 src/value.c                                   |  16 +
 test/bin/json_process.c                       |  16 +-
 test/suites/api/test_memory_funcs.c           |   6 +-
 test/suites/api/test_object.c                 |  64 +--
 test/suites/encoding-flags/compact-object/env |   3 +-
 .../encoding-flags/indent-compact-object/env  |   3 +-
 test/suites/encoding-flags/indent-object/env  |   3 +-
 test/suites/encoding-flags/object/env         |   2 +
 19 files changed, 873 insertions(+), 122 deletions(-)
 create mode 100644 src/hashtable_seed.c
 create mode 100644 src/lookup3.h
 create mode 100644 test/suites/encoding-flags/object/env

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 446ec6e9..1043c9ae 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -52,6 +52,8 @@ project (jansson C)
 
 # Options
 OPTION (BUILD_SHARED_LIBS "Build shared libraries." OFF)
+OPTION (USE_URANDOM "Use /dev/urandom to seed the hash function." ON)
+OPTION (USE_WINDOWS_CRYPTOAPI "Use CryptGenRandom to seed the hash function." ON)
 
 if (MSVC)
    # This option must match the settings used in your program, in particular if you
@@ -85,12 +87,12 @@ set (JANSSON_SOVERSION 4)
 # for CheckFunctionKeywords
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
+INCLUDE (CheckCSourceCompiles)
 include (CheckFunctionExists)
 include (CheckFunctionKeywords)
 include (CheckIncludeFiles)
 include (CheckTypeSize)
 
-
 if (MSVC)
    # Turn off Microsofts "security" warnings.
    add_definitions( "/W3 /D_CRT_SECURE_NO_WARNINGS /wd4005 /wd4996 /nologo" )
@@ -106,14 +108,25 @@ if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
    set(CMAKE_C_FLAGS "-fPIC")
 endif()
 
-   
+check_include_files (endian.h HAVE_ENDIAN_H)
+check_include_files (fcntl.h HAVE_FCNTL_H)
+check_include_files (sched.h HAVE_SCHED_H)
+check_include_files (unistd.h HAVE_UNISTD_H)
+check_include_files (sys/param.h HAVE_SYS_PARAM_H)
+check_include_files (sys/stat.h HAVE_SYS_STAT_H)
+check_include_files (sys/time.h HAVE_SYS_TIME_H)
+check_include_files (sys/time.h HAVE_SYS_TYPES_H)
+
+check_function_exists (close HAVE_CLOSE)
+check_function_exists (getpid HAVE_GETPID)
+check_function_exists (gettimeofday HAVE_GETTIMEOFDAY)
+check_function_exists (open HAVE_OPEN)
+check_function_exists (read HAVE_READ)
+check_function_exists (sched_yield HAVE_SCHED_YIELD)
 
 # Check for the int-type includes
-check_include_files (sys/types.h HAVE_SYS_TYPES_H)
-check_include_files (inttypes.h HAVE_INTTYPES_H)
 check_include_files (stdint.h HAVE_STDINT_H)
 
-
 # Check our 64 bit integer sizes
 check_type_size (__int64 __INT64)
 check_type_size (int64_t INT64_T)
@@ -124,17 +137,32 @@ check_type_size (int32_t INT32_T)
 check_type_size (__int32 __INT32)
 check_type_size ("long" LONG_INT)
 check_type_size ("int" INT)
-
 if (HAVE_INT32_T)
    set (JSON_INT32 int32_t)
 elseif (HAVE___INT32)
    set (JSON_INT32 __int32)
-elseif (HAVE_LONG AND (${LONG_INT} EQUAL 4))
+elseif (HAVE_LONG_INT AND (${LONG_INT} EQUAL 4))
    set (JSON_INT32 long)
 elseif (HAVE_INT AND (${INT} EQUAL 4))
    set (JSON_INT32 int)
 else ()
-   message (FATAL_ERROR "Could not detect a valid 32 bit integer type")
+   message (FATAL_ERROR "Could not detect a valid 32-bit integer type")
+endif ()
+
+check_type_size (uint32_t UINT32_T)
+check_type_size (__uint32 __UINT32)
+check_type_size ("unsigned long" UNSIGNED_LONG_INT)
+check_type_size ("unsigned int" UNSIGNED_INT)
+if (HAVE_UINT32_T)
+   set (JSON_UINT32 uint32_t)
+elseif (HAVE___UINT32)
+   set (JSON_UINT32 __uint32)
+elseif (HAVE_UNSIGNED_LONG_INT AND (${UNSIGNED_LONG_INT} EQUAL 4))
+   set (JSON_UINT32 "unsigned long")
+elseif (HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 4))
+   set (JSON_UINT32 "unsigned int")
+else ()
+   message (FATAL_ERROR "Could not detect a valid unsigned 32-bit integer type")
 endif ()
 
 # Check for ssize_t and SSIZE_T existance.
@@ -206,11 +234,9 @@ else ()
    set (JSON_HAVE_LOCALECONV 0)
 endif ()
 
-
 # check if we have setlocale
 check_function_exists (setlocale HAVE_SETLOCALE)
 
-
 # Check what the inline keyword is.
 # Note that the original JSON_INLINE was always set to just 'inline', so this goes further.
 check_function_keywords("inline")
@@ -238,6 +264,9 @@ elseif (HAVE__SNPRINTF)
    set (JSON_SNPRINTF _snprintf)
 endif ()
 
+check_c_source_compiles ("int main() { unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1); return 0; } " HAVE_SYNC_BUILTINS)
+check_c_source_compiles ("int main() { char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_ACQ_REL); __atomic_load_n(&v, __ATOMIC_ACQUIRE); return 0; }" HAVE_ATOMIC_BUILTINS)
+
 # Create pkg-conf file.
 # (We use the same files as ./configure does, so we
 #  have to defined the same variables used there).
diff --git a/cmake/config.h.cmake b/cmake/config.h.cmake
index bc811784..b27b9a3a 100644
--- a/cmake/config.h.cmake
+++ b/cmake/config.h.cmake
@@ -1,35 +1,36 @@
-/* Reduced down to the defines that are actually used in the code */
-
-/* Define to 1 if you have the <inttypes.h> (and friends) header file. */
-#cmakedefine HAVE_INTTYPES_H 1
-#cmakedefine HAVE_STDINT_H 1
+#cmakedefine HAVE_ENDIAN_H 1
+#cmakedefine HAVE_FCNTL_H 1
+#cmakedefine HAVE_SCHED_H 1
+#cmakedefine HAVE_UNISTD_H 1
+#cmakedefine HAVE_SYS_PARAM_H 1
+#cmakedefine HAVE_SYS_STAT_H 1
+#cmakedefine HAVE_SYS_TIME_H 1
 #cmakedefine HAVE_SYS_TYPES_H 1
+#cmakedefine HAVE_STDINT_H 1
 
-/* We must include this here, as in (eg) utf.h it will want to use
-   the integer type, which in MSVC2010 will be in stdint.h
-   (there is no inttypes.h in MSVC2010) */
-#if defined(HAVE_STDINT_H)
-#  include <stdint.h>
-#elif defined(HAVE_INTTYPES_H)
-#  include <inttypes.h>
-#elif defined(HAVE_SYS_TYPES_H)
-#  include <sys/types.h>
-#endif
+#cmakedefine HAVE_CLOSE 1
+#cmakedefine HAVE_GETPID 1
+#cmakedefine HAVE_GETTIMEOFDAY 1
+#cmakedefine HAVE_OPEN 1
+#cmakedefine HAVE_READ 1
+#cmakedefine HAVE_SCHED_YIELD 1
 
-/* Define to 1 if you have the <locale.h> header file. */
-#cmakedefine HAVE_LOCALE_H 1
+#cmakedefine HAVE_SYNC_BUILTINS 1
+#cmakedefine HAVE_ATOMIC_BUILTINS 1
 
-/* Define to 1 if you have the 'setlocale' function. */
+#cmakedefine HAVE_LOCALE_H 1
 #cmakedefine HAVE_SETLOCALE 1
 
-/* Define to the type of a signed integer type of width exactly 32 bits if
-   such a type exists and the standard includes do not define it. */
 #cmakedefine HAVE_INT32_T 1
-
 #ifndef HAVE_INT32_T
 #  define int32_t @JSON_INT32@
 #endif
 
+#cmakedefine HAVE_UINT32_T 1
+#ifndef HAVE_UINT32_T
+#  define uint32_t @JSON_UINT32@
+#endif
+
 #cmakedefine HAVE_SSIZE_T 1
 
 #ifndef HAVE_SSIZE_T
@@ -43,3 +44,6 @@
 #endif
 
 #cmakedefine HAVE_VSNPRINTF
+
+#cmakedefine USE_URANDOM 1
+#cmakedefine USE_WINDOWS_CRYPTOAPI 1
diff --git a/configure.ac b/configure.ac
index 24ba37d4..113cb85e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -14,10 +14,11 @@ AM_CONDITIONAL([GCC], [test x$GCC = xyes])
 # Checks for libraries.
 
 # Checks for header files.
-AC_CHECK_HEADERS([locale.h])
+AC_CHECK_HEADERS([endian.h fcntl.h locale.h sched.h unistd.h sys/param.h sys/stat.h sys/time.h sys/types.h])
 
 # Checks for typedefs, structures, and compiler characteristics.
 AC_TYPE_INT32_T
+AC_TYPE_UINT32_T
 AC_TYPE_LONG_LONG_INT
 
 AC_C_INLINE
@@ -29,7 +30,31 @@ esac
 AC_SUBST([json_inline])
 
 # Checks for library functions.
-AC_CHECK_FUNCS([strtoll localeconv])
+AC_CHECK_FUNCS([close getpid gettimeofday localeconv open read sched_yield strtoll])
+
+AC_MSG_CHECKING([for gcc __sync builtins])
+have_sync_builtins=no
+AC_TRY_LINK(
+  [], [unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1);],
+  [have_sync_builtins=yes],
+)
+if test "x$have_sync_builtins" = "xyes"; then
+  AC_DEFINE([HAVE_SYNC_BUILTINS], [1],
+    [Define to 1 if gcc's __sync builtins are available])
+fi
+AC_MSG_RESULT([$have_sync_builtins])
+
+AC_MSG_CHECKING([for gcc __atomic builtins])
+have_atomic_builtins=no
+AC_TRY_LINK(
+  [], [char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_ACQ_REL); __atomic_load_n(&v, __ATOMIC_ACQUIRE);],
+  [have_atomic_builtins=yes],
+)
+if test "x$have_atomic_builtins" = "xyes"; then
+  AC_DEFINE([HAVE_ATOMIC_BUILTINS], [1],
+    [Define to 1 if gcc's __atomic builtins are available])
+fi
+AC_MSG_RESULT([$have_atomic_builtins])
 
 case "$ac_cv_type_long_long_int$ac_cv_func_strtoll" in
      yesyes) json_have_long_long=1;;
@@ -43,6 +68,27 @@ case "$ac_cv_header_locale_h$ac_cv_func_localeconv" in
 esac
 AC_SUBST([json_have_localeconv])
 
+# Features
+AC_ARG_ENABLE([urandom],
+  [AS_HELP_STRING([--disable-urandom],
+    [Don't use /dev/urandom to seed the hash function])],
+  [use_urandom=$enableval], [use_urandom=yes])
+
+if test "x$use_urandom" = xyes; then
+AC_DEFINE([USE_URANDOM], [1],
+  [Define to 1 if /dev/urandom should be used for seeding the hash function])
+fi
+
+AC_ARG_ENABLE([windows-cryptoapi],
+  [AS_HELP_STRING([--disable-windows-cryptoapi],
+    [Don't use CryptGenRandom to seed the hash function])],
+  [use_windows_cryptoapi=$enableval], [use_windows_cryptoapi=yes])
+
+if test "x$use_windows_cryptoapi" = xyes; then
+AC_DEFINE([USE_WINDOWS_CRYPTOAPI], [1],
+  [Define to 1 if CryptGenRandom should be used for seeding the hash function])
+fi
+
 AC_CONFIG_FILES([
         jansson.pc
         Makefile
diff --git a/src/Makefile.am b/src/Makefile.am
index e1a54938..b4af562e 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -8,6 +8,7 @@ libjansson_la_SOURCES = \
 	error.c \
 	hashtable.c \
 	hashtable.h \
+	hashtable_seed.c \
 	jansson_private.h \
 	load.c \
 	memory.c \
diff --git a/src/hashtable.c b/src/hashtable.c
index 5fb04679..abd4bf11 100644
--- a/src/hashtable.c
+++ b/src/hashtable.c
@@ -5,8 +5,17 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <stdlib.h>
 #include <string.h>
+
+#if HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
 #include <jansson_config.h>   /* for JSON_INLINE */
 #include "jansson_private.h"  /* for container_of() */
 #include "hashtable.h"
@@ -15,24 +24,13 @@ typedef struct hashtable_list list_t;
 typedef struct hashtable_pair pair_t;
 typedef struct hashtable_bucket bucket_t;
 
-#define list_to_pair(list_)  container_of(list_, pair_t, list)
-
-/* From http://www.cse.yorku.ca/~oz/hash.html */
-static size_t hash_str(const void *ptr)
-{
-    const char *str = (const char *)ptr;
-
-    size_t hash = 5381;
-    size_t c;
+extern volatile uint32_t hashtable_seed;
 
-    while((c = (size_t)*str))
-    {
-        hash = ((hash << 5) + hash) + c;
-        str++;
-    }
+/* Implementation of the hash function */
+#include "lookup3.h"
 
-    return hash;
-}
+#define list_to_pair(list_)  container_of(list_, pair_t, list)
+#define hash_str(key)        ((size_t)hashlittle((key), strlen(key), hashtable_seed))
 
 static JSON_INLINE void list_init(list_t *list)
 {
@@ -74,19 +72,6 @@ static void insert_to_bucket(hashtable_t *hashtable, bucket_t *bucket,
     }
 }
 
-static const size_t primes[] = {
-    5, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
-    49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
-    12582917, 25165843, 50331653, 100663319, 201326611, 402653189,
-    805306457, 1610612741
-};
-
-static JSON_INLINE size_t num_buckets(hashtable_t *hashtable)
-{
-    return primes[hashtable->num_buckets];
-}
-
-
 static pair_t *hashtable_find_pair(hashtable_t *hashtable, bucket_t *bucket,
                                    const char *key, size_t hash)
 {
@@ -120,7 +105,7 @@ static int hashtable_do_del(hashtable_t *hashtable,
     bucket_t *bucket;
     size_t index;
 
-    index = hash % num_buckets(hashtable);
+    index = hash & hashmask(hashtable->order);
     bucket = &hashtable->buckets[index];
 
     pair = hashtable_find_pair(hashtable, bucket, key, hash);
@@ -167,14 +152,14 @@ static int hashtable_do_rehash(hashtable_t *hashtable)
 
     jsonp_free(hashtable->buckets);
 
-    hashtable->num_buckets++;
-    new_size = num_buckets(hashtable);
+    hashtable->order++;
+    new_size = hashsize(hashtable->order);
 
     hashtable->buckets = jsonp_malloc(new_size * sizeof(bucket_t));
     if(!hashtable->buckets)
         return -1;
 
-    for(i = 0; i < num_buckets(hashtable); i++)
+    for(i = 0; i < hashsize(hashtable->order); i++)
     {
         hashtable->buckets[i].first = hashtable->buckets[i].last =
             &hashtable->list;
@@ -199,14 +184,14 @@ int hashtable_init(hashtable_t *hashtable)
     size_t i;
 
     hashtable->size = 0;
-    hashtable->num_buckets = 0;  /* index to primes[] */
-    hashtable->buckets = jsonp_malloc(num_buckets(hashtable) * sizeof(bucket_t));
+    hashtable->order = 3;
+    hashtable->buckets = jsonp_malloc(hashsize(hashtable->order) * sizeof(bucket_t));
     if(!hashtable->buckets)
         return -1;
 
     list_init(&hashtable->list);
 
-    for(i = 0; i < num_buckets(hashtable); i++)
+    for(i = 0; i < hashsize(hashtable->order); i++)
     {
         hashtable->buckets[i].first = hashtable->buckets[i].last =
             &hashtable->list;
@@ -230,12 +215,12 @@ int hashtable_set(hashtable_t *hashtable,
     size_t hash, index;
 
     /* rehash if the load ratio exceeds 1 */
-    if(hashtable->size >= num_buckets(hashtable))
+    if(hashtable->size >= hashsize(hashtable->order))
         if(hashtable_do_rehash(hashtable))
             return -1;
 
     hash = hash_str(key);
-    index = hash % num_buckets(hashtable);
+    index = hash & hashmask(hashtable->order);
     bucket = &hashtable->buckets[index];
     pair = hashtable_find_pair(hashtable, bucket, key, hash);
 
@@ -273,7 +258,7 @@ void *hashtable_get(hashtable_t *hashtable, const char *key)
     bucket_t *bucket;
 
     hash = hash_str(key);
-    bucket = &hashtable->buckets[hash % num_buckets(hashtable)];
+    bucket = &hashtable->buckets[hash & hashmask(hashtable->order)];
 
     pair = hashtable_find_pair(hashtable, bucket, key, hash);
     if(!pair)
@@ -294,7 +279,7 @@ void hashtable_clear(hashtable_t *hashtable)
 
     hashtable_do_clear(hashtable);
 
-    for(i = 0; i < num_buckets(hashtable); i++)
+    for(i = 0; i < hashsize(hashtable->order); i++)
     {
         hashtable->buckets[i].first = hashtable->buckets[i].last =
             &hashtable->list;
@@ -316,7 +301,7 @@ void *hashtable_iter_at(hashtable_t *hashtable, const char *key)
     bucket_t *bucket;
 
     hash = hash_str(key);
-    bucket = &hashtable->buckets[hash % num_buckets(hashtable)];
+    bucket = &hashtable->buckets[hash & hashmask(hashtable->order)];
 
     pair = hashtable_find_pair(hashtable, bucket, key, hash);
     if(!pair)
diff --git a/src/hashtable.h b/src/hashtable.h
index 4a7ce6f6..469c6ecd 100644
--- a/src/hashtable.h
+++ b/src/hashtable.h
@@ -32,7 +32,7 @@ struct hashtable_bucket {
 typedef struct hashtable {
     size_t size;
     struct hashtable_bucket *buckets;
-    size_t num_buckets;  /* index to primes[] */
+    size_t order;  /* hashtable has pow(2, order) buckets */
     struct hashtable_list list;
 } hashtable_t;
 
@@ -40,6 +40,7 @@ typedef struct hashtable {
 #define hashtable_key_to_iter(key_) \
     (&(container_of(key_, struct hashtable_pair, key)->list))
 
+
 /**
  * hashtable_init - Initialize a hashtable object
  *
diff --git a/src/hashtable_seed.c b/src/hashtable_seed.c
new file mode 100644
index 00000000..a07d145d
--- /dev/null
+++ b/src/hashtable_seed.c
@@ -0,0 +1,278 @@
+/* Generate sizeof(uint32_t) bytes of as random data as possible to seed
+   the hash function.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <time.h>
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+
+#ifdef HAVE_SCHED_H
+#include <sched.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#if defined(_WIN32)
+/* For _getpid() */
+#include <process.h>
+#endif
+
+#include "jansson.h"
+
+
+static uint32_t buf_to_uint32(char *data) {
+    size_t i;
+    uint32_t result = 0;
+
+    for (i = 0; i < sizeof(uint32_t); i++)
+        result = (result << 8) | (unsigned char)data[i];
+
+    return result;
+}
+
+
+
+/* /dev/urandom */
+#if !defined(_WIN32) && defined(USE_URANDOM)
+static int seed_from_urandom(uint32_t *seed) {
+    /* Use unbuffered I/O if we have open(), close() and read(). Otherwise
+       fall back to fopen() */
+
+    char data[sizeof(uint32_t)];
+    int ok;
+
+#if defined(HAVE_OPEN) && defined(HAVE_CLOSE) && defined(HAVE_READ)
+    int urandom;
+    urandom = open("/dev/urandom", O_RDONLY);
+    if (urandom == -1)
+        return 1;
+
+    ok = read(urandom, data, sizeof(uint32_t)) == sizeof(uint32_t);
+    close(urandom);
+#else
+    FILE *urandom;
+
+    urandom = fopen("/dev/urandom", "rb");
+    if (!urandom)
+        return 1;
+
+    ok = fread(data, 1, sizeof(uint32_t), urandom) == sizeof(uint32_t);
+    fclose(urandom);
+#endif
+
+    if (!ok)
+        return 1;
+
+    *seed = buf_to_uint32(data);
+    return 0;
+}
+#endif
+
+/* Windows Crypto API */
+#if defined(_WIN32) && defined(USE_WINDOWS_CRYPTOAPI)
+#include <windows.h>
+#include <wincrypt.h>
+
+typedef BOOL (WINAPI *CRYPTACQUIRECONTEXTA)(HCRYPTPROV *phProv, LPCSTR pszContainer, LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags);
+typedef BOOL (WINAPI *CRYPTGENRANDOM)(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer);
+typedef BOOL (WINAPI *CRYPTRELEASECONTEXT)(HCRYPTPROV hProv, DWORD dwFlags);
+
+static int seed_from_windows_cryptoapi(uint32_t *seed)
+{
+    HINSTANCE hAdvAPI32 = NULL;
+    CRYPTACQUIRECONTEXTA pCryptAcquireContext = NULL;
+    CRYPTGENRANDOM pCryptGenRandom = NULL;
+    CRYPTRELEASECONTEXT pCryptReleaseContext = NULL;
+    HCRYPTPROV hCryptProv = 0;
+    BYTE data[sizeof(uint32_t)];
+    int ok;
+
+    hAdvAPI32 = GetModuleHandle("advapi32.dll");
+    if(hAdvAPI32 == NULL)
+        return 1;
+
+    pCryptAcquireContext = (CRYPTACQUIRECONTEXTA)GetProcAddress(hAdvAPI32, "CryptAcquireContextA");
+    if (!pCryptAcquireContext)
+        return 1;
+
+    pCryptGenRandom = (CRYPTGENRANDOM)GetProcAddress(hAdvAPI32, "CryptGenRandom");
+    if (!pCryptGenRandom)
+        return 1;
+
+    pCryptReleaseContext = (CRYPTRELEASECONTEXT)GetProcAddress(hAdvAPI32, "CryptReleaseContext");
+    if (!pCryptReleaseContext)
+        return 1;
+
+    if (!pCryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
+        return 1;
+
+    ok = CryptGenRandom(hCryptProv, sizeof(uint32_t), data);
+    pCryptReleaseContext(hCryptProv, 0);
+
+    if (!ok)
+        return 1;
+
+    *seed = buf_to_uint32((char *)data);
+    return 0;
+}
+#endif
+
+/* gettimeofday() and getpid() */
+static int seed_from_timestamp_and_pid(uint32_t *seed) {
+#ifdef HAVE_GETTIMEOFDAY
+    /* XOR of seconds and microseconds */
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    *seed = (uint32_t)tv.tv_sec ^ (uint32_t)tv.tv_usec;
+#else
+    /* Seconds only */
+    *seed = (uint32_t)time(NULL);
+#endif
+
+    /* XOR with PID for more randomness */
+#if defined(_WIN32)
+    *seed ^= (uint32_t)_getpid();
+#elif defined(HAVE_GETPID)
+    *seed ^= (uint32_t)getpid();
+#endif
+
+    return 0;
+}
+
+static uint32_t generate_seed() {
+    uint32_t seed;
+    int done = 0;
+
+#if !defined(_WIN32) && defined(USE_URANDOM)
+    if (!done && seed_from_urandom(&seed) == 0)
+        done = 1;
+#endif
+
+#if defined(_WIN32) && defined(USE_WINDOWS_CRYPTOAPI)
+    if (!done && seed_from_windows_cryptoapi(&seed) == 0)
+        done = 1;
+#endif
+
+    if (!done) {
+        /* Fall back to timestamp and PID if no better randomness is
+           available */
+        seed_from_timestamp_and_pid(&seed);
+    }
+
+    /* Make sure the seed is never zero */
+    if (seed == 0)
+        seed = 1;
+
+    return seed;
+}
+
+
+volatile uint32_t hashtable_seed = 0;
+
+#if defined(HAVE_ATOMIC_BUILTINS) && (defined(HAVE_SCHED_YIELD) || !defined(_WIN32))
+static volatile char seed_initialized = 0;
+
+void json_object_seed(size_t seed) {
+    uint32_t new_seed = (uint32_t)seed;
+
+    if (hashtable_seed == 0) {
+        if (__atomic_test_and_set(&seed_initialized, __ATOMIC_RELAXED) == 0) {
+            /* Do the seeding ourselves */
+            if (new_seed == 0)
+                new_seed = generate_seed();
+
+            __atomic_store_n(&hashtable_seed, new_seed, __ATOMIC_ACQ_REL);
+        } else {
+            /* Wait for another thread to do the seeding */
+            do {
+#ifdef HAVE_SCHED_YIELD
+                sched_yield();
+#endif
+            } while(__atomic_load_n(&hashtable_seed, __ATOMIC_ACQUIRE) == 0);
+        }
+    }
+}
+#elif defined(HAVE_SYNC_BUILTINS) && (defined(HAVE_SCHED_YIELD) || !defined(_WIN32))
+void json_object_seed(size_t seed) {
+    uint32_t new_seed = (uint32_t)seed;
+
+    if (hashtable_seed == 0) {
+        if (new_seed == 0) {
+            /* Explicit synchronization fences are not supported by the
+               __sync builtins, so every thread getting here has to
+               generate the seed value.
+            */
+            new_seed = generate_seed();
+        }
+
+        do {
+            if (__sync_bool_compare_and_swap(&hashtable_seed, 0, new_seed)) {
+                /* We were the first to seed */
+                break;
+            } else {
+                /* Wait for another thread to do the seeding */
+#ifdef HAVE_SCHED_YIELD
+                sched_yield();
+#endif
+            }
+        } while(hashtable_seed == 0);
+    }
+}
+#elif defined(_WIN32)
+static long seed_initialized = 0;
+void json_object_seed(size_t seed) {
+    uint32_t new_seed = (uint32_t)seed;
+
+    if (hashtable_seed == 0) {
+        if (InterlockedIncrement(&seed_initialized) == 1) {
+            /* Do the seeding ourselves */
+            if (new_seed == 0)
+                new_seed = generate_seed();
+
+            hashtable_seed = new_seed;
+        } else {
+            /* Wait for another thread to do the seeding */
+            do {
+                SwitchToThread();
+            } while (hashtable_seed == 0);
+        }
+    }
+}
+#else
+/* Fall back to a thread-unsafe version */
+void json_object_seed(size_t seed) {
+    uint32_t new_seed = (uint32_t)seed;
+
+    if (hashtable_seed == 0) {
+        if (new_seed == 0)
+            new_seed = generate_seed();
+
+        hashtable_seed = new_seed;
+    }
+}
+#endif
diff --git a/src/jansson.def b/src/jansson.def
index 8cc2e9cb..19096d42 100644
--- a/src/jansson.def
+++ b/src/jansson.def
@@ -41,6 +41,7 @@ EXPORTS
     json_object_iter_value
     json_object_iter_set_new
     json_object_key_to_iter
+    json_object_seed
     json_dumps
     json_dumpf
     json_dump_file
diff --git a/src/jansson.h b/src/jansson.h
index 52c8077d..ea230852 100644
--- a/src/jansson.h
+++ b/src/jansson.h
@@ -126,6 +126,7 @@ typedef struct {
 
 /* getters, setters, manipulation */
 
+void json_object_seed(size_t seed);
 size_t json_object_size(const json_t *object);
 json_t *json_object_get(const json_t *object, const char *key);
 int json_object_set_new(json_t *object, const char *key, json_t *value);
diff --git a/src/lookup3.h b/src/lookup3.h
new file mode 100644
index 00000000..dc76138c
--- /dev/null
+++ b/src/lookup3.h
@@ -0,0 +1,366 @@
+/*
+-------------------------------------------------------------------------------
+lookup3.c, by Bob Jenkins, May 2006, Public Domain.
+
+These are functions for producing 32-bit hashes for hash table lookup.
+hashword(), hashlittle(), hashlittle2(), hashbig(), mix(), and final() 
+are externally useful functions.  Routines to test the hash are included 
+if SELF_TEST is defined.  You can use this free for any purpose.  It's in
+the public domain.  It has no warranty.
+
+You probably want to use hashlittle().  hashlittle() and hashbig()
+hash byte arrays.  hashlittle() is is faster than hashbig() on
+little-endian machines.  Intel and AMD are little-endian machines.
+On second thought, you probably want hashlittle2(), which is identical to
+hashlittle() except it returns two 32-bit hashes for the price of one.  
+You could implement hashbig2() if you wanted but I haven't bothered here.
+
+If you want to find a hash of, say, exactly 7 integers, do
+  a = i1;  b = i2;  c = i3;
+  mix(a,b,c);
+  a += i4; b += i5; c += i6;
+  mix(a,b,c);
+  a += i7;
+  final(a,b,c);
+then use c as the hash value.  If you have a variable length array of
+4-byte integers to hash, use hashword().  If you have a byte array (like
+a character string), use hashlittle().  If you have several byte arrays, or
+a mix of things, see the comments above hashlittle().  
+
+Why is this so big?  I read 12 bytes at a time into 3 4-byte integers, 
+then mix those integers.  This is fast (you can do a lot more thorough
+mixing with 12*3 instructions on 3 integers than you can with 3 instructions
+on 1 byte), but shoehorning those bytes into integers efficiently is messy.
+-------------------------------------------------------------------------------
+*/
+
+#include <stdlib.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>     /* defines uint32_t etc */
+#endif
+
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>  /* attempt to define endianness */
+#endif
+
+#ifdef HAVE_ENDIAN_H
+# include <endian.h>    /* attempt to define endianness */
+#endif
+
+/*
+ * My best guess at if you are big-endian or little-endian.  This may
+ * need adjustment.
+ */
+#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
+     __BYTE_ORDER == __LITTLE_ENDIAN) || \
+    (defined(i386) || defined(__i386__) || defined(__i486__) || \
+     defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL))
+# define HASH_LITTLE_ENDIAN 1
+# define HASH_BIG_ENDIAN 0
+#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \
+       __BYTE_ORDER == __BIG_ENDIAN) || \
+      (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 1
+#else
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 0
+#endif
+
+#define hashsize(n) ((uint32_t)1<<(n))
+#define hashmask(n) (hashsize(n)-1)
+#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
+
+/*
+-------------------------------------------------------------------------------
+mix -- mix 3 32-bit values reversibly.
+
+This is reversible, so any information in (a,b,c) before mix() is
+still in (a,b,c) after mix().
+
+If four pairs of (a,b,c) inputs are run through mix(), or through
+mix() in reverse, there are at least 32 bits of the output that
+are sometimes the same for one pair and different for another pair.
+This was tested for:
+* pairs that differed by one bit, by two bits, in any combination
+  of top bits of (a,b,c), or in any combination of bottom bits of
+  (a,b,c).
+* "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
+  the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+  is commonly produced by subtraction) look like a single 1-bit
+  difference.
+* the base values were pseudorandom, all zero but one bit set, or 
+  all zero plus a counter that starts at zero.
+
+Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
+satisfy this are
+    4  6  8 16 19  4
+    9 15  3 18 27 15
+   14  9  3  7 17  3
+Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
+for "differ" defined as + with a one-bit base and a two-bit delta.  I
+used http://burtleburtle.net/bob/hash/avalanche.html to choose 
+the operations, constants, and arrangements of the variables.
+
+This does not achieve avalanche.  There are input bits of (a,b,c)
+that fail to affect some output bits of (a,b,c), especially of a.  The
+most thoroughly mixed value is c, but it doesn't really even achieve
+avalanche in c.
+
+This allows some parallelism.  Read-after-writes are good at doubling
+the number of bits affected, so the goal of mixing pulls in the opposite
+direction as the goal of parallelism.  I did what I could.  Rotates
+seem to cost as much as shifts on every machine I could lay my hands
+on, and rotates are much kinder to the top and bottom bits, so I used
+rotates.
+-------------------------------------------------------------------------------
+*/
+#define mix(a,b,c) \
+{ \
+  a -= c;  a ^= rot(c, 4);  c += b; \
+  b -= a;  b ^= rot(a, 6);  a += c; \
+  c -= b;  c ^= rot(b, 8);  b += a; \
+  a -= c;  a ^= rot(c,16);  c += b; \
+  b -= a;  b ^= rot(a,19);  a += c; \
+  c -= b;  c ^= rot(b, 4);  b += a; \
+}
+
+/*
+-------------------------------------------------------------------------------
+final -- final mixing of 3 32-bit values (a,b,c) into c
+
+Pairs of (a,b,c) values differing in only a few bits will usually
+produce values of c that look totally different.  This was tested for
+* pairs that differed by one bit, by two bits, in any combination
+  of top bits of (a,b,c), or in any combination of bottom bits of
+  (a,b,c).
+* "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
+  the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+  is commonly produced by subtraction) look like a single 1-bit
+  difference.
+* the base values were pseudorandom, all zero but one bit set, or 
+  all zero plus a counter that starts at zero.
+
+These constants passed:
+ 14 11 25 16 4 14 24
+ 12 14 25 16 4 14 24
+and these came close:
+  4  8 15 26 3 22 24
+ 10  8 15 26 3 22 24
+ 11  8 15 26 3 22 24
+-------------------------------------------------------------------------------
+*/
+#define final(a,b,c) \
+{ \
+  c ^= b; c -= rot(b,14); \
+  a ^= c; a -= rot(c,11); \
+  b ^= a; b -= rot(a,25); \
+  c ^= b; c -= rot(b,16); \
+  a ^= c; a -= rot(c,4);  \
+  b ^= a; b -= rot(a,14); \
+  c ^= b; c -= rot(b,24); \
+}
+
+/*
+-------------------------------------------------------------------------------
+hashlittle() -- hash a variable-length key into a 32-bit value
+  k       : the key (the unaligned variable-length array of bytes)
+  length  : the length of the key, counting by bytes
+  initval : can be any 4-byte value
+Returns a 32-bit value.  Every bit of the key affects every bit of
+the return value.  Two keys differing by one or two bits will have
+totally different hash values.
+
+The best hash table sizes are powers of 2.  There is no need to do
+mod a prime (mod is sooo slow!).  If you need less than 32 bits,
+use a bitmask.  For example, if you need only 10 bits, do
+  h = (h & hashmask(10));
+In which case, the hash table should have hashsize(10) elements.
+
+If you are hashing n strings (uint8_t **)k, do it like this:
+  for (i=0, h=0; i<n; ++i) h = hashlittle( k[i], len[i], h);
+
+By Bob Jenkins, 2006.  bob_jenkins@burtleburtle.net.  You may use this
+code any way you wish, private, educational, or commercial.  It's free.
+
+Use for hash table lookup, or anything where one collision in 2^^32 is
+acceptable.  Do NOT use for cryptographic purposes.
+-------------------------------------------------------------------------------
+*/
+
+static uint32_t hashlittle(const void *key, size_t length, uint32_t initval)
+{
+  uint32_t a,b,c;                                          /* internal state */
+  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+
+  u.ptr = key;
+  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+
+#ifdef VALGRIND
+    const uint8_t  *k8;
+#endif
+
+    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 12;
+      k += 3;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    /* 
+     * "k[2]&0xffffff" actually reads beyond the end of the string, but
+     * then masks off the part it's not allowed to read.  Because the
+     * string is aligned, the masked-off tail is in the same word as the
+     * rest of the string.  Every machine with memory protection I've seen
+     * does it on word boundaries, so is OK with this.  But VALGRIND will
+     * still catch it and complain.  The masking trick does make the hash
+     * noticably faster for short strings (like English words).
+     */
+#ifndef VALGRIND
+
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+    case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+    case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+    case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+    case 5 : b+=k[1]&0xff; a+=k[0]; break;
+    case 4 : a+=k[0]; break;
+    case 3 : a+=k[0]&0xffffff; break;
+    case 2 : a+=k[0]&0xffff; break;
+    case 1 : a+=k[0]&0xff; break;
+    case 0 : return c;              /* zero length strings require no mixing */
+    }
+
+#else /* make valgrind happy */
+
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=((uint32_t)k8[10])<<16;  /* fall through */
+    case 10: c+=((uint32_t)k8[9])<<8;    /* fall through */
+    case 9 : c+=k8[8];                   /* fall through */
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=((uint32_t)k8[6])<<16;   /* fall through */
+    case 6 : b+=((uint32_t)k8[5])<<8;    /* fall through */
+    case 5 : b+=k8[4];                   /* fall through */
+    case 4 : a+=k[0]; break;
+    case 3 : a+=((uint32_t)k8[2])<<16;   /* fall through */
+    case 2 : a+=((uint32_t)k8[1])<<8;    /* fall through */
+    case 1 : a+=k8[0]; break;
+    case 0 : return c;
+    }
+
+#endif /* !valgrind */
+
+  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
+    const uint8_t  *k8;
+
+    /*--------------- all but last block: aligned reads and different mixing */
+    while (length > 12)
+    {
+      a += k[0] + (((uint32_t)k[1])<<16);
+      b += k[2] + (((uint32_t)k[3])<<16);
+      c += k[4] + (((uint32_t)k[5])<<16);
+      mix(a,b,c);
+      length -= 12;
+      k += 6;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 11: c+=((uint32_t)k8[10])<<16;     /* fall through */
+    case 10: c+=k[4];
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 9 : c+=k8[8];                      /* fall through */
+    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 7 : b+=((uint32_t)k8[6])<<16;      /* fall through */
+    case 6 : b+=k[2];
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 5 : b+=k8[4];                      /* fall through */
+    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 3 : a+=((uint32_t)k8[2])<<16;      /* fall through */
+    case 2 : a+=k[0];
+             break;
+    case 1 : a+=k8[0];
+             break;
+    case 0 : return c;                     /* zero length requires no mixing */
+    }
+
+  } else {                        /* need to read the key one byte at a time */
+    const uint8_t *k = (const uint8_t *)key;
+
+    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      a += ((uint32_t)k[1])<<8;
+      a += ((uint32_t)k[2])<<16;
+      a += ((uint32_t)k[3])<<24;
+      b += k[4];
+      b += ((uint32_t)k[5])<<8;
+      b += ((uint32_t)k[6])<<16;
+      b += ((uint32_t)k[7])<<24;
+      c += k[8];
+      c += ((uint32_t)k[9])<<8;
+      c += ((uint32_t)k[10])<<16;
+      c += ((uint32_t)k[11])<<24;
+      mix(a,b,c);
+      length -= 12;
+      k += 12;
+    }
+
+    /*-------------------------------- last block: affect all 32 bits of (c) */
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=((uint32_t)k[11])<<24;
+    case 11: c+=((uint32_t)k[10])<<16;
+    case 10: c+=((uint32_t)k[9])<<8;
+    case 9 : c+=k[8];
+    case 8 : b+=((uint32_t)k[7])<<24;
+    case 7 : b+=((uint32_t)k[6])<<16;
+    case 6 : b+=((uint32_t)k[5])<<8;
+    case 5 : b+=k[4];
+    case 4 : a+=((uint32_t)k[3])<<24;
+    case 3 : a+=((uint32_t)k[2])<<16;
+    case 2 : a+=((uint32_t)k[1])<<8;
+    case 1 : a+=k[0];
+             break;
+    case 0 : return c;
+    }
+  }
+
+  final(a,b,c);
+  return c;
+}
diff --git a/src/utf.h b/src/utf.h
index cb10c24c..b4f10914 100644
--- a/src/utf.h
+++ b/src/utf.h
@@ -10,23 +10,11 @@
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
+#endif
 
-#ifdef HAVE_INTTYPES_H
-/* inttypes.h includes stdint.h in a standard environment, so there's
-no need to include stdint.h separately. If inttypes.h doesn't define
-int32_t, it's defined in config.h. */
-#include <inttypes.h>
-#endif /* HAVE_INTTYPES_H */
-
-#else /* !HAVE_CONFIG_H */
-#ifdef _WIN32
-typedef int int32_t;
-#else /* !_WIN32 */
-/* Assume a standard environment */
-#include <inttypes.h>
-#endif /* _WIN32 */
-
-#endif /* HAVE_CONFIG_H */
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
 
 int utf8_encode(int codepoint, char *buffer, int *size);
 
diff --git a/src/value.c b/src/value.c
index 582849be..1b02d90a 100644
--- a/src/value.c
+++ b/src/value.c
@@ -9,11 +9,19 @@
 #define _GNU_SOURCE
 #endif
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
 #include "jansson.h"
 #include "hashtable.h"
 #include "jansson_private.h"
@@ -36,11 +44,19 @@ static JSON_INLINE void json_init(json_t *json, json_type type)
 
 /*** object ***/
 
+extern volatile uint32_t hashtable_seed;
+
 json_t *json_object(void)
 {
     json_object_t *object = jsonp_malloc(sizeof(json_object_t));
     if(!object)
         return NULL;
+
+    if (!hashtable_seed) {
+        /* Autoseed */
+        json_object_seed(0);
+    }
+
     json_init(&object->json, JSON_OBJECT);
 
     if(hashtable_init(&object->hashtable))
diff --git a/test/bin/json_process.c b/test/bin/json_process.c
index 23afefec..e2c54bd1 100644
--- a/test/bin/json_process.c
+++ b/test/bin/json_process.c
@@ -37,6 +37,8 @@ struct config {
     int sort_keys;
     int strip;
     int use_env;
+    int have_hashseed;
+    int hashseed;
 } conf;
 
 #define l_isspace(c) ((c) == ' ' || (c) == '\n' || (c) == '\r' || (c) == '\t')
@@ -108,6 +110,12 @@ static void read_conf(FILE *conffile)
             conf.sort_keys = atoi(val);
         if (!strcmp(line, "STRIP"))
             conf.strip = atoi(val);
+        if (!strcmp(line, "HASHSEED")) {
+            conf.have_hashseed = 1;
+            conf.hashseed = atoi(val);
+        } else {
+            conf.have_hashseed = 0;
+        }
     }
 
     free(buffer);
@@ -188,6 +196,9 @@ int use_conf(char *test_path)
     if (conf.sort_keys)
         flags |= JSON_SORT_KEYS;
 
+    if (conf.have_hashseed)
+        json_object_seed(conf.hashseed);
+
     if (conf.strip) {
         /* Load to memory, strip leading and trailing whitespace */
         buffer = loadfile(infile);
@@ -265,7 +276,10 @@ int use_env()
         flags |= JSON_PRESERVE_ORDER;
 
     if(getenv_int("JSON_SORT_KEYS"))
-         flags |= JSON_SORT_KEYS;
+        flags |= JSON_SORT_KEYS;
+
+    if(getenv("HASHSEED"))
+        json_object_seed(getenv_int("HASHSEED"));
 
     if(getenv_int("STRIP")) {
         /* Load to memory, strip leading and trailing whitespace */
diff --git a/test/suites/api/test_memory_funcs.c b/test/suites/api/test_memory_funcs.c
index 8737389b..84b17466 100644
--- a/test/suites/api/test_memory_funcs.c
+++ b/test/suites/api/test_memory_funcs.c
@@ -24,13 +24,13 @@ static void create_and_free_complex_object()
 
 static void *my_malloc(size_t size)
 {
-    malloc_called += 1;
+    malloc_called = 1;
     return malloc(size);
 }
 
 static void my_free(void *ptr)
 {
-    free_called += 1;
+    free_called = 1;
     free(ptr);
 }
 
@@ -39,7 +39,7 @@ static void test_simple()
     json_set_alloc_funcs(my_malloc, my_free);
     create_and_free_complex_object();
 
-    if(malloc_called != 20 || free_called != 20)
+    if(malloc_called != 1 || free_called != 1)
         fail("Custom allocation failed");
 }
 
diff --git a/test/suites/api/test_object.c b/test/suites/api/test_object.c
index ba428e19..92e52082 100644
--- a/test/suites/api/test_object.c
+++ b/test/suites/api/test_object.c
@@ -249,7 +249,11 @@ static void test_set_nocheck()
 
 static void test_iterators()
 {
+    int i;
     json_t *object, *foo, *bar, *baz;
+    const char *iter_keys[3];
+    int have_key[3] = { 0, 0, 0 };
+    json_t *iter_values[3];
     void *iter;
 
     if(json_object_iter(NULL))
@@ -276,30 +280,50 @@ static void test_iterators()
     iter = json_object_iter(object);
     if(!iter)
         fail("unable to get iterator");
-    if(strcmp(json_object_iter_key(iter), "a"))
-        fail("iterating failed: wrong key");
-    if(json_object_iter_value(iter) != foo)
-        fail("iterating failed: wrong value");
+    iter_keys[0] = json_object_iter_key(iter);
+    iter_values[0] = json_object_iter_value(iter);
 
     iter = json_object_iter_next(object, iter);
     if(!iter)
         fail("unable to increment iterator");
-    if(strcmp(json_object_iter_key(iter), "b"))
-        fail("iterating failed: wrong key");
-    if(json_object_iter_value(iter) != bar)
-        fail("iterating failed: wrong value");
+    iter_keys[1] = json_object_iter_key(iter);
+    iter_values[1] = json_object_iter_value(iter);
 
     iter = json_object_iter_next(object, iter);
     if(!iter)
         fail("unable to increment iterator");
-    if(strcmp(json_object_iter_key(iter), "c"))
-        fail("iterating failed: wrong key");
-    if(json_object_iter_value(iter) != baz)
-        fail("iterating failed: wrong value");
+    iter_keys[2] = json_object_iter_key(iter);
+    iter_values[2] = json_object_iter_value(iter);
 
     if(json_object_iter_next(object, iter) != NULL)
         fail("able to iterate over the end");
 
+    /* Check that keys have correct values */
+    for (i = 0; i < 3; i++) {
+        if (strcmp(iter_keys[i], "a") == 0) {
+            if (iter_values[i] != foo)
+                fail("wrong value for iter key a");
+            else
+                have_key[0] = 1;
+        } else if (strcmp(iter_keys[i], "b") == 0) {
+            if (iter_values[i] != bar)
+                fail("wrong value for iter key b");
+            else
+                have_key[1] = 1;
+        } else if (strcmp(iter_keys[i], "c") == 0) {
+            if (iter_values[i] != baz)
+                fail("wrong value for iter key c");
+            else
+                have_key[2] = 1;
+        }
+    }
+
+    /* Check that we got all keys */
+    for(i = 0; i < 3; i++) {
+        if(!have_key[i])
+            fail("a key wasn't iterated over");
+    }
+
     if(json_object_iter_at(object, "foo"))
         fail("json_object_iter_at() succeeds for non-existent key");
 
@@ -312,22 +336,14 @@ static void test_iterators()
     if(json_object_iter_value(iter) != bar)
         fail("iterating failed: wrong value");
 
-    iter = json_object_iter_next(object, iter);
-    if(!iter)
-        fail("unable to increment iterator");
-    if(strcmp(json_object_iter_key(iter), "c"))
-        fail("iterating failed: wrong key");
-    if(json_object_iter_value(iter) != baz)
-        fail("iterating failed: wrong value");
-
-    if(json_object_iter_set(object, iter, bar))
+    if(json_object_iter_set(object, iter, baz))
         fail("unable to set value at iterator");
 
-    if(strcmp(json_object_iter_key(iter), "c"))
+    if(strcmp(json_object_iter_key(iter), "b"))
         fail("json_object_iter_key() fails after json_object_iter_set()");
-    if(json_object_iter_value(iter) != bar)
+    if(json_object_iter_value(iter) != baz)
         fail("json_object_iter_value() fails after json_object_iter_set()");
-    if(json_object_get(object, "c") != bar)
+    if(json_object_get(object, "b") != baz)
         fail("json_object_get() fails after json_object_iter_set()");
 
     json_decref(object);
diff --git a/test/suites/encoding-flags/compact-object/env b/test/suites/encoding-flags/compact-object/env
index 4474aaf1..93cb33dd 100644
--- a/test/suites/encoding-flags/compact-object/env
+++ b/test/suites/encoding-flags/compact-object/env
@@ -1,2 +1,3 @@
 JSON_COMPACT=1
-export JSON_COMPACT
+HASHSEED=1
+export JSON_COMPACT HASHSEED
diff --git a/test/suites/encoding-flags/indent-compact-object/env b/test/suites/encoding-flags/indent-compact-object/env
index 78fbfcc2..c73acc17 100644
--- a/test/suites/encoding-flags/indent-compact-object/env
+++ b/test/suites/encoding-flags/indent-compact-object/env
@@ -1,3 +1,4 @@
 JSON_INDENT=4
 JSON_COMPACT=1
-export JSON_INDENT JSON_COMPACT
+HASHSEED=1
+export JSON_INDENT JSON_COMPACT HASHSEED
diff --git a/test/suites/encoding-flags/indent-object/env b/test/suites/encoding-flags/indent-object/env
index d220f837..961558ca 100644
--- a/test/suites/encoding-flags/indent-object/env
+++ b/test/suites/encoding-flags/indent-object/env
@@ -1,2 +1,3 @@
 JSON_INDENT=4
-export JSON_INDENT
+HASHSEED=1
+export JSON_INDENT HASHSEED
diff --git a/test/suites/encoding-flags/object/env b/test/suites/encoding-flags/object/env
new file mode 100644
index 00000000..9120b035
--- /dev/null
+++ b/test/suites/encoding-flags/object/env
@@ -0,0 +1,2 @@
+HASHSEED=1
+export HASHSEED", "url": "https://github.com/akheron/jansson/commit/8f80c2d83808150724d31793e6ade92749b1faa4.patch" } ]
null
GHSA-67p6-88m2-4frh
null
[ { "commit_message": "[PATCH] avcodec/h264: do not trust last_pic_droppable when marking pictures as done This simplifies the code and fixes a deadlock Fixes Ticket2927 Signed-off-by: Michael Niedermayer <michaelni@gmx.at> libavcodec/h264.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/FFmpeg/FFmpeg/commit/29ffeef5e73b8f41ff3a3f2242d356759c66f91f.patch" } ]
null
CVE-2024-27090
Decidim vulnerable to data disclosure through the embed feature
Decidim is a participatory democracy framework, written in Ruby on Rails, originally developed for the Barcelona City government online and offline participation website. If an attacker can infer the slug or URL of an unpublished or private resource, and this resource can be embbeded (such as a Participatory Process, an Assembly, a Proposal, a Result, etc), then some data of this resource could be accessed. This vulnerability is fixed in 0.27.6.
[ { "commit_message": "<andreslucena@users.noreply.github.com> [PATCH] Fix embeds for resources and spaces that shouldn't be embedded (#12528) * Check if the resources and spaces are unpublished when embedding * Check if the spaces are private when embedding * Fix the naming for the `skip_publication_checks` option Co-authored-by: Alexandru Emil Lupu <contact@alecslupu.ro> * Move embed permission to its own action * Fix specs * Prevent accessing widgets from other organizations in multitenant * Fix bug on preventing multitenant access on components' resources * Prevent accessing moderated resources * Fix bug with users registered in a private space Until now we allowed them to embed the private non transparent space. This is a bug because even though they can access, the visitors in their external website would not be able to actually see the embed, so it's better to not allow this embed. * Add spec for checking the Embed link in the resource page * Prevent accessing withdrawn resources * Refactor specs definitions * Prevent or allow accessing initiatives according to their states * Fix specs names * Skip checking embed link in conferences * Fix specs for initiatives * Add all the states in the initiatives' permission spec * Add missing spec for consultations' embeds * Skip checking embed link in consultations' questions * Fix rubocop offense * Query for unpublished spaces Co-authored-by: Alexandru Emil Lupu <contact@alecslupu.ro> * Make consistent the NotFound (404) response on withdrawn resources Co-authored-by: Alexandru Emil Lupu <contact@alecslupu.ro> * Fix specs * Make consistent the NotFound (404) response on initiatives unpublished Co-authored-by: Alexandru Emil Lupu <contact@alecslupu.ro> .../decidim/assemblies/widgets_controller.rb | 12 +- .../decidim/assemblies/permissions.rb | 12 ++ .../decidim/assemblies/permissions_spec.rb | 30 +++ .../spec/system/assembly_embeds_spec.rb | 3 + .../conference_widgets_controller.rb | 12 +- .../decidim/conferences/permissions.rb | 11 + .../decidim/conferences/permissions_spec.rb | 36 ++++ .../spec/system/conference_embeds_spec.rb | 16 +- .../consultation_widgets_controller.rb | 13 +- .../question_widgets_controller.rb | 12 +- .../decidim/consultations/permissions.rb | 22 +- .../consultation_widgets/show.html.erb | 3 + .../decidim/consultations/permissions_spec.rb | 54 +++++ .../spec/system/consultation_embeds_spec.rb | 10 + .../spec/system/question_embeds_spec.rb | 15 +- .../controllers/decidim/widgets_controller.rb | 6 + .../embed_resource_examples.rb | 198 +++++++++++++++++- .../decidim/debates/widgets_controller.rb | 12 +- .../decidim/debates/permissions.rb | 6 + .../decidim/debates/permissions_spec.rb | 14 ++ .../spec/system/debate_embeds_spec.rb | 5 +- .../decidim/initiatives/widgets_controller.rb | 16 +- .../decidim/initiatives/permissions.rb | 10 + .../initiatives/initiatives/show.html.erb | 4 +- .../decidim/initiatives/permissions_spec.rb | 70 +++++++ .../spec/system/initiative_embeds_spec.rb | 66 +++++- .../decidim/meetings/widgets_controller.rb | 12 +- .../decidim/meetings/permissions.rb | 10 + .../decidim/meetings/meetings/show.html.erb | 4 +- .../decidim/meetings/permissions_spec.rb | 22 ++ .../spec/system/meeting_embeds_spec.rb | 5 +- .../widgets_controller.rb | 14 +- .../participatory_processes/permissions.rb | 12 ++ .../permissions_spec.rb | 30 +++ .../spec/system/process_embeds_spec.rb | 2 + .../decidim/proposals/widgets_controller.rb | 12 +- .../decidim/proposals/permissions.rb | 9 + .../decidim/proposals/proposals/show.html.erb | 4 +- .../decidim/proposals/permissions_spec.rb | 8 + .../spec/system/proposal_embeds_spec.rb | 6 +- .../decidim/sortitions/widgets_controller.rb | 12 +- .../decidim/sortitions/permissions.rb | 14 ++ .../decidim/sortitions/permissions_spec.rb | 8 + .../sortitions/sortition_embeds_spec.rb | 4 +- 44 files changed, 799 insertions(+), 57 deletions(-) create mode 100644 decidim-consultations/spec/system/consultation_embeds_spec.rb", "patch_text_b64": "From 1756fa639ef393ca8e8bb16221cab2e2e7875705 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Pereira=20de=20Lucena?=
 <andreslucena@users.noreply.github.com>
Date: Fri, 29 Mar 2024 23:50:02 +0100
Subject: [PATCH] Fix embeds for resources and spaces that shouldn't be
 embedded (#12528)

* Check if the resources and spaces are unpublished when embedding

* Check if the spaces are private when embedding

* Fix the naming for the `skip_publication_checks` option

Co-authored-by: Alexandru Emil Lupu <contact@alecslupu.ro>

* Move embed permission to its own action

* Fix specs

* Prevent accessing widgets from other organizations in multitenant

* Fix bug on preventing multitenant access on components' resources

* Prevent accessing moderated resources

* Fix bug with users registered in a private space

Until now we allowed them to embed the private non transparent space.
This is a bug because even though they can access, the visitors in their
external website would not be able to actually see the embed, so it's
better to not allow this embed.

* Add spec for checking the Embed link in the resource page

* Prevent accessing withdrawn resources

* Refactor specs definitions

* Prevent or allow accessing initiatives according to their states

* Fix specs names

* Skip checking embed link in conferences

* Fix specs for initiatives

* Add all the states in the initiatives' permission spec

* Add missing spec for consultations' embeds

* Skip checking embed link in consultations' questions

* Fix rubocop offense

* Query for unpublished spaces

Co-authored-by: Alexandru Emil Lupu <contact@alecslupu.ro>

* Make consistent the NotFound (404) response on withdrawn resources

Co-authored-by: Alexandru Emil Lupu <contact@alecslupu.ro>

* Fix specs

* Make consistent the NotFound (404) response on initiatives unpublished

---------

Co-authored-by: Alexandru Emil Lupu <contact@alecslupu.ro>
---
 .../decidim/assemblies/widgets_controller.rb  |  12 +-
 .../decidim/assemblies/permissions.rb         |  12 ++
 .../decidim/assemblies/permissions_spec.rb    |  30 +++
 .../spec/system/assembly_embeds_spec.rb       |   3 +
 .../conference_widgets_controller.rb          |  12 +-
 .../decidim/conferences/permissions.rb        |  11 +
 .../decidim/conferences/permissions_spec.rb   |  36 ++++
 .../spec/system/conference_embeds_spec.rb     |  16 +-
 .../consultation_widgets_controller.rb        |  13 +-
 .../question_widgets_controller.rb            |  12 +-
 .../decidim/consultations/permissions.rb      |  22 +-
 .../consultation_widgets/show.html.erb        |   3 +
 .../decidim/consultations/permissions_spec.rb |  54 +++++
 .../spec/system/consultation_embeds_spec.rb   |  10 +
 .../spec/system/question_embeds_spec.rb       |  15 +-
 .../controllers/decidim/widgets_controller.rb |   6 +
 .../embed_resource_examples.rb                | 198 +++++++++++++++++-
 .../decidim/debates/widgets_controller.rb     |  12 +-
 .../decidim/debates/permissions.rb            |   6 +
 .../decidim/debates/permissions_spec.rb       |  14 ++
 .../spec/system/debate_embeds_spec.rb         |   5 +-
 .../decidim/initiatives/widgets_controller.rb |  16 +-
 .../decidim/initiatives/permissions.rb        |  10 +
 .../initiatives/initiatives/show.html.erb     |   4 +-
 .../decidim/initiatives/permissions_spec.rb   |  70 +++++++
 .../spec/system/initiative_embeds_spec.rb     |  66 +++++-
 .../decidim/meetings/widgets_controller.rb    |  12 +-
 .../decidim/meetings/permissions.rb           |  10 +
 .../decidim/meetings/meetings/show.html.erb   |   4 +-
 .../decidim/meetings/permissions_spec.rb      |  22 ++
 .../spec/system/meeting_embeds_spec.rb        |   5 +-
 .../widgets_controller.rb                     |  14 +-
 .../participatory_processes/permissions.rb    |  12 ++
 .../permissions_spec.rb                       |  30 +++
 .../spec/system/process_embeds_spec.rb        |   2 +
 .../decidim/proposals/widgets_controller.rb   |  12 +-
 .../decidim/proposals/permissions.rb          |   9 +
 .../decidim/proposals/proposals/show.html.erb |   4 +-
 .../decidim/proposals/permissions_spec.rb     |   8 +
 .../spec/system/proposal_embeds_spec.rb       |   6 +-
 .../decidim/sortitions/widgets_controller.rb  |  12 +-
 .../decidim/sortitions/permissions.rb         |  14 ++
 .../decidim/sortitions/permissions_spec.rb    |   8 +
 .../sortitions/sortition_embeds_spec.rb       |   4 +-
 44 files changed, 799 insertions(+), 57 deletions(-)
 create mode 100644 decidim-consultations/spec/system/consultation_embeds_spec.rb

diff --git a/decidim-assemblies/app/controllers/decidim/assemblies/widgets_controller.rb b/decidim-assemblies/app/controllers/decidim/assemblies/widgets_controller.rb
index 5472c75ca405e..14655a271c6df 100644
--- a/decidim-assemblies/app/controllers/decidim/assemblies/widgets_controller.rb
+++ b/decidim-assemblies/app/controllers/decidim/assemblies/widgets_controller.rb
@@ -5,10 +5,16 @@ module Assemblies
     class WidgetsController < Decidim::WidgetsController
       helper Decidim::SanitizeHelper
 
+      def show
+        enforce_permission_to :embed, :participatory_space, current_participatory_space: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= Assembly.find_by(slug: params[:assembly_slug])
+        @model ||= Assembly.where(organization: current_organization).public_spaces.find_by(slug: params[:assembly_slug])
       end
 
       def current_participatory_space
@@ -18,6 +24,10 @@ def current_participatory_space
       def iframe_url
         @iframe_url ||= assembly_widget_url(model)
       end
+
+      def permission_class_chain
+        ::Decidim.permissions_registry.chain_for(::Decidim::Assemblies::ApplicationController)
+      end
     end
   end
 end
diff --git a/decidim-assemblies/app/permissions/decidim/assemblies/permissions.rb b/decidim-assemblies/app/permissions/decidim/assemblies/permissions.rb
index 9f1de1819c627..765d8ab3f63be 100644
--- a/decidim-assemblies/app/permissions/decidim/assemblies/permissions.rb
+++ b/decidim-assemblies/app/permissions/decidim/assemblies/permissions.rb
@@ -16,6 +16,7 @@ def permissions
         if permission_action.scope == :public
           public_list_assemblies_action?
           public_read_assembly_action?
+          public_embed_assembly_action?
           public_list_members_action?
           return permission_action
         end
@@ -136,6 +137,17 @@ def public_list_members_action?
         allow!
       end
 
+      def public_embed_assembly_action?
+        return unless permission_action.action == :embed &&
+                      [:assembly, :participatory_space].include?(permission_action.subject) &&
+                      assembly
+
+        return disallow! unless assembly.published?
+        return disallow! if assembly.private_space && !assembly.is_transparent?
+
+        allow!
+      end
+
       # All users with a relation to a assembly and organization admins can enter
       # the space area. The sapce area is considered to be the assemblies zone,
       # not the assembly groups one.
diff --git a/decidim-assemblies/spec/permissions/decidim/assemblies/permissions_spec.rb b/decidim-assemblies/spec/permissions/decidim/assemblies/permissions_spec.rb
index 19b66fd7e7be4..48d10323187c5 100644
--- a/decidim-assemblies/spec/permissions/decidim/assemblies/permissions_spec.rb
+++ b/decidim-assemblies/spec/permissions/decidim/assemblies/permissions_spec.rb
@@ -127,6 +127,36 @@
       end
     end
 
+    context "when embedding an assembly" do
+      let(:action) do
+        { scope: :public, action: :embed, subject: :assembly }
+      end
+      let(:context) { { assembly: assembly } }
+
+      context "when the assembly is published" do
+        let(:user) { create(:user, organization: organization) }
+
+        it { is_expected.to be true }
+      end
+
+      context "when the assembly is not published" do
+        let(:user) { create(:user, organization: organization) }
+        let(:assembly) { create(:assembly, :unpublished, organization: organization) }
+
+        context "when the user doesn't have access to it" do
+          it { is_expected.to be false }
+        end
+
+        context "when the user has access to it" do
+          before do
+            create(:assembly_user_role, user: user, assembly: assembly)
+          end
+
+          it { is_expected.to be false }
+        end
+      end
+    end
+
     context "when listing assemblies" do
       let(:action) do
         { scope: :public, action: :list, subject: :assembly }
diff --git a/decidim-assemblies/spec/system/assembly_embeds_spec.rb b/decidim-assemblies/spec/system/assembly_embeds_spec.rb
index f9f7633291489..be7f78190ee87 100644
--- a/decidim-assemblies/spec/system/assembly_embeds_spec.rb
+++ b/decidim-assemblies/spec/system/assembly_embeds_spec.rb
@@ -4,6 +4,9 @@
 
 describe "Assembly embeds", type: :system do
   let(:resource) { create(:assembly) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(resource).assembly_widget_path }
 
   it_behaves_like "an embed resource", skip_space_checks: true
+  it_behaves_like "a private embed resource"
+  it_behaves_like "a transparent private embed resource"
 end
diff --git a/decidim-conferences/app/controllers/decidim/conferences/conference_widgets_controller.rb b/decidim-conferences/app/controllers/decidim/conferences/conference_widgets_controller.rb
index a44f7a2f8d4ed..7bc532621c3d7 100644
--- a/decidim-conferences/app/controllers/decidim/conferences/conference_widgets_controller.rb
+++ b/decidim-conferences/app/controllers/decidim/conferences/conference_widgets_controller.rb
@@ -5,10 +5,16 @@ module Conferences
     class ConferenceWidgetsController < Decidim::WidgetsController
       helper Decidim::SanitizeHelper
 
+      def show
+        enforce_permission_to :embed, :conference, conference: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= Conference.find_by(slug: params[:conference_slug])
+        @model ||= Conference.where(organization: current_organization).published.find_by(slug: params[:conference_slug])
       end
 
       def current_participatory_space
@@ -18,6 +24,10 @@ def current_participatory_space
       def iframe_url
         @iframe_url ||= conference_conference_widget_url(model)
       end
+
+      def permission_class_chain
+        ::Decidim.permissions_registry.chain_for(::Decidim::Conferences::ApplicationController)
+      end
     end
   end
 end
diff --git a/decidim-conferences/app/permissions/decidim/conferences/permissions.rb b/decidim-conferences/app/permissions/decidim/conferences/permissions.rb
index c1eab3c4c7b48..cd7fae9a4ce1d 100644
--- a/decidim-conferences/app/permissions/decidim/conferences/permissions.rb
+++ b/decidim-conferences/app/permissions/decidim/conferences/permissions.rb
@@ -16,6 +16,7 @@ def permissions
         if permission_action.scope == :public
           public_list_conferences_action?
           public_read_conference_action?
+          public_embed_conference_action?
           public_list_speakers_action?
           public_list_program_action?
           public_list_media_links_action?
@@ -131,6 +132,16 @@ def public_read_conference_action?
         toggle_allow(can_manage_conference?)
       end
 
+      def public_embed_conference_action?
+        return unless permission_action.action == :embed &&
+                      [:conference, :participatory_space].include?(permission_action.subject) &&
+                      conference
+
+        return disallow! unless conference.published?
+
+        allow!
+      end
+
       def public_list_speakers_action?
         return unless permission_action.action == :list &&
                       permission_action.subject == :speakers
diff --git a/decidim-conferences/spec/permissions/decidim/conferences/permissions_spec.rb b/decidim-conferences/spec/permissions/decidim/conferences/permissions_spec.rb
index 7e3f7ba4ef73e..df6d37e6f9fca 100644
--- a/decidim-conferences/spec/permissions/decidim/conferences/permissions_spec.rb
+++ b/decidim-conferences/spec/permissions/decidim/conferences/permissions_spec.rb
@@ -125,6 +125,42 @@
       end
     end
 
+    context "when embedding a conference" do
+      let(:action) do
+        { scope: :public, action: :embed, subject: :conference }
+      end
+      let(:context) { { conference: conference } }
+
+      context "when the user is an admin" do
+        let(:user) { create :user, :admin }
+
+        it { is_expected.to be true }
+      end
+
+      context "when the conference is published" do
+        let(:user) { create :user, organization: organization }
+
+        it { is_expected.to be true }
+      end
+
+      context "when the conference is not published" do
+        let(:user) { create :user, organization: organization }
+        let(:conference) { create :conference, :unpublished, organization: organization }
+
+        context "when the user doesn't have access to it" do
+          it { is_expected.to be false }
+        end
+
+        context "when the user has access to it" do
+          before do
+            create :conference_user_role, user: user, conference: conference
+          end
+
+          it { is_expected.to be false }
+        end
+      end
+    end
+
     context "when listing conferences" do
       let(:action) do
         { scope: :public, action: :list, subject: :conference }
diff --git a/decidim-conferences/spec/system/conference_embeds_spec.rb b/decidim-conferences/spec/system/conference_embeds_spec.rb
index f00c21f4e1ae4..25affa7682c35 100644
--- a/decidim-conferences/spec/system/conference_embeds_spec.rb
+++ b/decidim-conferences/spec/system/conference_embeds_spec.rb
@@ -3,18 +3,8 @@
 require "spec_helper"
 
 describe "Conference embeds", type: :system do
-  let!(:conference) { create(:conference) }
+  let!(:resource) { create(:conference) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(resource).conference_conference_widget_path }
 
-  context "when visiting the embed page for an conference" do
-    before do
-      switch_to_host(conference.organization.host)
-      visit resource_locator(conference).path
-      visit "#{current_path}/embed"
-    end
-
-    it "renders the page correctly" do
-      expect(page).to have_i18n_content(conference.title)
-      expect(page).to have_content(conference.organization.name)
-    end
-  end
+  it_behaves_like "an embed resource", skip_space_checks: true, skip_link_checks: true
 end
diff --git a/decidim-consultations/app/controllers/decidim/consultations/consultation_widgets_controller.rb b/decidim-consultations/app/controllers/decidim/consultations/consultation_widgets_controller.rb
index 0602e7ad5f3f9..a2993077ee229 100644
--- a/decidim-consultations/app/controllers/decidim/consultations/consultation_widgets_controller.rb
+++ b/decidim-consultations/app/controllers/decidim/consultations/consultation_widgets_controller.rb
@@ -4,13 +4,20 @@ module Decidim
   module Consultations
     class ConsultationWidgetsController < Decidim::WidgetsController
       helper Decidim::SanitizeHelper
+      helper ConsultationsHelper
 
       layout false
 
+      def show
+        enforce_permission_to :embed, :participatory_space, current_participatory_space: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= Consultation.find_by(slug: params[:consultation_slug])
+        @model ||= Consultation.where(organization: current_organization).published.find_by(slug: params[:consultation_slug])
       end
 
       def current_participatory_space
@@ -20,6 +27,10 @@ def current_participatory_space
       def iframe_url
         @iframe_url ||= consultation_consultation_widget_url(model)
       end
+
+      def permission_class_chain
+        ::Decidim.permissions_registry.chain_for(::Decidim::Consultations::ApplicationController)
+      end
     end
   end
 end
diff --git a/decidim-consultations/app/controllers/decidim/consultations/question_widgets_controller.rb b/decidim-consultations/app/controllers/decidim/consultations/question_widgets_controller.rb
index d43f90cbc2ab1..15e3c7a85437b 100644
--- a/decidim-consultations/app/controllers/decidim/consultations/question_widgets_controller.rb
+++ b/decidim-consultations/app/controllers/decidim/consultations/question_widgets_controller.rb
@@ -8,10 +8,16 @@ class QuestionWidgetsController < Decidim::WidgetsController
 
       helper Decidim::SanitizeHelper
 
+      def show
+        enforce_permission_to :embed, :question, question: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= current_question
+        @model ||= current_question if current_question.published?
       end
 
       def current_participatory_space
@@ -21,6 +27,10 @@ def current_participatory_space
       def iframe_url
         @iframe_url ||= question_question_widget_url(model)
       end
+
+      def permission_class_chain
+        ::Decidim.permissions_registry.chain_for(::Decidim::Consultations::ApplicationController)
+      end
     end
   end
 end
diff --git a/decidim-consultations/app/permissions/decidim/consultations/permissions.rb b/decidim-consultations/app/permissions/decidim/consultations/permissions.rb
index fb197858c07f3..2d3c8b5f73017 100644
--- a/decidim-consultations/app/permissions/decidim/consultations/permissions.rb
+++ b/decidim-consultations/app/permissions/decidim/consultations/permissions.rb
@@ -5,6 +5,8 @@ module Consultations
     class Permissions < Decidim::DefaultPermissions
       def permissions
         allowed_public_anonymous_action?
+        allowed_public_embed_consultation_action?
+        allowed_public_embed_question_action?
 
         return permission_action unless user
 
@@ -22,7 +24,7 @@ def question
       end
 
       def consultation
-        @consultation ||= context.fetch(:consultation, nil)
+        @consultation ||= context.fetch(:current_participatory_space, nil) || context.fetch(:consultation, nil)
       end
 
       def authorized?(permission_action, resource: nil)
@@ -45,6 +47,24 @@ def allowed_public_anonymous_action?
         end
       end
 
+      def allowed_public_embed_consultation_action?
+        return unless permission_action.action == :embed &&
+                      [:consultation, :participatory_space].include?(permission_action.subject) &&
+                      consultation
+
+        return disallow! unless consultation.published?
+
+        allow!
+      end
+
+      def allowed_public_embed_question_action?
+        return unless permission_action.action == :embed && permission_action.subject == :question && question
+
+        return disallow! unless question.published?
+
+        allow!
+      end
+
       def allowed_public_action?
         return unless permission_action.scope == :public
         return unless permission_action.subject == :question
diff --git a/decidim-consultations/app/views/decidim/consultations/consultation_widgets/show.html.erb b/decidim-consultations/app/views/decidim/consultations/consultation_widgets/show.html.erb
index ce787f3e484ba..777af2af27486 100644
--- a/decidim-consultations/app/views/decidim/consultations/consultation_widgets/show.html.erb
+++ b/decidim-consultations/app/views/decidim/consultations/consultation_widgets/show.html.erb
@@ -1,3 +1,6 @@
+<p><%= translated_attribute(model.title) %></p>
+<p><%= current_organization.name %></p>
+
 <%= render partial: "decidim/consultations/consultations/consultation_details", locals: { consultation: model } %>
 <%= render partial: "decidim/consultations/consultations/highlighted_questions", locals: { consultation: model } %>
 <%= render partial: "decidim/consultations/consultations/regular_questions", locals: { consultation: model } %>
diff --git a/decidim-consultations/spec/permissions/decidim/consultations/permissions_spec.rb b/decidim-consultations/spec/permissions/decidim/consultations/permissions_spec.rb
index 3792393f3220a..df742add501d2 100644
--- a/decidim-consultations/spec/permissions/decidim/consultations/permissions_spec.rb
+++ b/decidim-consultations/spec/permissions/decidim/consultations/permissions_spec.rb
@@ -52,6 +52,33 @@
       end
     end
 
+    context "when embedding a consultation" do
+      let(:action_name) { :embed }
+      let(:action_subject) { :consultation }
+
+      context "when the consultation is published" do
+        let(:consultation) { create :consultation, :published }
+
+        it { is_expected.to be true }
+      end
+
+      context "when the consultation is not published" do
+        let(:consultation) { create :consultation, :unpublished }
+
+        context "when the user is not an admin" do
+          let(:user) { nil }
+
+          it { is_expected.to be false }
+        end
+
+        context "when the user is an admin" do
+          let(:user) { create :user, :admin, organization: organization }
+
+          it { is_expected.to be false }
+        end
+      end
+    end
+
     context "when reading a question" do
       let(:action_subject) { :question }
 
@@ -78,6 +105,33 @@
       end
     end
 
+    context "when embedding a question" do
+      let(:action_name) { :embed }
+      let(:action_subject) { :question }
+
+      context "when the question is published" do
+        let(:question) { create :question, :published, consultation: consultation }
+
+        it { is_expected.to be true }
+      end
+
+      context "when the question is not published" do
+        let(:question) { create :question, :unpublished, consultation: consultation }
+
+        context "when the user is not an admin" do
+          let(:user) { nil }
+
+          it { is_expected.to be false }
+        end
+
+        context "when the user is an admin" do
+          let(:user) { create :user, :admin, organization: organization }
+
+          it { is_expected.to be false }
+        end
+      end
+    end
+
     context "when voting a question" do
       let(:action_subject) { :question }
       let(:action_name) { :vote }
diff --git a/decidim-consultations/spec/system/consultation_embeds_spec.rb b/decidim-consultations/spec/system/consultation_embeds_spec.rb
new file mode 100644
index 0000000000000..13c88603fada0
--- /dev/null
+++ b/decidim-consultations/spec/system/consultation_embeds_spec.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "Consultation embeds", type: :system do
+  let(:resource) { create(:consultation) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(resource).consultation_consultation_widget_path }
+
+  it_behaves_like "an embed resource", skip_space_checks: true, skip_link_checks: true
+end
diff --git a/decidim-consultations/spec/system/question_embeds_spec.rb b/decidim-consultations/spec/system/question_embeds_spec.rb
index e425b7af46bef..531f22190dbcf 100644
--- a/decidim-consultations/spec/system/question_embeds_spec.rb
+++ b/decidim-consultations/spec/system/question_embeds_spec.rb
@@ -3,17 +3,8 @@
 require "spec_helper"
 
 describe "Question embeds", type: :system do
-  let(:question) { create(:question) }
+  let(:resource) { create(:question) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(resource).question_question_widget_path }
 
-  context "when visiting the embed page for a question" do
-    before do
-      switch_to_host(question.organization.host)
-      visit "#{decidim_consultations.question_path(question)}/embed"
-    end
-
-    it "renders the page correctly" do
-      expect(page).to have_i18n_content(question.title)
-      expect(page).to have_content(question.organization.name)
-    end
-  end
+  it_behaves_like "an embed resource", skip_space_checks: true, skip_link_checks: true
 end
diff --git a/decidim-core/app/controllers/decidim/widgets_controller.rb b/decidim-core/app/controllers/decidim/widgets_controller.rb
index b35fda6c9475b..30d11e0ca37f9 100644
--- a/decidim-core/app/controllers/decidim/widgets_controller.rb
+++ b/decidim-core/app/controllers/decidim/widgets_controller.rb
@@ -11,6 +11,8 @@ class WidgetsController < Decidim::ApplicationController
     helper_method :model, :iframe_url, :current_participatory_space
 
     def show
+      raise ActionController::RoutingError, "Not Found" if model.nil?
+
       respond_to do |format|
         format.js { render "decidim/widgets/show" }
         format.html
@@ -19,6 +21,10 @@ def show
 
     private
 
+    def current_component
+      @current_component ||= request.env["decidim.current_component"]
+    end
+
     def current_participatory_space
       @current_participatory_space ||= model.component.participatory_space
     end
diff --git a/decidim-core/lib/decidim/core/test/shared_examples/embed_resource_examples.rb b/decidim-core/lib/decidim/core/test/shared_examples/embed_resource_examples.rb
index 7339bae1dbf61..2ff5b774df9aa 100644
--- a/decidim-core/lib/decidim/core/test/shared_examples/embed_resource_examples.rb
+++ b/decidim-core/lib/decidim/core/test/shared_examples/embed_resource_examples.rb
@@ -1,5 +1,50 @@
 # frozen_string_literal: true
 
+require "decidim/admin/test/admin_participatory_space_access_examples"
+
+shared_examples "rendering the embed page correctly" do
+  before do
+    visit widget_path
+  end
+
+  it "renders" do
+    if resource.title.is_a?(Hash)
+      expect(page).to have_i18n_content(resource.title)
+    else
+      expect(page).to have_content(resource.title)
+    end
+
+    expect(page).to have_content(organization.name)
+  end
+end
+
+shared_examples "rendering the embed link in the resource page" do
+  before do
+    visit resource_locator(resource).path
+  end
+
+  it "has the embed link" do
+    expect(page).to have_button("Embed")
+  end
+end
+
+shared_examples "showing the unauthorized message in the widget_path" do
+  it do
+    visit widget_path
+    expect(page).to have_content "You are not authorized to perform this action"
+  end
+end
+
+shared_examples "not rendering the embed link in the resource page" do
+  before do
+    visit resource_locator(resource).path
+  end
+
+  it "does not have the embed link" do
+    expect(page).to have_no_button("Embed")
+  end
+end
+
 shared_examples_for "an embed resource" do |options|
   if options.is_a?(Hash) && options[:skip_space_checks]
     let(:organization) { resource.organization }
@@ -11,22 +56,29 @@
     include_context "with a component"
   end
 
-  context "when visiting the embed page for a resource" do
-    before do
-      visit resource_locator(resource).path
-      visit "#{current_path}/embed"
-    end
+  unless options.is_a?(Hash) && options[:skip_publication_checks]
+    context "when the resource is not published" do
+      before do
+        resource.unpublish!
+      end
+
+      it_behaves_like "not rendering the embed link in the resource page"
 
-    it "renders the page correctly" do
-      if resource.title.is_a?(Hash)
-        expect(page).to have_i18n_content(resource.title)
-      else
-        expect(page).to have_content(resource.title)
+      it_behaves_like "a 404 page" do
+        let(:target_path) { widget_path }
       end
+    end
+  end
+
+  it_behaves_like "rendering the embed link in the resource page" unless options.is_a?(Hash) && options[:skip_link_checks]
 
-      expect(page).to have_content(organization.name)
+  context "when visiting the embed page for a resource" do
+    before do
+      visit widget_path
     end
 
+    it_behaves_like "rendering the embed page correctly"
+
     unless options.is_a?(Hash) && options[:skip_space_checks]
       context "when the participatory_space is a process" do
         it "shows the process name" do
@@ -47,3 +99,127 @@
     end
   end
 end
+
+shared_examples_for "a private embed resource" do
+  let(:organization) { resource.organization }
+  let!(:other_user) { create(:user, :confirmed, organization: organization) }
+  let!(:participatory_space_private_user) { create(:participatory_space_private_user, user: other_user, privatable_to: resource) }
+
+  before do
+    switch_to_host(organization.host)
+  end
+
+  context "when the resource is private" do
+    before do
+      resource.update!(private_space: true)
+      resource.update!(is_transparent: false) if resource.respond_to?(:is_transparent)
+    end
+
+    context "and user is a visitor" do
+      let(:user) { nil }
+
+      it_behaves_like "not rendering the embed link in the resource page"
+
+      it_behaves_like "a 404 page" do
+        let(:target_path) { widget_path }
+      end
+    end
+
+    context "and user is a registered user" do
+      let(:user) { create(:user, :confirmed, organization: organization) }
+
+      before do
+        sign_in user, scope: :user
+      end
+
+      it_behaves_like "not rendering the embed link in the resource page"
+
+      it_behaves_like "a 404 page" do
+        let(:target_path) { widget_path }
+      end
+    end
+
+    context "and user is a private user" do
+      let(:user) { other_user }
+
+      before do
+        sign_in user, scope: :user
+      end
+
+      it_behaves_like "a 404 page" do
+        let(:target_path) { widget_path }
+      end
+    end
+  end
+end
+
+shared_examples_for "a transparent private embed resource" do
+  let(:organization) { resource.organization }
+  let!(:other_user) { create(:user, :confirmed, organization: organization) }
+  let!(:participatory_space_private_user) { create(:participatory_space_private_user, user: other_user, privatable_to: resource) }
+
+  before do
+    switch_to_host(organization.host)
+  end
+
+  context "when the resource is private" do
+    before do
+      resource.update!(private_space: true)
+      resource.update!(is_transparent: true) if resource.respond_to?(:is_transparent)
+    end
+
+    context "and user is a visitor" do
+      let(:user) { nil }
+
+      it_behaves_like "rendering the embed page correctly"
+    end
+
+    context "and user is a registered user" do
+      let(:user) { create(:user, :confirmed, organization: organization) }
+
+      before do
+        sign_in user, scope: :user
+      end
+
+      it_behaves_like "rendering the embed page correctly"
+    end
+
+    context "and user is a private user" do
+      let(:user) { other_user }
+
+      before do
+        sign_in user, scope: :user
+      end
+
+      it_behaves_like "rendering the embed page correctly"
+    end
+  end
+end
+
+shared_examples_for "a moderated embed resource" do
+  include_context "with a component"
+
+  context "when the resource is moderated" do
+    let!(:moderation) { create(:moderation, reportable: resource, hidden_at: 2.days.ago) }
+
+    it_behaves_like "a 404 page" do
+      let(:target_path) { widget_path }
+    end
+  end
+end
+
+shared_examples_for "a withdrawn embed resource" do
+  include_context "with a component"
+
+  context "when the resource is withdrawn" do
+    before do
+      resource.update!(state: "withdrawn")
+    end
+
+    it_behaves_like "not rendering the embed link in the resource page"
+
+    it_behaves_like "a 404 page" do
+      let(:target_path) { widget_path }
+    end
+  end
+end
diff --git a/decidim-debates/app/controllers/decidim/debates/widgets_controller.rb b/decidim-debates/app/controllers/decidim/debates/widgets_controller.rb
index f74d5facb9556..3ea5d1a82d15f 100644
--- a/decidim-debates/app/controllers/decidim/debates/widgets_controller.rb
+++ b/decidim-debates/app/controllers/decidim/debates/widgets_controller.rb
@@ -5,15 +5,25 @@ module Debates
     class WidgetsController < Decidim::WidgetsController
       helper Debates::ApplicationHelper
 
+      def show
+        enforce_permission_to :embed, :debate, debate: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= Debate.where(component: params[:component_id]).find(params[:debate_id])
+        @model ||= Debate.not_hidden.where(component: current_component).find(params[:debate_id])
       end
 
       def iframe_url
         @iframe_url ||= debate_widget_url(model)
       end
+
+      def permission_class_chain
+        [Decidim::Debates::Permissions]
+      end
     end
   end
 end
diff --git a/decidim-debates/app/permissions/decidim/debates/permissions.rb b/decidim-debates/app/permissions/decidim/debates/permissions.rb
index a18b32d710036..49adf0025b90d 100644
--- a/decidim-debates/app/permissions/decidim/debates/permissions.rb
+++ b/decidim-debates/app/permissions/decidim/debates/permissions.rb
@@ -21,6 +21,8 @@ def permissions
           can_endorse_debate?
         when :close
           can_close_debate?
+        when :embed
+          can_embed_debate?
         end
 
         permission_action
@@ -45,6 +47,10 @@ def can_close_debate?
         disallow!
       end
 
+      def can_embed_debate?
+        allow!
+      end
+
       def can_endorse_debate?
         return disallow! if debate.closed?
 
diff --git a/decidim-debates/spec/permissions/decidim/debates/permissions_spec.rb b/decidim-debates/spec/permissions/decidim/debates/permissions_spec.rb
index 9f75483ff20f3..99a19eb7e313e 100644
--- a/decidim-debates/spec/permissions/decidim/debates/permissions_spec.rb
+++ b/decidim-debates/spec/permissions/decidim/debates/permissions_spec.rb
@@ -106,4 +106,18 @@
       it { is_expected.to be false }
     end
   end
+
+  context "when embedding a debate" do
+    let(:action) do
+      { scope: :public, action: :embed, subject: :debate }
+    end
+
+    it { is_expected.to be true }
+
+    context "when the debate is closed" do
+      let(:debate) { create :debate, :closed, component: debates_component }
+
+      it { is_expected.to be true }
+    end
+  end
 end
diff --git a/decidim-debates/spec/system/debate_embeds_spec.rb b/decidim-debates/spec/system/debate_embeds_spec.rb
index 399bddeacaccf..d524ede8d3169 100644
--- a/decidim-debates/spec/system/debate_embeds_spec.rb
+++ b/decidim-debates/spec/system/debate_embeds_spec.rb
@@ -4,8 +4,11 @@
 
 describe "Debate embeds", type: :system do
   include_context "with a component"
+
   let(:manifest_name) { "debates" }
   let!(:resource) { create(:debate, component: component, skip_injection: true) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(component).debate_widget_path(resource) }
 
-  it_behaves_like "an embed resource"
+  it_behaves_like "an embed resource", skip_publication_checks: true
+  it_behaves_like "a moderated embed resource"
 end
diff --git a/decidim-initiatives/app/controllers/decidim/initiatives/widgets_controller.rb b/decidim-initiatives/app/controllers/decidim/initiatives/widgets_controller.rb
index b2d7e902acb0e..72a02ddc0ea2a 100644
--- a/decidim-initiatives/app/controllers/decidim/initiatives/widgets_controller.rb
+++ b/decidim-initiatives/app/controllers/decidim/initiatives/widgets_controller.rb
@@ -12,10 +12,20 @@ class WidgetsController < Decidim::WidgetsController
 
       include NeedsInitiative
 
+      def show
+        enforce_permission_to :embed, :participatory_space, current_participatory_space: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= current_initiative
+        @model ||= if current_initiative.created? || current_initiative.validating? || current_initiative.discarded?
+                     nil
+                   else
+                     current_initiative
+                   end
       end
 
       def current_participatory_space
@@ -25,6 +35,10 @@ def current_participatory_space
       def iframe_url
         @iframe_url ||= initiative_widget_url(model)
       end
+
+      def permission_class_chain
+        ::Decidim.permissions_registry.chain_for(::Decidim::Initiatives::ApplicationController)
+      end
     end
   end
 end
diff --git a/decidim-initiatives/app/permissions/decidim/initiatives/permissions.rb b/decidim-initiatives/app/permissions/decidim/initiatives/permissions.rb
index 429c31d06ce69..ccca0058770d0 100644
--- a/decidim-initiatives/app/permissions/decidim/initiatives/permissions.rb
+++ b/decidim-initiatives/app/permissions/decidim/initiatives/permissions.rb
@@ -11,6 +11,7 @@ def permissions
         # Non-logged users permissions
         list_public_initiatives?
         read_public_initiative?
+        embed_public_initiative?
         search_initiative_types_and_scopes?
         request_membership?
 
@@ -57,6 +58,15 @@ def read_public_initiative?
         disallow!
       end
 
+      def embed_public_initiative?
+        return unless [:initiative, :participatory_space].include?(permission_action.subject) &&
+                      permission_action.action == :embed
+
+        return disallow! if initiative.created? || initiative.validating? || initiative.discarded?
+
+        allow!
+      end
+
       def search_initiative_types_and_scopes?
         return unless permission_action.action == :search
         return unless [:initiative_type, :initiative_type_scope, :initiative_type_signature_types].include?(permission_action.subject)
diff --git a/decidim-initiatives/app/views/decidim/initiatives/initiatives/show.html.erb b/decidim-initiatives/app/views/decidim/initiatives/initiatives/show.html.erb
index c39f247d3d1d7..ebb5a421f3c66 100644
--- a/decidim-initiatives/app/views/decidim/initiatives/initiatives/show.html.erb
+++ b/decidim-initiatives/app/views/decidim/initiatives/initiatives/show.html.erb
@@ -65,7 +65,9 @@ edit_link(
       </div>
     <% end %>
     <%= render partial: "decidim/shared/share_modal" %>
-    <%= embed_modal_for initiative_widget_url(current_initiative, format: :js) %>
+    <% if allowed_to? :embed, :initiative, initiative: current_initiative %>
+      <%= embed_modal_for initiative_widget_url(current_initiative, format: :js) %>
+    <% end %>
     <%= resource_reference(current_initiative) %>
     <%= resource_version(current_initiative, versions_path: initiative_versions_path(current_initiative)) %>
   </div>
diff --git a/decidim-initiatives/spec/permissions/decidim/initiatives/permissions_spec.rb b/decidim-initiatives/spec/permissions/decidim/initiatives/permissions_spec.rb
index a7200a62559d5..deb44daf7fbd1 100644
--- a/decidim-initiatives/spec/permissions/decidim/initiatives/permissions_spec.rb
+++ b/decidim-initiatives/spec/permissions/decidim/initiatives/permissions_spec.rb
@@ -149,6 +149,76 @@
     end
   end
 
+  context "when emeding an initiative" do
+    let(:initiative) { create(:initiative, :accepted, organization: organization) }
+    let(:action) do
+      { scope: :public, action: :embed, subject: :initiative }
+    end
+    let(:context) do
+      { initiative: initiative }
+    end
+
+    context "when initiative is created" do
+      let(:initiative) { create(:initiative, :created, organization: organization) }
+
+      it { is_expected.to be false }
+    end
+
+    context "when initiative is validating" do
+      let(:initiative) { create(:initiative, :validating, organization: organization) }
+
+      it { is_expected.to be false }
+    end
+
+    context "when initiative is discarded" do
+      let(:initiative) { create(:initiative, :discarded, organization: organization) }
+
+      it { is_expected.to be false }
+    end
+
+    context "when initiative is published" do
+      let(:initiative) { create(:initiative, :published, organization: organization) }
+
+      it { is_expected.to be true }
+    end
+
+    context "when initiative is rejected" do
+      let(:initiative) { create(:initiative, :rejected, organization: organization) }
+
+      it { is_expected.to be true }
+    end
+
+    context "when initiative is accepted" do
+      let(:initiative) { create(:initiative, :accepted, organization: organization) }
+
+      it { is_expected.to be true }
+    end
+
+    context "when user is admin" do
+      let(:user) { create(:user, :admin, organization: organization) }
+
+      it { is_expected.to be true }
+    end
+
+    context "when user is author of the initiative" do
+      let(:initiative) { create(:initiative, author: user, organization: organization) }
+
+      it { is_expected.to be true }
+    end
+
+    context "when user is committee member of the initiative" do
+      before do
+        create(:initiatives_committee_member, initiative: initiative, user: user)
+      end
+
+      it { is_expected.to be true }
+    end
+
+    context "when any other condition" do
+      it { is_expected.to be true }
+    end
+  end
+
   context "when listing committee members of the initiative as author" do
     let(:initiative) { create(:initiative, organization: organization, author: user) }
     let(:action) do
diff --git a/decidim-initiatives/spec/system/initiative_embeds_spec.rb b/decidim-initiatives/spec/system/initiative_embeds_spec.rb
index 9831afa8e43d9..b788506d3d67b 100644
--- a/decidim-initiatives/spec/system/initiative_embeds_spec.rb
+++ b/decidim-initiatives/spec/system/initiative_embeds_spec.rb
@@ -3,7 +3,69 @@
 require "spec_helper"
 
 describe "Initiative embeds", type: :system do
-  let(:resource) { create(:initiative) }
+  let(:state) { :published }
+  let(:resource) { create(:initiative, state: state) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(resource).initiative_widget_path }
 
-  it_behaves_like "an embed resource", skip_space_checks: true
+  it_behaves_like "an embed resource", skip_space_checks: true, skip_publication_checks: true
+
+  context "when the user is the initiative author" do
+    let(:organization) { resource.organization }
+    let(:user) { resource.author }
+
+    before do
+      switch_to_host(organization.host)
+    end
+
+    context "when the state is created" do
+      let(:state) { :created }
+
+      it_behaves_like "not rendering the embed link in the resource page"
+
+      it_behaves_like "a 404 page" do
+        let(:target_path) { widget_path }
+      end
+    end
+
+    context "when the state is validating" do
+      let(:state) { :validating }
+
+      it_behaves_like "not rendering the embed link in the resource page"
+
+      it_behaves_like "a 404 page" do
+        let(:target_path) { widget_path }
+      end
+    end
+
+    context "when the state is discarded" do
+      let(:state) { :discarded }
+
+      # A discarded initiative is not available anymore to authors
+
+      it_behaves_like "a 404 page" do
+        let(:target_path) { widget_path }
+      end
+    end
+
+    context "when the state is published" do
+      let(:state) { :published }
+
+      it_behaves_like "rendering the embed link in the resource page"
+      it_behaves_like "rendering the embed page correctly"
+    end
+
+    context "when the state is rejected" do
+      let(:state) { :rejected }
+
+      it_behaves_like "rendering the embed link in the resource page"
+      it_behaves_like "rendering the embed page correctly"
+    end
+
+    context "when the state is accepted" do
+      let(:state) { :accepted }
+
+      it_behaves_like "rendering the embed link in the resource page"
+      it_behaves_like "rendering the embed page correctly"
+    end
+  end
 end
diff --git a/decidim-meetings/app/controllers/decidim/meetings/widgets_controller.rb b/decidim-meetings/app/controllers/decidim/meetings/widgets_controller.rb
index 9586abd47f07a..6eaa6bbbb52c1 100644
--- a/decidim-meetings/app/controllers/decidim/meetings/widgets_controller.rb
+++ b/decidim-meetings/app/controllers/decidim/meetings/widgets_controller.rb
@@ -6,15 +6,25 @@ class WidgetsController < Decidim::WidgetsController
       helper MeetingsHelper
       helper Decidim::SanitizeHelper
 
+      def show
+        enforce_permission_to :embed, :meeting, meeting: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= Meeting.where(component: params[:component_id]).find(params[:meeting_id])
+        @model ||= Meeting.except_withdrawn.published.not_hidden.where(component: current_component).find(params[:meeting_id])
       end
 
       def iframe_url
         @iframe_url ||= meeting_widget_url(model)
       end
+
+      def permission_class_chain
+        [Decidim::Meetings::Permissions]
+      end
     end
   end
 end
diff --git a/decidim-meetings/app/permissions/decidim/meetings/permissions.rb b/decidim-meetings/app/permissions/decidim/meetings/permissions.rb
index f769110ede29f..7263fad5c5e35 100644
--- a/decidim-meetings/app/permissions/decidim/meetings/permissions.rb
+++ b/decidim-meetings/app/permissions/decidim/meetings/permissions.rb
@@ -4,6 +4,7 @@ module Decidim
   module Meetings
     class Permissions < Decidim::DefaultPermissions
       def permissions
+        allow_embed_meeting?
         return permission_action unless user
 
         # Delegate the admin permission checks to the admin permissions class
@@ -57,6 +58,15 @@ def question
         @question ||= context.fetch(:question, nil)
       end
 
+      # As this is a public action, we need to run this before other checks
+      def allow_embed_meeting?
+        return unless permission_action.action == :embed && permission_action.subject == :meeting && meeting
+        return disallow! if meeting.withdrawn?
+        return allow! if meeting.published?
+
+        disallow!
+      end
+
       def can_join_meeting?
         meeting.can_be_joined_by?(user) &&
           authorized?(:join, resource: meeting)
diff --git a/decidim-meetings/app/views/decidim/meetings/meetings/show.html.erb b/decidim-meetings/app/views/decidim/meetings/meetings/show.html.erb
index 3c2243d5fc5f3..ecf5f9e3e83f5 100644
--- a/decidim-meetings/app/views/decidim/meetings/meetings/show.html.erb
+++ b/decidim-meetings/app/views/decidim/meetings/meetings/show.html.erb
@@ -105,7 +105,9 @@ edit_link(
     <%= resource_version(meeting, versions_path: meeting_versions_path(meeting)) %>
     <%= cell "decidim/meetings/cancel_registration_meeting_button", meeting %>
     <%= render partial: "decidim/shared/share_modal" %>
-    <%= embed_modal_for meeting_widget_url(meeting, format: :js) %>
+    <% if allowed_to? :embed, :meeting, meeting: @meeting %>
+      <%= embed_modal_for meeting_widget_url(meeting, format: :js) %>
+    <% end %>
     <%= render partial: "calendar_modal", locals: { ics_url: calendar_meeting_url(meeting), google_url: google_calendar_event_url(meeting) } %>
   </div>
   <div class="columns mediumlarge-8 mediumlarge-pull-4">
diff --git a/decidim-meetings/spec/permissions/decidim/meetings/permissions_spec.rb b/decidim-meetings/spec/permissions/decidim/meetings/permissions_spec.rb
index caa322d594a5a..274e78365c60b 100644
--- a/decidim-meetings/spec/permissions/decidim/meetings/permissions_spec.rb
+++ b/decidim-meetings/spec/permissions/decidim/meetings/permissions_spec.rb
@@ -82,6 +82,28 @@
     end
   end
 
+  context "when embedding a meeting" do
+    let(:action) do
+      { scope: :public, action: :embed, subject: :meeting }
+    end
+
+    context "when meeting isn't published" do
+      before do
+        allow(meeting).to receive(:published?).and_return(false)
+      end
+
+      it { is_expected.to be false }
+    end
+
+    context "when meeting is published" do
+      before do
+        allow(meeting).to receive(:published?).and_return(true)
+      end
+
+      it { is_expected.to be true }
+    end
+  end
+
   context "when joining a meeting" do
     let(:action) do
       { scope: :public, action: :join, subject: :meeting }
diff --git a/decidim-meetings/spec/system/meeting_embeds_spec.rb b/decidim-meetings/spec/system/meeting_embeds_spec.rb
index bb5fceeb04073..f38aeb0c94f4b 100644
--- a/decidim-meetings/spec/system/meeting_embeds_spec.rb
+++ b/decidim-meetings/spec/system/meeting_embeds_spec.rb
@@ -4,9 +4,12 @@
 
 describe "Meeting embeds", type: :system do
   include_context "with a component"
-  let(:manifest_name) { "meetings" }
 
+  let(:manifest_name) { "meetings" }
   let!(:resource) { create(:meeting, :published, component: component) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(component).meeting_widget_path(resource) }
 
   it_behaves_like "an embed resource"
+  it_behaves_like "a moderated embed resource"
+  it_behaves_like "a withdrawn embed resource"
 end
diff --git a/decidim-participatory_processes/app/controllers/decidim/participatory_processes/widgets_controller.rb b/decidim-participatory_processes/app/controllers/decidim/participatory_processes/widgets_controller.rb
index 15956edcc7001..7f70cab78595d 100644
--- a/decidim-participatory_processes/app/controllers/decidim/participatory_processes/widgets_controller.rb
+++ b/decidim-participatory_processes/app/controllers/decidim/participatory_processes/widgets_controller.rb
@@ -5,13 +5,19 @@ module ParticipatoryProcesses
     class WidgetsController < Decidim::WidgetsController
       helper Decidim::SanitizeHelper
 
+      def show
+        enforce_permission_to :embed, :participatory_space, current_participatory_space: model
+
+        super
+      end
+
       private
 
       def model
         return unless params[:participatory_process_slug]
 
-        @model ||= ParticipatoryProcess.where(slug: params[:participatory_process_slug]).or(
-          ParticipatoryProcess.where(id: params[:participatory_process_slug])
+        @model ||= ParticipatoryProcess.where(organization: current_organization).public_spaces.where(slug: params[:participatory_process_slug]).or(
+          ParticipatoryProcess.where(organization: current_organization).public_spaces.where(id: params[:participatory_process_slug])
         ).first!
       end
 
@@ -22,6 +28,10 @@ def current_participatory_space
       def iframe_url
         @iframe_url ||= participatory_process_widget_url(model)
       end
+
+      def permission_class_chain
+        ::Decidim.permissions_registry.chain_for(::Decidim::ParticipatoryProcesses::ApplicationController)
+      end
     end
   end
 end
diff --git a/decidim-participatory_processes/app/permissions/decidim/participatory_processes/permissions.rb b/decidim-participatory_processes/app/permissions/decidim/participatory_processes/permissions.rb
index ae326db5352f7..32f735d0643d4 100644
--- a/decidim-participatory_processes/app/permissions/decidim/participatory_processes/permissions.rb
+++ b/decidim-participatory_processes/app/permissions/decidim/participatory_processes/permissions.rb
@@ -19,6 +19,7 @@ def permissions
           public_list_process_groups_action?
           public_read_process_group_action?
           public_read_process_action?
+          public_embed_process_action?
           return permission_action
         end
 
@@ -112,6 +113,17 @@ def public_read_process_action?
         toggle_allow(can_manage_process?)
       end
 
+      def public_embed_process_action?
+        return unless permission_action.action == :embed &&
+                      [:process, :participatory_space].include?(permission_action.subject) &&
+                      process
+
+        return disallow! unless process.published?
+        return disallow! if process.private_space
+
+        allow!
+      end
+
       def can_view_private_space?
         return true unless process.private_space
         return false unless user
diff --git a/decidim-participatory_processes/spec/permissions/decidim/participatory_processes/permissions_spec.rb b/decidim-participatory_processes/spec/permissions/decidim/participatory_processes/permissions_spec.rb
index 8042869ecb06e..e21ba96130b0d 100644
--- a/decidim-participatory_processes/spec/permissions/decidim/participatory_processes/permissions_spec.rb
+++ b/decidim-participatory_processes/spec/permissions/decidim/participatory_processes/permissions_spec.rb
@@ -135,6 +135,36 @@
       end
     end
 
+    context "when embedding an process" do
+      let(:action) do
+        { scope: :public, action: :embed, subject: :process }
+      end
+      let(:context) { { process: process } }
+
+      context "when the process is published" do
+        let(:user) { create(:user, organization: organization) }
+
+        it { is_expected.to be true }
+      end
+
+      context "when the process is not published" do
+        let(:user) { create(:user, organization: organization) }
+        let(:process) { create(:participatory_process, :unpublished, organization: organization) }
+
+        context "when the user doesn't have access to it" do
+          it { is_expected.to be false }
+        end
+
+        context "when the user has access to it" do
+          before do
+            create(:participatory_process_user_role, user: user, participatory_process: process)
+          end
+
+          it { is_expected.to be false }
+        end
+      end
+    end
+
     context "when listing processes" do
       let(:action) do
         { scope: :public, action: :list, subject: :process }
diff --git a/decidim-participatory_processes/spec/system/process_embeds_spec.rb b/decidim-participatory_processes/spec/system/process_embeds_spec.rb
index 4530d00e4d70e..ad8c512100dcc 100644
--- a/decidim-participatory_processes/spec/system/process_embeds_spec.rb
+++ b/decidim-participatory_processes/spec/system/process_embeds_spec.rb
@@ -4,6 +4,8 @@
 
 describe "Process embeds", type: :system do
   let(:resource) { create(:participatory_process) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(resource).participatory_process_widget_path }
 
   it_behaves_like "an embed resource", skip_space_checks: true
+  it_behaves_like "a private embed resource"
 end
diff --git a/decidim-proposals/app/controllers/decidim/proposals/widgets_controller.rb b/decidim-proposals/app/controllers/decidim/proposals/widgets_controller.rb
index 4f0e24b00ba2b..a399d7cff0af7 100644
--- a/decidim-proposals/app/controllers/decidim/proposals/widgets_controller.rb
+++ b/decidim-proposals/app/controllers/decidim/proposals/widgets_controller.rb
@@ -5,15 +5,25 @@ module Proposals
     class WidgetsController < Decidim::WidgetsController
       helper Proposals::ApplicationHelper
 
+      def show
+        enforce_permission_to :embed, :proposal, proposal: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= Proposal.where(component: params[:component_id]).find(params[:proposal_id])
+        @model ||= Proposal.not_hidden.except_withdrawn.where(component: current_component).find(params[:proposal_id])
       end
 
       def iframe_url
         @iframe_url ||= proposal_widget_url(model)
       end
+
+      def permission_class_chain
+        [Decidim::Proposals::Permissions]
+      end
     end
   end
 end
diff --git a/decidim-proposals/app/permissions/decidim/proposals/permissions.rb b/decidim-proposals/app/permissions/decidim/proposals/permissions.rb
index ea40f2d30bbc7..4f37a684dd41c 100644
--- a/decidim-proposals/app/permissions/decidim/proposals/permissions.rb
+++ b/decidim-proposals/app/permissions/decidim/proposals/permissions.rb
@@ -4,6 +4,7 @@ module Decidim
   module Proposals
     class Permissions < Decidim::DefaultPermissions
       def permissions
+        allow_embed_proposal?
         return permission_action unless user
 
         # Delegate the admin permission checks to the admin permissions class
@@ -47,6 +48,14 @@ def proposal
         @proposal ||= context.fetch(:proposal, nil) || context.fetch(:resource, nil)
       end
 
+      # As this is a public action, we need to run this before other checks
+      def allow_embed_proposal?
+        return unless permission_action.action == :embed && permission_action.subject == :proposal && proposal
+        return disallow! if proposal.withdrawn?
+
+        allow!
+      end
+
       def voting_enabled?
         return unless current_settings
 
diff --git a/decidim-proposals/app/views/decidim/proposals/proposals/show.html.erb b/decidim-proposals/app/views/decidim/proposals/proposals/show.html.erb
index ce66bfcb2a948..46bca7ad45cae 100644
--- a/decidim-proposals/app/views/decidim/proposals/proposals/show.html.erb
+++ b/decidim-proposals/app/views/decidim/proposals/proposals/show.html.erb
@@ -129,7 +129,9 @@ extra_admin_link(
     <%= resource_version(proposal_presenter, versions_path: proposal_versions_path(@proposal)) %>
     <%= cell("decidim/fingerprint", @proposal) %>
     <%= render partial: "decidim/shared/share_modal", locals: { resource: @proposal } %>
-    <%= embed_modal_for proposal_widget_url(@proposal, format: :js) %>
+    <% if allowed_to? :embed, :proposal, proposal: @proposal %>
+      <%= embed_modal_for proposal_widget_url(@proposal, format: :js) %>
+    <% end %>
     <%= cell "decidim/proposals/proposal_link_to_collaborative_draft", @proposal %>
     <%= cell "decidim/proposals/proposal_link_to_rejected_emendation", @proposal %>
   </div>
diff --git a/decidim-proposals/spec/permissions/decidim/proposals/permissions_spec.rb b/decidim-proposals/spec/permissions/decidim/proposals/permissions_spec.rb
index 9ac3ebe5ce961..28da33fc24623 100644
--- a/decidim-proposals/spec/permissions/decidim/proposals/permissions_spec.rb
+++ b/decidim-proposals/spec/permissions/decidim/proposals/permissions_spec.rb
@@ -110,6 +110,14 @@
     end
   end
 
+  context "when emebeding a proposal" do
+    let(:action) do
+      { scope: :public, action: :embed, subject: :proposal }
+    end
+
+    it { is_expected.to be true }
+  end
+
   describe "voting" do
     let(:action) do
       { scope: :public, action: :vote, subject: :proposal }
diff --git a/decidim-proposals/spec/system/proposal_embeds_spec.rb b/decidim-proposals/spec/system/proposal_embeds_spec.rb
index 74e4d024155c6..6d83a96fdfb4f 100644
--- a/decidim-proposals/spec/system/proposal_embeds_spec.rb
+++ b/decidim-proposals/spec/system/proposal_embeds_spec.rb
@@ -4,8 +4,12 @@
 
 describe "Proposal embeds", type: :system do
   include_context "with a component"
+
   let(:manifest_name) { "proposals" }
   let(:resource) { create(:proposal, component: component) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(component).proposal_widget_path(resource) }
 
-  it_behaves_like "an embed resource"
+  it_behaves_like "an embed resource", skip_publication_checks: true
+  it_behaves_like "a moderated embed resource"
+  it_behaves_like "a withdrawn embed resource"
 end
diff --git a/decidim-sortitions/app/controllers/decidim/sortitions/widgets_controller.rb b/decidim-sortitions/app/controllers/decidim/sortitions/widgets_controller.rb
index dc68bc319ec52..380509c460baf 100644
--- a/decidim-sortitions/app/controllers/decidim/sortitions/widgets_controller.rb
+++ b/decidim-sortitions/app/controllers/decidim/sortitions/widgets_controller.rb
@@ -6,15 +6,25 @@ class WidgetsController < Decidim::WidgetsController
       helper Decidim::SanitizeHelper
       helper Sortitions::SortitionsHelper
 
+      def show
+        enforce_permission_to :embed, :sortition, sortition: model if model
+
+        super
+      end
+
       private
 
       def model
-        @model ||= Sortition.where(component: params[:component_id]).find(params[:sortition_id])
+        @model ||= Sortition.where(component: current_component).find(params[:sortition_id])
       end
 
       def iframe_url
         @iframe_url ||= sortition_widget_url(model)
       end
+
+      def permission_class_chain
+        [Decidim::Sortitions::Permissions]
+      end
     end
   end
 end
diff --git a/decidim-sortitions/app/permissions/decidim/sortitions/permissions.rb b/decidim-sortitions/app/permissions/decidim/sortitions/permissions.rb
index 06868f0ef0e6c..12587ffe1dc61 100644
--- a/decidim-sortitions/app/permissions/decidim/sortitions/permissions.rb
+++ b/decidim-sortitions/app/permissions/decidim/sortitions/permissions.rb
@@ -4,12 +4,26 @@ module Decidim
   module Sortitions
     class Permissions < Decidim::DefaultPermissions
       def permissions
+        allow_embed_sortition?
         return permission_action unless user
 
         return Decidim::Sortitions::Admin::Permissions.new(user, permission_action, context).permissions if permission_action.scope == :admin
 
         permission_action
       end
+
+      private
+
+      def sortition
+        @sortition ||= context.fetch(:sortition, nil) || context.fetch(:resource, nil)
+      end
+
+      # As this is a public action, we need to run this before other checks
+      def allow_embed_sortition?
+        return unless permission_action.action == :embed && permission_action.subject == :sortition && sortition
+
+        allow!
+      end
     end
   end
 end
diff --git a/decidim-sortitions/spec/permissions/decidim/sortitions/permissions_spec.rb b/decidim-sortitions/spec/permissions/decidim/sortitions/permissions_spec.rb
index 364d68d980ea1..8ae9e6c23e26c 100644
--- a/decidim-sortitions/spec/permissions/decidim/sortitions/permissions_spec.rb
+++ b/decidim-sortitions/spec/permissions/decidim/sortitions/permissions_spec.rb
@@ -25,6 +25,14 @@
     it_behaves_like "delegates permissions to", Decidim::Sortitions::Admin::Permissions
   end
 
+  context "when emebedding a sortition" do
+    let(:action) do
+      { scope: :public, action: :embed, subject: :sortition }
+    end
+
+    it { is_expected.to be true }
+  end
+
   context "when any other condition" do
     let(:action) do
       { scope: :foo, action: :blah, subject: :sortition }
diff --git a/decidim-sortitions/spec/system/decidim/sortitions/sortition_embeds_spec.rb b/decidim-sortitions/spec/system/decidim/sortitions/sortition_embeds_spec.rb
index 965b1c11d4024..76e92b95af809 100644
--- a/decidim-sortitions/spec/system/decidim/sortitions/sortition_embeds_spec.rb
+++ b/decidim-sortitions/spec/system/decidim/sortitions/sortition_embeds_spec.rb
@@ -4,8 +4,10 @@
 
 describe "Sortition embeds", type: :system do
   include_context "with a component"
+
   let(:manifest_name) { "sortitions" }
   let(:resource) { create(:sortition, component: component) }
+  let(:widget_path) { Decidim::EngineRouter.main_proxy(component).sortition_widget_path(resource) }
 
-  it_behaves_like "an embed resource"
+  it_behaves_like "an embed resource", skip_publication_checks: true
 end", "url": "https://github.com/decidim/decidim/commit/1756fa639ef393ca8e8bb16221cab2e2e7875705.patch" } ]
CWE-200: Exposure of Sensitive Information to an Unauthorized Actor
GHSA-crh5-vv2v-c82q
@claviska/jquery-minicolors vulnerable to Cross-site Scripting
null
[ { "commit_message": "[PATCH] fix XSS vuln jquery.minicolors.js | 3 ++- jquery.minicolors.min.js | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-)", "patch_text_b64": "From ef134824a7f4110ada53ea6c173111a4fa2f48f3 Mon Sep 17 00:00:00 2001
From: Cory LaViska <cory@abeautifulsite.net>
Date: Wed, 24 Nov 2021 09:24:31 -0500
Subject: [PATCH] fix XSS vuln

---
 jquery.minicolors.js     | 3 ++-
 jquery.minicolors.min.js | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/jquery.minicolors.js b/jquery.minicolors.js
index e06e5ae..a2afce1 100644
--- a/jquery.minicolors.js
+++ b/jquery.minicolors.js
@@ -226,7 +226,8 @@
         }
         swatchString = swatch;
         swatch = isRgb(swatch) ? parseRgb(swatch, true) : hex2rgb(parseHex(swatch, true));
-        $('<li class="minicolors-swatch minicolors-sprite"><span class="minicolors-swatch-color" title="' + name + '"></span></li>')
+        $('<li class="minicolors-swatch minicolors-sprite"><span class="minicolors-swatch-color"></span></li>')
+          .attr("title", name)
           .appendTo(swatches)
           .data('swatch-color', swatchString)
           .find('.minicolors-swatch-color')
diff --git a/jquery.minicolors.min.js b/jquery.minicolors.min.js
index 831f819..5ce9822 100644
--- a/jquery.minicolors.min.js
+++ b/jquery.minicolors.min.js
@@ -5,4 +5,4 @@
 //
 // Licensed under the MIT license: http://opensource.org/licenses/MIT
 //
-!function(i){"function"==typeof define&&define.amd?define(["jquery"],i):"object"==typeof exports?module.exports=i(require("jquery")):i(jQuery)}(function(C){"use strict";function o(i){var t=i.parent();i.removeData("minicolors-initialized").removeData("minicolors-settings").removeProp("size").removeClass("minicolors-input"),t.before(i).remove()}function s(i){var t=i.parent(),o=t.find(".minicolors-panel"),s=i.data("minicolors-settings");!i.data("minicolors-initialized")||i.prop("disabled")||t.hasClass("minicolors-inline")||t.hasClass("minicolors-focus")||(a(),t.addClass("minicolors-focus"),o.animate?o.stop(!0,!0).fadeIn(s.showSpeed,function(){s.show&&s.show.call(i.get(0))}):(o.show(),s.show&&s.show.call(i.get(0))))}function a(){C(".minicolors-focus").each(function(){var i=C(this),t=i.find(".minicolors-input"),o=i.find(".minicolors-panel"),s=t.data("minicolors-settings");o.animate?o.fadeOut(s.hideSpeed,function(){s.hide&&s.hide.call(t.get(0)),i.removeClass("minicolors-focus")}):(o.hide(),s.hide&&s.hide.call(t.get(0)),i.removeClass("minicolors-focus"))})}function n(i,t,o){var s,a,n,r,e,c=i.parents(".minicolors").find(".minicolors-input"),l=c.data("minicolors-settings"),h=i.find("[class$=-picker]"),d=i.offset().left,p=i.offset().top,u=Math.round(t.pageX-d),g=Math.round(t.pageY-p),m=o?l.animationSpeed:0;t.originalEvent.changedTouches&&(u=t.originalEvent.changedTouches[0].pageX-d,g=t.originalEvent.changedTouches[0].pageY-p),u<0&&(u=0),g<0&&(g=0),u>i.width()&&(u=i.width()),g>i.height()&&(g=i.height()),i.parent().is(".minicolors-slider-wheel")&&h.parent().is(".minicolors-grid")&&(s=75-u,a=75-g,n=Math.sqrt(s*s+a*a),(r=Math.atan2(a,s))<0&&(r+=2*Math.PI),75<n&&(u=(n=75)-75*Math.cos(r),g=75-75*Math.sin(r)),u=Math.round(u),g=Math.round(g)),e={top:g+"px"},i.is(".minicolors-grid")&&(e.left=u+"px"),h.animate?h.stop(!0).animate(e,m,l.animationEasing,function(){f(c,i)}):(h.css(e),f(c,i))}function f(i,t){function o(i,t){var o,s;return i.length&&t?(o=i.offset().left,s=i.offset().top,{x:o-t.offset().left+i.outerWidth()/2,y:s-t.offset().top+i.outerHeight()/2}):null}var s,a,n,r,e,c,l,h=i.val(),d=i.attr("data-opacity"),p=i.parent(),u=i.data("minicolors-settings"),g=p.find(".minicolors-input-swatch"),m=p.find(".minicolors-grid"),f=p.find(".minicolors-slider"),v=p.find(".minicolors-opacity-slider"),b=m.find("[class$=-picker]"),w=f.find("[class$=-picker]"),y=v.find("[class$=-picker]"),C=o(b,m),k=o(w,f),M=o(y,v);if(t.is(".minicolors-grid, .minicolors-slider, .minicolors-opacity-slider")){switch(u.control){case"wheel":r=m.width()/2-C.x,e=m.height()/2-C.y,c=Math.sqrt(r*r+e*e),(l=Math.atan2(e,r))<0&&(l+=2*Math.PI),75<c&&(c=75,C.x=69-75*Math.cos(l),C.y=69-75*Math.sin(l)),a=F(c/.75,0,100),h=q({h:s=F(180*l/Math.PI,0,360),s:a,b:n=F(100-Math.floor(k.y*(100/f.height())),0,100)}),f.css("backgroundColor",q({h:s,s:a,b:100}));break;case"saturation":h=q({h:s=F(parseInt(C.x*(360/m.width()),10),0,360),s:a=F(100-Math.floor(k.y*(100/f.height())),0,100),b:n=F(100-Math.floor(C.y*(100/m.height())),0,100)}),f.css("backgroundColor",q({h:s,s:100,b:n})),p.find(".minicolors-grid-inner").css("opacity",a/100);break;case"brightness":h=q({h:s=F(parseInt(C.x*(360/m.width()),10),0,360),s:a=F(100-Math.floor(C.y*(100/m.height())),0,100),b:n=F(100-Math.floor(k.y*(100/f.height())),0,100)}),f.css("backgroundColor",q({h:s,s:a,b:100})),p.find(".minicolors-grid-inner").css("opacity",1-n/100);break;default:h=q({h:s=F(360-parseInt(k.y*(360/f.height()),10),0,360),s:a=F(Math.floor(C.x*(100/m.width())),0,100),b:n=F(100-Math.floor(C.y*(100/m.height())),0,100)}),m.css("backgroundColor",q({h:s,s:100,b:100}))}x(i,h,d=u.opacity?parseFloat(1-M.y/v.height()).toFixed(2):1)}else g.find("span").css({backgroundColor:h,opacity:String(d)}),S(i,h,d)}function x(i,t,o){var s,a=i.parent(),n=i.data("minicolors-settings"),r=a.find(".minicolors-input-swatch");n.opacity&&i.attr("data-opacity",o),t="rgb"===n.format?(s=T(t)?I(t,!0):L(M(t,!0)),o=""===i.attr("data-opacity")?1:F(parseFloat(i.attr("data-opacity")).toFixed(2),0,1),!isNaN(o)&&n.opacity||(o=1),i.minicolors("rgbObject").a<=1&&s&&n.opacity?"rgba("+s.r+", "+s.g+", "+s.b+", "+parseFloat(o)+")":"rgb("+s.r+", "+s.g+", "+s.b+")"):(T(t)&&(t=j(t)),k(t,n.letterCase)),i.val(t),r.find("span").css({backgroundColor:t,opacity:String(o)}),S(i,t,o)}function d(i,t){var o,s,a,n,r,e,c,l,h,d,p=i.parent(),u=i.data("minicolors-settings"),g=p.find(".minicolors-input-swatch"),m=p.find(".minicolors-grid"),f=p.find(".minicolors-slider"),v=p.find(".minicolors-opacity-slider"),b=m.find("[class$=-picker]"),w=f.find("[class$=-picker]"),y=v.find("[class$=-picker]");switch(T(i.val())?(o=j(i.val()),(r=F(parseFloat(D(i.val())).toFixed(2),0,1))&&i.attr("data-opacity",r)):o=k(M(i.val(),!0),u.letterCase),s=function(i){var t=function(i){var t={h:0,s:0,b:0},o=Math.min(i.r,i.g,i.b),s=Math.max(i.r,i.g,i.b),a=s-o;t.b=s,t.s=0!==s?255*a/s:0,0!==t.s?i.r===s?t.h=(i.g-i.b)/a:i.g===s?t.h=2+(i.b-i.r)/a:t.h=4+(i.r-i.g)/a:t.h=-1;t.h*=60,t.h<0&&(t.h+=360);return t.s*=100/255,t.b*=100/255,t}(L(i));0===t.s&&(t.h=360);return t}(o=o||k(z(u.defaultValue,!0),u.letterCase)),n=u.keywords?C.map(u.keywords.split(","),function(i){return i.toLowerCase().trim()}):[],e=""!==i.val()&&-1<C.inArray(i.val().toLowerCase(),n)?k(i.val()):T(i.val())?I(i.val()):o,t||i.val(e),u.opacity&&(a=""===i.attr("data-opacity")?1:F(parseFloat(i.attr("data-opacity")).toFixed(2),0,1),isNaN(a)&&(a=1),i.attr("data-opacity",a),g.find("span").css("opacity",String(a)),l=F(v.height()-v.height()*a,0,v.height()),y.css("top",l+"px")),"transparent"===i.val().toLowerCase()&&g.find("span").css("opacity",String(0)),g.find("span").css("backgroundColor",o),u.control){case"wheel":h=F(Math.ceil(.75*s.s),0,m.height()/2),d=s.h*Math.PI/180,c=F(75-Math.cos(d)*h,0,m.width()),l=F(75-Math.sin(d)*h,0,m.height()),b.css({top:l+"px",left:c+"px"}),l=150-s.b/(100/m.height()),""===o&&(l=0),w.css("top",l+"px"),f.css("backgroundColor",q({h:s.h,s:s.s,b:100}));break;case"saturation":c=F(5*s.h/12,0,150),l=F(m.height()-Math.ceil(s.b/(100/m.height())),0,m.height()),b.css({top:l+"px",left:c+"px"}),l=F(f.height()-s.s*(f.height()/100),0,f.height()),w.css("top",l+"px"),f.css("backgroundColor",q({h:s.h,s:100,b:s.b})),p.find(".minicolors-grid-inner").css("opacity",s.s/100);break;case"brightness":c=F(5*s.h/12,0,150),l=F(m.height()-Math.ceil(s.s/(100/m.height())),0,m.height()),b.css({top:l+"px",left:c+"px"}),l=F(f.height()-s.b*(f.height()/100),0,f.height()),w.css("top",l+"px"),f.css("backgroundColor",q({h:s.h,s:s.s,b:100})),p.find(".minicolors-grid-inner").css("opacity",1-s.b/100);break;default:c=F(Math.ceil(s.s/(100/m.width())),0,m.width()),l=F(m.height()-Math.ceil(s.b/(100/m.height())),0,m.height()),b.css({top:l+"px",left:c+"px"}),l=F(f.height()-s.h/(360/f.height()),0,f.height()),w.css("top",l+"px"),m.css("backgroundColor",q({h:s.h,s:100,b:100}))}i.data("minicolors-initialized")&&S(i,e,a)}function S(i,t,o){var s,a,n,r=i.data("minicolors-settings"),e=i.data("minicolors-lastChange");if(!e||e.value!==t||e.opacity!==o){if(i.data("minicolors-lastChange",{value:t,opacity:o}),r.swatches&&0!==r.swatches.length){for(s=T(t)?I(t,!0):L(t),a=-1,n=0;n<r.swatches.length;++n)if(s.r===r.swatches[n].r&&s.g===r.swatches[n].g&&s.b===r.swatches[n].b&&s.a===r.swatches[n].a){a=n;break}i.parent().find(".minicolors-swatches .minicolors-swatch").removeClass("selected"),-1!==a&&i.parent().find(".minicolors-swatches .minicolors-swatch").eq(n).addClass("selected")}r.change&&(r.changeDelay?(clearTimeout(i.data("minicolors-changeTimeout")),i.data("minicolors-changeTimeout",setTimeout(function(){r.change.call(i.get(0),t,o)},r.changeDelay))):r.change.call(i.get(0),t,o)),i.trigger("change").trigger("input")}}function k(i,t){return"uppercase"===t?i.toUpperCase():i.toLowerCase()}function M(i,t){return!(i=i.replace(/^#/g,"")).match(/^[A-F0-9]{3,6}/gi)||3!==i.length&&6!==i.length?"":(3===i.length&&t&&(i=i[0]+i[0]+i[1]+i[1]+i[2]+i[2]),"#"+i)}function I(i,t){var o=i.replace(/[^\d,.]/g,"").split(",");return o[0]=F(parseInt(o[0],10),0,255),o[1]=F(parseInt(o[1],10),0,255),o[2]=F(parseInt(o[2],10),0,255),void 0!==o[3]&&(o[3]=F(parseFloat(o[3],10),0,1)),t?void 0!==o[3]?{r:o[0],g:o[1],b:o[2],a:o[3]}:{r:o[0],g:o[1],b:o[2]}:void 0!==o[3]&&o[3]<=1?"rgba("+o[0]+", "+o[1]+", "+o[2]+", "+o[3]+")":"rgb("+o[0]+", "+o[1]+", "+o[2]+")"}function z(i,t){return T(i)?I(i):M(i,t)}function F(i,t,o){return i<t&&(i=t),o<i&&(i=o),i}function T(i){var t=i.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);return!(!t||4!==t.length)}function D(i){return(i=i.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+(\.\d{1,2})?|\.\d{1,2})[\s+]?/i))&&6===i.length?i[4]:"1"}function j(i){return(i=i.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i))&&4===i.length?"#"+("0"+parseInt(i[1],10).toString(16)).slice(-2)+("0"+parseInt(i[2],10).toString(16)).slice(-2)+("0"+parseInt(i[3],10).toString(16)).slice(-2):""}function p(i){var o=[i.r.toString(16),i.g.toString(16),i.b.toString(16)];return C.each(o,function(i,t){1===t.length&&(o[i]="0"+t)}),"#"+o.join("")}function q(i){return p((t=i,n={},r=Math.round(t.h),e=Math.round(255*t.s/100),c=Math.round(255*t.b/100),0===e?n.r=n.g=n.b=c:(a=r%60*((o=c)-(s=(255-e)*c/255))/60,360===r&&(r=0),r<60?(n.r=o,n.b=s,n.g=s+a):r<120?(n.g=o,n.b=s,n.r=o-a):r<180?(n.g=o,n.r=s,n.b=s+a):r<240?(n.b=o,n.r=s,n.g=o-a):r<300?(n.b=o,n.g=s,n.r=s+a):r<360?(n.r=o,n.g=s,n.b=o-a):(n.r=0,n.g=0,n.b=0)),{r:Math.round(n.r),g:Math.round(n.g),b:Math.round(n.b)}));var t,o,s,a,n,r,e,c}function L(i){return{r:(i=parseInt(-1<i.indexOf("#")?i.substring(1):i,16))>>16,g:(65280&i)>>8,b:255&i}}C.minicolors={defaults:{animationSpeed:50,animationEasing:"swing",change:null,changeDelay:0,control:"hue",defaultValue:"",format:"hex",hide:null,hideSpeed:100,inline:!1,keywords:"",letterCase:"lowercase",opacity:!1,position:"bottom",show:null,showSpeed:100,theme:"default",swatches:[]}},C.extend(C.fn,{minicolors:function(i,t){switch(i){case"destroy":return C(this).each(function(){o(C(this))}),C(this);case"hide":return a(),C(this);case"opacity":return void 0===t?C(this).attr("data-opacity"):(C(this).each(function(){d(C(this).attr("data-opacity",t))}),C(this));case"rgbObject":return function(i){var t,o=C(i).attr("data-opacity");{var s;t=T(C(i).val())?I(C(i).val(),!0):(s=M(C(i).val(),!0),L(s))}if(!t)return null;void 0!==o&&C.extend(t,{a:parseFloat(o)});return t}(C(this));case"rgbString":case"rgbaString":return function(i,t){var o,s=C(i).attr("data-opacity");{var a;o=T(C(i).val())?I(C(i).val(),!0):(a=M(C(i).val(),!0),L(a))}if(!o)return null;void 0===s&&(s=1);return t?"rgba("+o.r+", "+o.g+", "+o.b+", "+parseFloat(s)+")":"rgb("+o.r+", "+o.g+", "+o.b+")"}(C(this),"rgbaString"===i);case"settings":return void 0===t?C(this).data("minicolors-settings"):(C(this).each(function(){var i=C(this).data("minicolors-settings")||{};o(C(this)),C(this).minicolors(C.extend(!0,i,t))}),C(this));case"show":return s(C(this).eq(0)),C(this);case"value":return void 0===t?C(this).val():(C(this).each(function(){"object"==typeof t&&null!==t?(void 0!==t.opacity&&C(this).attr("data-opacity",F(t.opacity,0,1)),t.color&&C(this).val(t.color)):C(this).val(t),d(C(this))}),C(this));default:return"create"!==i&&(t=i),C(this).each(function(){!function(t,i){var o,s,a,n,r,e,c,l=C('<div class="minicolors" />'),h=C.minicolors.defaults;if(t.data("minicolors-initialized"))return;i=C.extend(!0,{},h,i),l.addClass("minicolors-theme-"+i.theme).toggleClass("minicolors-with-opacity",i.opacity),void 0!==i.position&&C.each(i.position.split(" "),function(){l.addClass("minicolors-position-"+this)});s="rgb"===i.format?i.opacity?"25":"20":i.keywords?"11":"7";t.addClass("minicolors-input").data("minicolors-initialized",!1).data("minicolors-settings",i).prop("size",s).wrap(l).after('<div class="minicolors-panel minicolors-slider-'+i.control+'"><div class="minicolors-slider minicolors-sprite"><div class="minicolors-picker"></div></div><div class="minicolors-opacity-slider minicolors-sprite"><div class="minicolors-picker"></div></div><div class="minicolors-grid minicolors-sprite"><div class="minicolors-grid-inner"></div><div class="minicolors-picker"><div></div></div></div></div>'),i.inline||(t.after('<span class="minicolors-swatch minicolors-sprite minicolors-input-swatch"><span class="minicolors-swatch-color"></span></span>'),t.next(".minicolors-input-swatch").on("click",function(i){i.preventDefault(),t.trigger("focus")}));if((e=t.parent().find(".minicolors-panel")).on("selectstart",function(){return!1}).end(),i.swatches&&0!==i.swatches.length)for(e.addClass("minicolors-with-swatches"),a=C('<ul class="minicolors-swatches"></ul>').appendTo(e),c=0;c<i.swatches.length;++c)n="object"==typeof i.swatches[c]?(o=i.swatches[c].name,i.swatches[c].color):(o="",i.swatches[c]),n=T(r=n)?I(n,!0):L(M(n,!0)),C('<li class="minicolors-swatch minicolors-sprite"><span class="minicolors-swatch-color" title="'+o+'"></span></li>').appendTo(a).data("swatch-color",r).find(".minicolors-swatch-color").css({backgroundColor:"transparent"!==r?p(n):"transparent",opacity:String(n.a)}),i.swatches[c]=n;i.inline&&t.parent().addClass("minicolors-inline");d(t,!1),t.data("minicolors-initialized",!0)}(C(this),t)}),C(this)}}}),C([document]).on("mousedown.minicolors touchstart.minicolors",function(i){C(i.target).parents().add(i.target).hasClass("minicolors")||a()}).on("mousedown.minicolors touchstart.minicolors",".minicolors-grid, .minicolors-slider, .minicolors-opacity-slider",function(i){var t=C(this);i.preventDefault(),C(i.delegateTarget).data("minicolors-target",t),n(t,i,!0)}).on("mousemove.minicolors touchmove.minicolors",function(i){var t=C(i.delegateTarget).data("minicolors-target");t&&n(t,i)}).on("mouseup.minicolors touchend.minicolors",function(){C(this).removeData("minicolors-target")}).on("click.minicolors",".minicolors-swatches li",function(i){i.preventDefault();var t=C(this),o=t.parents(".minicolors").find(".minicolors-input"),s=t.data("swatch-color");x(o,s,D(s)),d(o)}).on("mousedown.minicolors touchstart.minicolors",".minicolors-input-swatch",function(i){var t=C(this).parent().find(".minicolors-input");i.preventDefault(),s(t)}).on("focus.minicolors",".minicolors-input",function(){var i=C(this);i.data("minicolors-initialized")&&s(i)}).on("blur.minicolors",".minicolors-input",function(){var i,t,o,s,a,n=C(this),r=n.data("minicolors-settings");n.data("minicolors-initialized")&&(i=r.keywords?C.map(r.keywords.split(","),function(i){return i.toLowerCase().trim()}):[],a=""!==n.val()&&-1<C.inArray(n.val().toLowerCase(),i)?n.val():null===(o=T(n.val())?I(n.val(),!0):(t=M(n.val(),!0))?L(t):null)?r.defaultValue:"rgb"===r.format?r.opacity?I("rgba("+o.r+","+o.g+","+o.b+","+n.attr("data-opacity")+")"):I("rgb("+o.r+","+o.g+","+o.b+")"):p(o),s=r.opacity?n.attr("data-opacity"):1,"transparent"===a.toLowerCase()&&(s=0),n.closest(".minicolors").find(".minicolors-input-swatch > span").css("opacity",String(s)),n.val(a),""===n.val()&&n.val(z(r.defaultValue,!0)),n.val(k(n.val(),r.letterCase)))}).on("keydown.minicolors",".minicolors-input",function(i){var t=C(this);if(t.data("minicolors-initialized"))switch(i.which){case 9:a();break;case 13:case 27:a(),t.blur()}}).on("keyup.minicolors",".minicolors-input",function(){var i=C(this);i.data("minicolors-initialized")&&d(i,!0)}).on("paste.minicolors",".minicolors-input",function(){var i=C(this);i.data("minicolors-initialized")&&setTimeout(function(){d(i,!0)},1)})});
\ No newline at end of file
+!function(i){"function"==typeof define&&define.amd?define(["jquery"],i):"object"==typeof exports?module.exports=i(require("jquery")):i(jQuery)}(function(C){"use strict";function o(i){var t=i.parent();i.removeData("minicolors-initialized").removeData("minicolors-settings").removeProp("size").removeClass("minicolors-input"),t.before(i).remove()}function s(i){var t=i.parent(),o=t.find(".minicolors-panel"),s=i.data("minicolors-settings");!i.data("minicolors-initialized")||i.prop("disabled")||t.hasClass("minicolors-inline")||t.hasClass("minicolors-focus")||(a(),t.addClass("minicolors-focus"),o.animate?o.stop(!0,!0).fadeIn(s.showSpeed,function(){s.show&&s.show.call(i.get(0))}):(o.show(),s.show&&s.show.call(i.get(0))))}function a(){C(".minicolors-focus").each(function(){var i=C(this),t=i.find(".minicolors-input"),o=i.find(".minicolors-panel"),s=t.data("minicolors-settings");o.animate?o.fadeOut(s.hideSpeed,function(){s.hide&&s.hide.call(t.get(0)),i.removeClass("minicolors-focus")}):(o.hide(),s.hide&&s.hide.call(t.get(0)),i.removeClass("minicolors-focus"))})}function n(i,t,o){var s,a,n,r,e,c=i.parents(".minicolors").find(".minicolors-input"),l=c.data("minicolors-settings"),h=i.find("[class$=-picker]"),d=i.offset().left,p=i.offset().top,u=Math.round(t.pageX-d),g=Math.round(t.pageY-p),m=o?l.animationSpeed:0;t.originalEvent.changedTouches&&(u=t.originalEvent.changedTouches[0].pageX-d,g=t.originalEvent.changedTouches[0].pageY-p),u<0&&(u=0),g<0&&(g=0),u>i.width()&&(u=i.width()),g>i.height()&&(g=i.height()),i.parent().is(".minicolors-slider-wheel")&&h.parent().is(".minicolors-grid")&&(s=75-u,a=75-g,n=Math.sqrt(s*s+a*a),(r=Math.atan2(a,s))<0&&(r+=2*Math.PI),75<n&&(u=(n=75)-75*Math.cos(r),g=75-75*Math.sin(r)),u=Math.round(u),g=Math.round(g)),e={top:g+"px"},i.is(".minicolors-grid")&&(e.left=u+"px"),h.animate?h.stop(!0).animate(e,m,l.animationEasing,function(){f(c,i)}):(h.css(e),f(c,i))}function f(i,t){function o(i,t){var o,s;return i.length&&t?(o=i.offset().left,s=i.offset().top,{x:o-t.offset().left+i.outerWidth()/2,y:s-t.offset().top+i.outerHeight()/2}):null}var s,a,n,r,e,c,l,h=i.val(),d=i.attr("data-opacity"),p=i.parent(),u=i.data("minicolors-settings"),g=p.find(".minicolors-input-swatch"),m=p.find(".minicolors-grid"),f=p.find(".minicolors-slider"),v=p.find(".minicolors-opacity-slider"),b=m.find("[class$=-picker]"),w=f.find("[class$=-picker]"),y=v.find("[class$=-picker]"),C=o(b,m),k=o(w,f),M=o(y,v);if(t.is(".minicolors-grid, .minicolors-slider, .minicolors-opacity-slider")){switch(u.control){case"wheel":r=m.width()/2-C.x,e=m.height()/2-C.y,c=Math.sqrt(r*r+e*e),(l=Math.atan2(e,r))<0&&(l+=2*Math.PI),75<c&&(c=75,C.x=69-75*Math.cos(l),C.y=69-75*Math.sin(l)),a=F(c/.75,0,100),h=q({h:s=F(180*l/Math.PI,0,360),s:a,b:n=F(100-Math.floor(k.y*(100/f.height())),0,100)}),f.css("backgroundColor",q({h:s,s:a,b:100}));break;case"saturation":h=q({h:s=F(parseInt(C.x*(360/m.width()),10),0,360),s:a=F(100-Math.floor(k.y*(100/f.height())),0,100),b:n=F(100-Math.floor(C.y*(100/m.height())),0,100)}),f.css("backgroundColor",q({h:s,s:100,b:n})),p.find(".minicolors-grid-inner").css("opacity",a/100);break;case"brightness":h=q({h:s=F(parseInt(C.x*(360/m.width()),10),0,360),s:a=F(100-Math.floor(C.y*(100/m.height())),0,100),b:n=F(100-Math.floor(k.y*(100/f.height())),0,100)}),f.css("backgroundColor",q({h:s,s:a,b:100})),p.find(".minicolors-grid-inner").css("opacity",1-n/100);break;default:h=q({h:s=F(360-parseInt(k.y*(360/f.height()),10),0,360),s:a=F(Math.floor(C.x*(100/m.width())),0,100),b:n=F(100-Math.floor(C.y*(100/m.height())),0,100)}),m.css("backgroundColor",q({h:s,s:100,b:100}))}x(i,h,d=u.opacity?parseFloat(1-M.y/v.height()).toFixed(2):1)}else g.find("span").css({backgroundColor:h,opacity:String(d)}),S(i,h,d)}function x(i,t,o){var s,a=i.parent(),n=i.data("minicolors-settings"),r=a.find(".minicolors-input-swatch");n.opacity&&i.attr("data-opacity",o),t="rgb"===n.format?(s=T(t)?I(t,!0):L(M(t,!0)),o=""===i.attr("data-opacity")?1:F(parseFloat(i.attr("data-opacity")).toFixed(2),0,1),!isNaN(o)&&n.opacity||(o=1),i.minicolors("rgbObject").a<=1&&s&&n.opacity?"rgba("+s.r+", "+s.g+", "+s.b+", "+parseFloat(o)+")":"rgb("+s.r+", "+s.g+", "+s.b+")"):(T(t)&&(t=j(t)),k(t,n.letterCase)),i.val(t),r.find("span").css({backgroundColor:t,opacity:String(o)}),S(i,t,o)}function d(i,t){var o,s,a,n,r,e,c,l,h,d,p=i.parent(),u=i.data("minicolors-settings"),g=p.find(".minicolors-input-swatch"),m=p.find(".minicolors-grid"),f=p.find(".minicolors-slider"),v=p.find(".minicolors-opacity-slider"),b=m.find("[class$=-picker]"),w=f.find("[class$=-picker]"),y=v.find("[class$=-picker]");switch(T(i.val())?(o=j(i.val()),(r=F(parseFloat(D(i.val())).toFixed(2),0,1))&&i.attr("data-opacity",r)):o=k(M(i.val(),!0),u.letterCase),s=function(i){var t=function(i){var t={h:0,s:0,b:0},o=Math.min(i.r,i.g,i.b),s=Math.max(i.r,i.g,i.b),a=s-o;t.b=s,t.s=0!==s?255*a/s:0,0!==t.s?i.r===s?t.h=(i.g-i.b)/a:i.g===s?t.h=2+(i.b-i.r)/a:t.h=4+(i.r-i.g)/a:t.h=-1;t.h*=60,t.h<0&&(t.h+=360);return t.s*=100/255,t.b*=100/255,t}(L(i));0===t.s&&(t.h=360);return t}(o=o||k(z(u.defaultValue,!0),u.letterCase)),n=u.keywords?C.map(u.keywords.split(","),function(i){return i.toLowerCase().trim()}):[],e=""!==i.val()&&-1<C.inArray(i.val().toLowerCase(),n)?k(i.val()):T(i.val())?I(i.val()):o,t||i.val(e),u.opacity&&(a=""===i.attr("data-opacity")?1:F(parseFloat(i.attr("data-opacity")).toFixed(2),0,1),isNaN(a)&&(a=1),i.attr("data-opacity",a),g.find("span").css("opacity",String(a)),l=F(v.height()-v.height()*a,0,v.height()),y.css("top",l+"px")),"transparent"===i.val().toLowerCase()&&g.find("span").css("opacity",String(0)),g.find("span").css("backgroundColor",o),u.control){case"wheel":h=F(Math.ceil(.75*s.s),0,m.height()/2),d=s.h*Math.PI/180,c=F(75-Math.cos(d)*h,0,m.width()),l=F(75-Math.sin(d)*h,0,m.height()),b.css({top:l+"px",left:c+"px"}),l=150-s.b/(100/m.height()),""===o&&(l=0),w.css("top",l+"px"),f.css("backgroundColor",q({h:s.h,s:s.s,b:100}));break;case"saturation":c=F(5*s.h/12,0,150),l=F(m.height()-Math.ceil(s.b/(100/m.height())),0,m.height()),b.css({top:l+"px",left:c+"px"}),l=F(f.height()-s.s*(f.height()/100),0,f.height()),w.css("top",l+"px"),f.css("backgroundColor",q({h:s.h,s:100,b:s.b})),p.find(".minicolors-grid-inner").css("opacity",s.s/100);break;case"brightness":c=F(5*s.h/12,0,150),l=F(m.height()-Math.ceil(s.s/(100/m.height())),0,m.height()),b.css({top:l+"px",left:c+"px"}),l=F(f.height()-s.b*(f.height()/100),0,f.height()),w.css("top",l+"px"),f.css("backgroundColor",q({h:s.h,s:s.s,b:100})),p.find(".minicolors-grid-inner").css("opacity",1-s.b/100);break;default:c=F(Math.ceil(s.s/(100/m.width())),0,m.width()),l=F(m.height()-Math.ceil(s.b/(100/m.height())),0,m.height()),b.css({top:l+"px",left:c+"px"}),l=F(f.height()-s.h/(360/f.height()),0,f.height()),w.css("top",l+"px"),m.css("backgroundColor",q({h:s.h,s:100,b:100}))}i.data("minicolors-initialized")&&S(i,e,a)}function S(i,t,o){var s,a,n,r=i.data("minicolors-settings"),e=i.data("minicolors-lastChange");if(!e||e.value!==t||e.opacity!==o){if(i.data("minicolors-lastChange",{value:t,opacity:o}),r.swatches&&0!==r.swatches.length){for(s=T(t)?I(t,!0):L(t),a=-1,n=0;n<r.swatches.length;++n)if(s.r===r.swatches[n].r&&s.g===r.swatches[n].g&&s.b===r.swatches[n].b&&s.a===r.swatches[n].a){a=n;break}i.parent().find(".minicolors-swatches .minicolors-swatch").removeClass("selected"),-1!==a&&i.parent().find(".minicolors-swatches .minicolors-swatch").eq(n).addClass("selected")}r.change&&(r.changeDelay?(clearTimeout(i.data("minicolors-changeTimeout")),i.data("minicolors-changeTimeout",setTimeout(function(){r.change.call(i.get(0),t,o)},r.changeDelay))):r.change.call(i.get(0),t,o)),i.trigger("change").trigger("input")}}function k(i,t){return"uppercase"===t?i.toUpperCase():i.toLowerCase()}function M(i,t){return!(i=i.replace(/^#/g,"")).match(/^[A-F0-9]{3,6}/gi)||3!==i.length&&6!==i.length?"":(3===i.length&&t&&(i=i[0]+i[0]+i[1]+i[1]+i[2]+i[2]),"#"+i)}function I(i,t){var o=i.replace(/[^\d,.]/g,"").split(",");return o[0]=F(parseInt(o[0],10),0,255),o[1]=F(parseInt(o[1],10),0,255),o[2]=F(parseInt(o[2],10),0,255),void 0!==o[3]&&(o[3]=F(parseFloat(o[3],10),0,1)),t?void 0!==o[3]?{r:o[0],g:o[1],b:o[2],a:o[3]}:{r:o[0],g:o[1],b:o[2]}:void 0!==o[3]&&o[3]<=1?"rgba("+o[0]+", "+o[1]+", "+o[2]+", "+o[3]+")":"rgb("+o[0]+", "+o[1]+", "+o[2]+")"}function z(i,t){return T(i)?I(i):M(i,t)}function F(i,t,o){return i<t&&(i=t),o<i&&(i=o),i}function T(i){var t=i.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);return!(!t||4!==t.length)}function D(i){return(i=i.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+(\.\d{1,2})?|\.\d{1,2})[\s+]?/i))&&6===i.length?i[4]:"1"}function j(i){return(i=i.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i))&&4===i.length?"#"+("0"+parseInt(i[1],10).toString(16)).slice(-2)+("0"+parseInt(i[2],10).toString(16)).slice(-2)+("0"+parseInt(i[3],10).toString(16)).slice(-2):""}function p(i){var o=[i.r.toString(16),i.g.toString(16),i.b.toString(16)];return C.each(o,function(i,t){1===t.length&&(o[i]="0"+t)}),"#"+o.join("")}function q(i){return p((t=i,n={},r=Math.round(t.h),e=Math.round(255*t.s/100),c=Math.round(255*t.b/100),0===e?n.r=n.g=n.b=c:(a=r%60*((o=c)-(s=(255-e)*c/255))/60,360===r&&(r=0),r<60?(n.r=o,n.b=s,n.g=s+a):r<120?(n.g=o,n.b=s,n.r=o-a):r<180?(n.g=o,n.r=s,n.b=s+a):r<240?(n.b=o,n.r=s,n.g=o-a):r<300?(n.b=o,n.g=s,n.r=s+a):r<360?(n.r=o,n.g=s,n.b=o-a):(n.r=0,n.g=0,n.b=0)),{r:Math.round(n.r),g:Math.round(n.g),b:Math.round(n.b)}));var t,o,s,a,n,r,e,c}function L(i){return{r:(i=parseInt(-1<i.indexOf("#")?i.substring(1):i,16))>>16,g:(65280&i)>>8,b:255&i}}C.minicolors={defaults:{animationSpeed:50,animationEasing:"swing",change:null,changeDelay:0,control:"hue",defaultValue:"",format:"hex",hide:null,hideSpeed:100,inline:!1,keywords:"",letterCase:"lowercase",opacity:!1,position:"bottom",show:null,showSpeed:100,theme:"default",swatches:[]}},C.extend(C.fn,{minicolors:function(i,t){switch(i){case"destroy":return C(this).each(function(){o(C(this))}),C(this);case"hide":return a(),C(this);case"opacity":return void 0===t?C(this).attr("data-opacity"):(C(this).each(function(){d(C(this).attr("data-opacity",t))}),C(this));case"rgbObject":return function(i){var t,o=C(i).attr("data-opacity");{var s;t=T(C(i).val())?I(C(i).val(),!0):(s=M(C(i).val(),!0),L(s))}if(!t)return null;void 0!==o&&C.extend(t,{a:parseFloat(o)});return t}(C(this));case"rgbString":case"rgbaString":return function(i,t){var o,s=C(i).attr("data-opacity");{var a;o=T(C(i).val())?I(C(i).val(),!0):(a=M(C(i).val(),!0),L(a))}if(!o)return null;void 0===s&&(s=1);return t?"rgba("+o.r+", "+o.g+", "+o.b+", "+parseFloat(s)+")":"rgb("+o.r+", "+o.g+", "+o.b+")"}(C(this),"rgbaString"===i);case"settings":return void 0===t?C(this).data("minicolors-settings"):(C(this).each(function(){var i=C(this).data("minicolors-settings")||{};o(C(this)),C(this).minicolors(C.extend(!0,i,t))}),C(this));case"show":return s(C(this).eq(0)),C(this);case"value":return void 0===t?C(this).val():(C(this).each(function(){"object"==typeof t&&null!==t?(void 0!==t.opacity&&C(this).attr("data-opacity",F(t.opacity,0,1)),t.color&&C(this).val(t.color)):C(this).val(t),d(C(this))}),C(this));default:return"create"!==i&&(t=i),C(this).each(function(){!function(t,i){var o,s,a,n,r,e,c,l=C('<div class="minicolors" />'),h=C.minicolors.defaults;if(t.data("minicolors-initialized"))return;i=C.extend(!0,{},h,i),l.addClass("minicolors-theme-"+i.theme).toggleClass("minicolors-with-opacity",i.opacity),void 0!==i.position&&C.each(i.position.split(" "),function(){l.addClass("minicolors-position-"+this)});s="rgb"===i.format?i.opacity?"25":"20":i.keywords?"11":"7";t.addClass("minicolors-input").data("minicolors-initialized",!1).data("minicolors-settings",i).prop("size",s).wrap(l).after('<div class="minicolors-panel minicolors-slider-'+i.control+'"><div class="minicolors-slider minicolors-sprite"><div class="minicolors-picker"></div></div><div class="minicolors-opacity-slider minicolors-sprite"><div class="minicolors-picker"></div></div><div class="minicolors-grid minicolors-sprite"><div class="minicolors-grid-inner"></div><div class="minicolors-picker"><div></div></div></div></div>'),i.inline||(t.after('<span class="minicolors-swatch minicolors-sprite minicolors-input-swatch"><span class="minicolors-swatch-color"></span></span>'),t.next(".minicolors-input-swatch").on("click",function(i){i.preventDefault(),t.trigger("focus")}));if((e=t.parent().find(".minicolors-panel")).on("selectstart",function(){return!1}).end(),i.swatches&&0!==i.swatches.length)for(e.addClass("minicolors-with-swatches"),a=C('<ul class="minicolors-swatches"></ul>').appendTo(e),c=0;c<i.swatches.length;++c)n="object"==typeof i.swatches[c]?(o=i.swatches[c].name,i.swatches[c].color):(o="",i.swatches[c]),n=T(r=n)?I(n,!0):L(M(n,!0)),C('<li class="minicolors-swatch minicolors-sprite"><span class="minicolors-swatch-color"></span></li>').attr("title",o).appendTo(a).data("swatch-color",r).find(".minicolors-swatch-color").css({backgroundColor:"transparent"!==r?p(n):"transparent",opacity:String(n.a)}),i.swatches[c]=n;i.inline&&t.parent().addClass("minicolors-inline");d(t,!1),t.data("minicolors-initialized",!0)}(C(this),t)}),C(this)}}}),C([document]).on("mousedown.minicolors touchstart.minicolors",function(i){C(i.target).parents().add(i.target).hasClass("minicolors")||a()}).on("mousedown.minicolors touchstart.minicolors",".minicolors-grid, .minicolors-slider, .minicolors-opacity-slider",function(i){var t=C(this);i.preventDefault(),C(i.delegateTarget).data("minicolors-target",t),n(t,i,!0)}).on("mousemove.minicolors touchmove.minicolors",function(i){var t=C(i.delegateTarget).data("minicolors-target");t&&n(t,i)}).on("mouseup.minicolors touchend.minicolors",function(){C(this).removeData("minicolors-target")}).on("click.minicolors",".minicolors-swatches li",function(i){i.preventDefault();var t=C(this),o=t.parents(".minicolors").find(".minicolors-input"),s=t.data("swatch-color");x(o,s,D(s)),d(o)}).on("mousedown.minicolors touchstart.minicolors",".minicolors-input-swatch",function(i){var t=C(this).parent().find(".minicolors-input");i.preventDefault(),s(t)}).on("focus.minicolors",".minicolors-input",function(){var i=C(this);i.data("minicolors-initialized")&&s(i)}).on("blur.minicolors",".minicolors-input",function(){var i,t,o,s,a,n=C(this),r=n.data("minicolors-settings");n.data("minicolors-initialized")&&(i=r.keywords?C.map(r.keywords.split(","),function(i){return i.toLowerCase().trim()}):[],a=""!==n.val()&&-1<C.inArray(n.val().toLowerCase(),i)?n.val():null===(o=T(n.val())?I(n.val(),!0):(t=M(n.val(),!0))?L(t):null)?r.defaultValue:"rgb"===r.format?r.opacity?I("rgba("+o.r+","+o.g+","+o.b+","+n.attr("data-opacity")+")"):I("rgb("+o.r+","+o.g+","+o.b+")"):p(o),s=r.opacity?n.attr("data-opacity"):1,"transparent"===a.toLowerCase()&&(s=0),n.closest(".minicolors").find(".minicolors-input-swatch > span").css("opacity",String(s)),n.val(a),""===n.val()&&n.val(z(r.defaultValue,!0)),n.val(k(n.val(),r.letterCase)))}).on("keydown.minicolors",".minicolors-input",function(i){var t=C(this);if(t.data("minicolors-initialized"))switch(i.which){case 9:a();break;case 13:case 27:a(),t.blur()}}).on("keyup.minicolors",".minicolors-input",function(){var i=C(this);i.data("minicolors-initialized")&&d(i,!0)}).on("paste.minicolors",".minicolors-input",function(){var i=C(this);i.data("minicolors-initialized")&&setTimeout(function(){d(i,!0)},1)})});
\ No newline at end of file", "url": "https://github.com/claviska/jquery-minicolors/commit/ef134824a7f4110ada53ea6c173111a4fa2f48f3.patch" } ]
null
GHSA-8vvx-qvq9-5948
Flowise allows arbitrary file write to RCE
null
[ { "commit_message": "[PATCH] Bugfix/arbitrary create attachemnt file upload (#4171) fix arbitrary create attachemnt file upload .../PostgresRecordManager.ts | 1 - packages/components/src/index.ts | 1 + packages/components/src/storageUtils.ts | 12 +++---- packages/components/src/validator.ts | 29 +++++++++++++++++ packages/server/src/utils/createAttachment.ts | 32 +++++++++++++------ 5 files changed, 59 insertions(+), 16 deletions(-) create mode 100644 packages/components/src/validator.ts", "patch_text_b64": "From c2b830f279e454e8b758da441016b2234f220ac7 Mon Sep 17 00:00:00 2001
From: Henry Heng <henryheng@flowiseai.com>
Date: Thu, 13 Mar 2025 19:46:27 +0000
Subject: [PATCH] Bugfix/arbitrary create attachemnt file upload (#4171)

fix arbitrary create attachemnt file upload
---
 .../PostgresRecordManager.ts                  |  1 -
 packages/components/src/index.ts              |  1 +
 packages/components/src/storageUtils.ts       | 12 +++----
 packages/components/src/validator.ts          | 29 +++++++++++++++++
 packages/server/src/utils/createAttachment.ts | 32 +++++++++++++------
 5 files changed, 59 insertions(+), 16 deletions(-)
 create mode 100644 packages/components/src/validator.ts

diff --git a/packages/components/nodes/recordmanager/PostgresRecordManager/PostgresRecordManager.ts b/packages/components/nodes/recordmanager/PostgresRecordManager/PostgresRecordManager.ts
index 0c5d60fb8b5..6294429dfed 100644
--- a/packages/components/nodes/recordmanager/PostgresRecordManager/PostgresRecordManager.ts
+++ b/packages/components/nodes/recordmanager/PostgresRecordManager/PostgresRecordManager.ts
@@ -4,7 +4,6 @@ import { ListKeyOptions, RecordManagerInterface, UpdateOptions } from '@langchai
 import { DataSource } from 'typeorm'
 import { getHost, getSSL } from '../../vectorstores/Postgres/utils'
 import { getDatabase, getPort, getTableName } from './utils'
-import fs from 'fs'
 
 const serverCredentialsExists = !!process.env.POSTGRES_RECORDMANAGER_USER && !!process.env.POSTGRES_RECORDMANAGER_PASSWORD
 
diff --git a/packages/components/src/index.ts b/packages/components/src/index.ts
index ec713bec314..a38761066ca 100644
--- a/packages/components/src/index.ts
+++ b/packages/components/src/index.ts
@@ -10,3 +10,4 @@ export * from './speechToText'
 export * from './storageUtils'
 export * from './handler'
 export * from './followUpPrompts'
+export * from './validator'
diff --git a/packages/components/src/storageUtils.ts b/packages/components/src/storageUtils.ts
index 3f120b70057..7d214220818 100644
--- a/packages/components/src/storageUtils.ts
+++ b/packages/components/src/storageUtils.ts
@@ -77,7 +77,7 @@ export const addArrayFilesToStorage = async (mime: string, bf: Buffer, fileName:
         fileNames.push(sanitizedFilename)
         return 'FILE-STORAGE::' + JSON.stringify(fileNames)
     } else {
-        const dir = path.join(getStoragePath(), ...paths)
+        const dir = path.join(getStoragePath(), ...paths.map(_sanitizeFilename))
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true })
         }
@@ -110,7 +110,7 @@ export const addSingleFileToStorage = async (mime: string, bf: Buffer, fileName:
         await s3Client.send(putObjCmd)
         return 'FILE-STORAGE::' + sanitizedFilename
     } else {
-        const dir = path.join(getStoragePath(), ...paths)
+        const dir = path.join(getStoragePath(), ...paths.map(_sanitizeFilename))
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true })
         }
@@ -180,7 +180,7 @@ export const getFileFromStorage = async (file: string, ...paths: string[]): Prom
         const buffer = Buffer.concat(response.Body.toArray())
         return buffer
     } else {
-        const fileInStorage = path.join(getStoragePath(), ...paths, sanitizedFilename)
+        const fileInStorage = path.join(getStoragePath(), ...paths.map(_sanitizeFilename), sanitizedFilename)
         return fs.readFileSync(fileInStorage)
     }
 }
@@ -209,7 +209,7 @@ export const removeFilesFromStorage = async (...paths: string[]) => {
         }
         await _deleteS3Folder(Key)
     } else {
-        const directory = path.join(getStoragePath(), ...paths)
+        const directory = path.join(getStoragePath(), ...paths.map(_sanitizeFilename))
         _deleteLocalFolderRecursive(directory)
     }
 }
@@ -243,7 +243,7 @@ export const removeSpecificFileFromStorage = async (...paths: string[]) => {
             const sanitizedFilename = _sanitizeFilename(fileName)
             paths.push(sanitizedFilename)
         }
-        const file = path.join(getStoragePath(), ...paths)
+        const file = path.join(getStoragePath(), ...paths.map(_sanitizeFilename))
         fs.unlinkSync(file)
     }
 }
@@ -258,7 +258,7 @@ export const removeFolderFromStorage = async (...paths: string[]) => {
         }
         await _deleteS3Folder(Key)
     } else {
-        const directory = path.join(getStoragePath(), ...paths)
+        const directory = path.join(getStoragePath(), ...paths.map(_sanitizeFilename))
         _deleteLocalFolderRecursive(directory, true)
     }
 }
diff --git a/packages/components/src/validator.ts b/packages/components/src/validator.ts
new file mode 100644
index 00000000000..4948165eb4c
--- /dev/null
+++ b/packages/components/src/validator.ts
@@ -0,0 +1,29 @@
+/**
+ * Validates if a string is a valid UUID v4
+ * @param {string} uuid The string to validate
+ * @returns {boolean} True if valid UUID, false otherwise
+ */
+export const isValidUUID = (uuid: string): boolean => {
+    // UUID v4 regex pattern
+    const uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+    return uuidV4Pattern.test(uuid)
+}
+
+/**
+ * Validates if a string contains path traversal attempts
+ * @param {string} path The string to validate
+ * @returns {boolean} True if path traversal detected, false otherwise
+ */
+export const isPathTraversal = (path: string): boolean => {
+    // Check for common path traversal patterns
+    const dangerousPatterns = [
+        '..', // Directory traversal
+        '/', // Root directory
+        '\\', // Windows root directory
+        '%2e', // URL encoded .
+        '%2f', // URL encoded /
+        '%5c' // URL encoded \
+    ]
+
+    return dangerousPatterns.some((pattern) => path.toLowerCase().includes(pattern))
+}
diff --git a/packages/server/src/utils/createAttachment.ts b/packages/server/src/utils/createAttachment.ts
index 3a2e691a80d..d38f6a93cb7 100644
--- a/packages/server/src/utils/createAttachment.ts
+++ b/packages/server/src/utils/createAttachment.ts
@@ -6,10 +6,15 @@ import {
     IDocument,
     mapExtToInputField,
     mapMimeTypeToInputField,
-    removeSpecificFileFromUpload
+    removeSpecificFileFromUpload,
+    isValidUUID,
+    isPathTraversal
 } from 'flowise-components'
 import { getRunningExpressApp } from './getRunningExpressApp'
 import { getErrorMessage } from '../errors/utils'
+import { InternalFlowiseError } from '../errors/internalFlowiseError'
+import { StatusCodes } from 'http-status-codes'
+import { ChatFlow } from '../database/entities/ChatFlow'
 
 /**
  * Create attachment
@@ -19,17 +24,26 @@ export const createFileAttachment = async (req: Request) => {
     const appServer = getRunningExpressApp()
 
     const chatflowid = req.params.chatflowId
-    if (!chatflowid) {
-        throw new Error(
-            'Params chatflowId is required! Please provide chatflowId and chatId in the URL: /api/v1/attachments/:chatflowId/:chatId'
-        )
+    if (!chatflowid || !isValidUUID(chatflowid)) {
+        throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'Invalid chatflowId format - must be a valid UUID')
     }
 
     const chatId = req.params.chatId
-    if (!chatId) {
-        throw new Error(
-            'Params chatId is required! Please provide chatflowId and chatId in the URL: /api/v1/attachments/:chatflowId/:chatId'
-        )
+    if (!chatId || !isValidUUID(chatId)) {
+        throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'Invalid chatId format - must be a valid UUID')
+    }
+
+    // Check for path traversal attempts
+    if (isPathTraversal(chatflowid) || isPathTraversal(chatId)) {
+        throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'Invalid path characters detected')
+    }
+
+    // Validate chatflow exists and check API key
+    const chatflow = await appServer.AppDataSource.getRepository(ChatFlow).findOneBy({
+        id: chatflowid
+    })
+    if (!chatflow) {
+        throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Chatflow ${chatflowid} not found`)
     }
 
     // Find FileLoader node", "url": "https://github.com/FlowiseAI/Flowise/commit/c2b830f279e454e8b758da441016b2234f220ac7.patch" } ]
null
PYSEC-2022-42975
null
[ { "commit_message": "[PATCH] =?UTF-8?q?=F0=9F=94=92=EF=B8=8F=20Close=20a=20sanity=20ch?= =?UTF-8?q?eck=20hole=20in=20language=20packs?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A language pack containing a directory traversing symlink could be uploaded. Upon backup creation, the symlink would then lead to inclusion of whatever it was pointing to in the resulting backup. This could be used by an attacker with admin permissions to extract information from the server. src/octoprint/server/api/languages.py | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/octoprint/octoprint/commit/3cca3a43f3d085e9bbe5a5840c8255bb1b5d052e.patch" } ]
null
CVE-2017-6890
A boundary error within the "foveon_load_camf()" function (dcraw_foveon.c) when initializing a huffman table in LibRaw-demosaic-pack-GPL2 before 0.18.2 can be exploited to cause a stack-based buffer overflow.
[ { "commit_message": "[PATCH] Fixed possible foveon buffer overrun (Secunia SA750000) dcraw_foveon.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)", "patch_text_b64": "RnJvbSAxOTRmNTkyZTIwNTk5MGVhOGZjZTcyYjZjNTcxYzE0MzUwYWNhNzE2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbGV4IFR1dHViYWxpbiA8bGV4YUBsZXhhLnJ1PgpEYXRlOiBTYXQsIDQgTWFyIDIwMTcgMTk6NTU6MjQgKzAzMDAKU3ViamVjdDogW1BBVENIXSBGaXhlZCBwb3NzaWJsZSBmb3Zlb24gYnVmZmVyIG92ZXJydW4gKFNlY3VuaWEgU0E3NTAwMDApCgotLS0KIGRjcmF3X2ZvdmVvbi5jIHwgOCArKysrKystLQogMSBmaWxlIGNoYW5nZWQsIDYgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kY3Jhd19mb3Zlb24uYyBiL2RjcmF3X2ZvdmVvbi5jCmluZGV4IGQ4YjcwMDUuLmJkZGU4OWQgMTAwNjQ0Ci0tLSBhL2RjcmF3X2ZvdmVvbi5jCisrKyBiL2RjcmF3X2ZvdmVvbi5jCkBAIC0zMTksNyArMzE5LDcgQEAgdm9pZCBDTEFTUyBmb3Zlb25faHVmZiAodXNob3J0ICpodWZmKQogdm9pZCBDTEFTUyBmb3Zlb25fZHBfbG9hZF9yYXcoKQogewogICB1bnNpZ25lZCBjLCByb2ZmWzRdLCByb3csIGNvbCwgZGlmZjsKLSAgdXNob3J0IGh1ZmZbNTEyXSwgdnByZWRbMl1bMl0sIGhwcmVkWzJdOworICB1c2hvcnQgaHVmZlsxMDI0XSwgdnByZWRbMl1bMl0sIGhwcmVkWzJdOwogCiAgIGZzZWVrIChpZnAsIDgsIFNFRUtfQ1VSKTsKICAgZm92ZW9uX2h1ZmYgKGh1ZmYpOwpAQCAtMzQ2LDEyICszNDYsMTYgQEAgdm9pZCBDTEFTUyBmb3Zlb25fZHBfbG9hZF9yYXcoKQogdm9pZCBDTEFTUyBmb3Zlb25fbG9hZF9jYW1mKCkKIHsKICAgdW5zaWduZWQgdHlwZSwgd2lkZSwgaGlnaCwgaSwgaiwgcm93LCBjb2wsIGRpZmY7Ci0gIHVzaG9ydCBodWZmWzI1OF0sIHZwcmVkWzJdWzJdID0ge3s1MTIsNTEyfSx7NTEyLDUxMn19LCBocHJlZFsyXTsKKyAgdXNob3J0IGh1ZmZbMTAyNF0sIHZwcmVkWzJdWzJdID0ge3s1MTIsNTEyfSx7NTEyLDUxMn19LCBocHJlZFsyXTsKIAogICBmc2VlayAoaWZwLCBtZXRhX29mZnNldCwgU0VFS19TRVQpOwogICB0eXBlID0gZ2V0NCgpOyAgZ2V0NCgpOyAgZ2V0NCgpOwogICB3aWRlID0gZ2V0NCgpOwogICBoaWdoID0gZ2V0NCgpOworI2lmZGVmIExJQlJBV19MSUJSQVJZX0JVSUxECisgIGlmKHdpZGU+MzI3NjcgfHwgaGlnaCA+IDMyNzY3IHx8IHdpZGUqaGlnaCA+IDIwMDAwMDAwKQorICAgICB0aHJvdyBMSUJSQVdfRVhDRVBUSU9OX0lPX0NPUlJVUFQ7CisjZW5kaWYKICAgaWYgKHR5cGUgPT0gMikgewogICAgIGZyZWFkIChtZXRhX2RhdGEsIDEsIG1ldGFfbGVuZ3RoLCBpZnApOwogICAgIGZvciAoaT0wOyBpIDwgbWV0YV9sZW5ndGg7IGkrKykgew==", "url": "https://github.com/LibRaw/LibRaw-demosaic-pack-GPL2/commit/194f592e205990ea8fce72b6c571c14350aca716.patch" } ]
Stack-based buffer overflow
CVE-2017-6390
An issue was discovered in whatanime.ga before c334dd8499a681587dd4199e90b0aa0eba814c1d. The vulnerability exists due to insufficient filtration of user-supplied data passed to the "whatanime.ga-master/index.php" URL. An attacker could execute arbitrary HTML and script code in a browser in the context of the vulnerable website.
[ { "commit_message": "[PATCH] Fix #8 XSS issue index.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSBjMzM0ZGQ4NDk5YTY4MTU4N2RkNDE5OWU5MGIwYWEwZWJhODE0YzFkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBzb3J1bHkgPHNvcnVseUBnbWFpbC5jb20+CkRhdGU6IFR1ZSwgMjggRmViIDIwMTcgMTE6NDE6MjIgKzA4MDAKU3ViamVjdDogW1BBVENIXSBGaXggIzggWFNTIGlzc3VlCgotLS0KIGluZGV4LnBocCB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2luZGV4LnBocCBiL2luZGV4LnBocAppbmRleCA5MGFlMjA1Li41MjRmYTMxIDEwMDc1NQotLS0gYS9pbmRleC5waHAKKysrIGIvaW5kZXgucGhwCkBAIC0xMjEsNyArMTIxLDcgQEAKIDxzY3JpcHQgc3JjPSIvanF1ZXJ5Lmh0bWw1dXBsb2FkZXIubWluLmpzIj48L3NjcmlwdD4NCiA8c2NyaXB0IHNyYz0iL2luZGV4LmpzIj48L3NjcmlwdD4NCiA8P3BocA0KLWlmKGlzc2V0KCRfR0VUWyJ1cmwiXSkpew0KK2lmKGlzc2V0KCRfR0VUWyJ1cmwiXSkgJiYgZmlsdGVyX3ZhcigkX0dFVFsidXJsIl0sIEZJTFRFUl9WQUxJREFURV9VUkwpKXsNCiBlY2hvICc8c2NyaXB0Pg0KIGRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoIiNhdXRvU2VhcmNoIikuY2hlY2tlZCA9IHRydWU7DQogZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiI21lc3NhZ2VUZXh0IikuY2xhc3NMaXN0LnJlbW92ZSgiZXJyb3IiKTs=", "url": "https://github.com/soruly/whatanime.ga/commit/c334dd8499a681587dd4199e90b0aa0eba814c1d.patch" } ]
n/a
GHSA-7767-wr3w-3hqg
null
[ { "commit_message": "[PATCH] bplist: Fix data range check for string/data/dict/array nodes Passing a size of 0xFFFFFFFFFFFFFFFF to parse_string_node() might result in a memcpy with a size of -1, leading to undefined behavior. This commit makes sure that the actual node data (which depends on the size) is in the range start_of_object..start_of_object+size. Credit to OSS-Fuzz src/bplist.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/libimobiledevice/libplist/commit/32ee5213fe64f1e10ec76c1ee861ee6f233120dd.patch" } ]
null
GHSA-8r58-88c9-cfv7
null
[ { "commit_message": "[PATCH] Filter more mimetypes There's no need to allow more than those defined mimetypes for images. apps/dav/lib/CardDAV/ImageExportPlugin.php | 12 ++++ .../unit/CardDAV/ImageExportPluginTest.php | 60 ++++++++++++++++--- 2 files changed, 63 insertions(+), 9 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/nextcloud/server/commit/68ab8325c799d20c1fb7e98d670785176590e7d0.patch" }, { "commit_message": "[PATCH] [stable9.1] Merge pull request #26459 from owncloud/limit-carddav-image-export-mime-types Limit carddav image export mime types apps/dav/lib/CardDAV/ImageExportPlugin.php | 10 ++++++++-- .../tests/unit/CardDAV/ImageExportPluginTest.php | 16 ++++++++++------ 2 files changed, 18 insertions(+), 8 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/owncloud/core/commit/6bf3be3877d9d9fda9c66926fe273fe79cbaf58e.patch" }, { "commit_message": "[PATCH] [stable9.1] Merge pull request #26459 from owncloud/limit-carddav-image-export-mime-types Limit carddav image export mime types apps/dav/lib/carddav/imageexportplugin.php | 10 ++++++++-- .../tests/unit/carddav/imageexportplugintest.php | 16 ++++++++++------ 2 files changed, 18 insertions(+), 8 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/owncloud/core/commit/b5a5be24c418033cb2ef965a4f3f06b7b4213845.patch" } ]
null
CVE-2024-31208
Synapse's V2 state resolution weakness allows DoS from remote room members
Synapse is an open-source Matrix homeserver. A remote Matrix user with malicious intent, sharing a room with Synapse instances before 1.105.1, can dispatch specially crafted events to exploit a weakness in the V2 state resolution algorithm. This can induce high CPU consumption and accumulate excessive data in the database of such instances, resulting in a denial of service. Servers in private federations, or those that do not federate, are not affected. Server administrators should upgrade to 1.105.1 or later. Some workarounds are available. One can ban the malicious users or ACL block servers from the rooms and/or leave the room and purge the room using the admin API.
[ { "commit_message": "[PATCH] Fix GHSA-3h7q-rfh9-xm4v Weakness in auth chain indexing allows DoS from remote room members through disk fill and high CPU usage. A remote Matrix user with malicious intent, sharing a room with Synapse instances before 1.104.1, can dispatch specially crafted events to exploit a weakness in how the auth chain cover index is calculated. This can induce high CPU consumption and accumulate excessive data in the database of such instances, resulting in a denial of service. Servers in private federations, or those that do not federate, are not affected. changelog.d/17044.misc | 1 + synapse/storage/databases/main/events.py | 108 ++++++++--------------- synapse/storage/schema/__init__.py | 8 +- tests/storage/test_event_chain.py | 104 +++++++++++++++------- 4 files changed, 117 insertions(+), 104 deletions(-) create mode 100644 changelog.d/17044.misc", "patch_text_b64": "From 55b0aa847a61774b6a3acdc4b177a20dc019f01a Mon Sep 17 00:00:00 2001
From: Erik Johnston <erik@matrix.org>
Date: Tue, 23 Apr 2024 15:24:08 +0100
Subject: [PATCH] Fix GHSA-3h7q-rfh9-xm4v

Weakness in auth chain indexing allows DoS from remote room members
through disk fill and high CPU usage.

A remote Matrix user with malicious intent, sharing a room with Synapse
instances before 1.104.1, can dispatch specially crafted events to
exploit a weakness in how the auth chain cover index is calculated. This
can induce high CPU consumption and accumulate excessive data in the
database of such instances, resulting in a denial of service.

Servers in private federations, or those that do not federate, are not
affected.
---
 changelog.d/17044.misc                   |   1 +
 synapse/storage/databases/main/events.py | 108 ++++++++---------------
 synapse/storage/schema/__init__.py       |   8 +-
 tests/storage/test_event_chain.py        | 104 +++++++++++++++-------
 4 files changed, 117 insertions(+), 104 deletions(-)
 create mode 100644 changelog.d/17044.misc

diff --git a/changelog.d/17044.misc b/changelog.d/17044.misc
new file mode 100644
index 00000000000..a1439752d34
--- /dev/null
+++ b/changelog.d/17044.misc
@@ -0,0 +1 @@
+Refactor auth chain fetching to reduce duplication.
diff --git a/synapse/storage/databases/main/events.py b/synapse/storage/databases/main/events.py
index a6fda3f43c8..1e731d56bde 100644
--- a/synapse/storage/databases/main/events.py
+++ b/synapse/storage/databases/main/events.py
@@ -19,6 +19,7 @@
 # [This file includes modifications made by New Vector Limited]
 #
 #
+import collections
 import itertools
 import logging
 from collections import OrderedDict
@@ -53,6 +54,7 @@
     LoggingDatabaseConnection,
     LoggingTransaction,
 )
+from synapse.storage.databases.main.event_federation import EventFederationStore
 from synapse.storage.databases.main.events_worker import EventCacheEntry
 from synapse.storage.databases.main.search import SearchEntry
 from synapse.storage.engines import PostgresEngine
@@ -768,40 +770,26 @@ def _add_chain_cover_index(
         #      that have the same chain ID as the event.
         #   2. For each retained auth event we:
         #       a. Add a link from the event's to the auth event's chain
-        #          ID/sequence number; and
-        #       b. Add a link from the event to every chain reachable by the
-        #          auth event.
+        #          ID/sequence number
 
         # Step 1, fetch all existing links from all the chains we've seen
         # referenced.
         chain_links = _LinkMap()
-        auth_chain_rows = cast(
-            List[Tuple[int, int, int, int]],
-            db_pool.simple_select_many_txn(
-                txn,
-                table="event_auth_chain_links",
-                column="origin_chain_id",
-                iterable={chain_id for chain_id, _ in chain_map.values()},
-                keyvalues={},
-                retcols=(
-                    "origin_chain_id",
-                    "origin_sequence_number",
-                    "target_chain_id",
-                    "target_sequence_number",
-                ),
-            ),
-        )
-        for (
-            origin_chain_id,
-            origin_sequence_number,
-            target_chain_id,
-            target_sequence_number,
-        ) in auth_chain_rows:
-            chain_links.add_link(
-                (origin_chain_id, origin_sequence_number),
-                (target_chain_id, target_sequence_number),
-                new=False,
-            )
+
+        for links in EventFederationStore._get_chain_links(
+            txn, {chain_id for chain_id, _ in chain_map.values()}
+        ):
+            for origin_chain_id, inner_links in links.items():
+                for (
+                    origin_sequence_number,
+                    target_chain_id,
+                    target_sequence_number,
+                ) in inner_links:
+                    chain_links.add_link(
+                        (origin_chain_id, origin_sequence_number),
+                        (target_chain_id, target_sequence_number),
+                        new=False,
+                    )
 
         # We do this in toplogical order to avoid adding redundant links.
         for event_id in sorted_topologically(
@@ -836,18 +824,6 @@ def _add_chain_cover_index(
                     (chain_id, sequence_number), (auth_chain_id, auth_sequence_number)
                 )
 
-                # Step 2b, add a link to chains reachable from the auth
-                # event.
-                for target_id, target_seq in chain_links.get_links_from(
-                    (auth_chain_id, auth_sequence_number)
-                ):
-                    if target_id == chain_id:
-                        continue
-
-                    chain_links.add_link(
-                        (chain_id, sequence_number), (target_id, target_seq)
-                    )
-
         db_pool.simple_insert_many_txn(
             txn,
             table="event_auth_chain_links",
@@ -2451,31 +2427,6 @@ def add_link(
         current_links[src_seq] = target_seq
         return True
 
-    def get_links_from(
-        self, src_tuple: Tuple[int, int]
-    ) -> Generator[Tuple[int, int], None, None]:
-        """Gets the chains reachable from the given chain/sequence number.
-
-        Yields:
-            The chain ID and sequence number the link points to.
-        """
-        src_chain, src_seq = src_tuple
-        for target_id, sequence_numbers in self.maps.get(src_chain, {}).items():
-            for link_src_seq, target_seq in sequence_numbers.items():
-                if link_src_seq <= src_seq:
-                    yield target_id, target_seq
-
-    def get_links_between(
-        self, source_chain: int, target_chain: int
-    ) -> Generator[Tuple[int, int], None, None]:
-        """Gets the links between two chains.
-
-        Yields:
-            The source and target sequence numbers.
-        """
-
-        yield from self.maps.get(source_chain, {}).get(target_chain, {}).items()
-
     def get_additions(self) -> Generator[Tuple[int, int, int, int], None, None]:
         """Gets any newly added links.
 
@@ -2502,9 +2453,24 @@ def exists_path_from(
         if src_chain == target_chain:
             return target_seq <= src_seq
 
-        links = self.get_links_between(src_chain, target_chain)
-        for link_start_seq, link_end_seq in links:
-            if link_start_seq <= src_seq and target_seq <= link_end_seq:
-                return True
+        # We have to graph traverse the links to check for indirect paths.
+        visited_chains = collections.Counter()
+        search = [(src_chain, src_seq)]
+        while search:
+            chain, seq = search.pop()
+            visited_chains[chain] = max(seq, visited_chains[chain])
+            for tc, links in self.maps.get(chain, {}).items():
+                for ss, ts in links.items():
+                    # Don't revisit chains we've already seen, unless the target
+                    # sequence number is higher than last time.
+                    if ts <= visited_chains.get(tc, 0):
+                        continue
+
+                    if ss <= seq:
+                        if tc == target_chain:
+                            if target_seq <= ts:
+                                return True
+                        else:
+                            search.append((tc, ts))
 
         return False
diff --git a/synapse/storage/schema/__init__.py b/synapse/storage/schema/__init__.py
index c0b925444fe..039aa91b92e 100644
--- a/synapse/storage/schema/__init__.py
+++ b/synapse/storage/schema/__init__.py
@@ -132,12 +132,16 @@
 
 Changes in SCHEMA_VERSION = 83
     - The event_txn_id is no longer used.
+
+Changes in SCHEMA_VERSION = 84
+    - No longer assumes that `event_auth_chain_links` holds transitive links, and
+      so read operations must do graph traversal.
 """
 
 
 SCHEMA_COMPAT_VERSION = (
-    # The event_txn_id table and tables from MSC2716 no longer exist.
-    83
+    # Transitive links are no longer written to `event_auth_chain_links`
+    84
 )
 """Limit on how far the synapse codebase can be rolled back without breaking db compat
 
diff --git a/tests/storage/test_event_chain.py b/tests/storage/test_event_chain.py
index 9e4e73832e3..27d5b0125fd 100644
--- a/tests/storage/test_event_chain.py
+++ b/tests/storage/test_event_chain.py
@@ -21,6 +21,8 @@
 
 from typing import Dict, List, Set, Tuple, cast
 
+from parameterized import parameterized
+
 from twisted.test.proto_helpers import MemoryReactor
 from twisted.trial import unittest
 
@@ -45,7 +47,8 @@ def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
         self.store = hs.get_datastores().main
         self._next_stream_ordering = 1
 
-    def test_simple(self) -> None:
+    @parameterized.expand([(False,), (True,)])
+    def test_simple(self, batched: bool) -> None:
         """Test that the example in `docs/auth_chain_difference_algorithm.md`
         works.
         """
@@ -53,6 +56,7 @@ def test_simple(self) -> None:
         event_factory = self.hs.get_event_builder_factory()
         bob = "@creator:test"
         alice = "@alice:test"
+        charlie = "@charlie:test"
         room_id = "!room:test"
 
         # Ensure that we have a rooms entry so that we generate the chain index.
@@ -191,6 +195,26 @@ def test_simple(self) -> None:
             )
         )
 
+        charlie_invite = self.get_success(
+            event_factory.for_room_version(
+                RoomVersions.V6,
+                {
+                    "type": EventTypes.Member,
+                    "state_key": charlie,
+                    "sender": alice,
+                    "room_id": room_id,
+                    "content": {"tag": "charlie_invite"},
+                },
+            ).build(
+                prev_event_ids=[],
+                auth_event_ids=[
+                    create.event_id,
+                    alice_join2.event_id,
+                    power_2.event_id,
+                ],
+            )
+        )
+
         events = [
             create,
             bob_join,
@@ -200,33 +224,41 @@ def test_simple(self) -> None:
             bob_join_2,
             power_2,
             alice_join2,
+            charlie_invite,
         ]
 
         expected_links = [
             (bob_join, create),
-            (power, create),
             (power, bob_join),
-            (alice_invite, create),
             (alice_invite, power),
-            (alice_invite, bob_join),
             (bob_join_2, power),
             (alice_join2, power_2),
+            (charlie_invite, alice_join2),
         ]
 
-        self.persist(events)
+        # We either persist as a batch or one-by-one depending on test
+        # parameter.
+        if batched:
+            self.persist(events)
+        else:
+            for event in events:
+                self.persist([event])
+
         chain_map, link_map = self.fetch_chains(events)
 
         # Check that the expected links and only the expected links have been
         # added.
-        self.assertEqual(len(expected_links), len(list(link_map.get_additions())))
-
-        for start, end in expected_links:
-            start_id, start_seq = chain_map[start.event_id]
-            end_id, end_seq = chain_map[end.event_id]
+        event_map = {e.event_id: e for e in events}
+        reverse_chain_map = {v: event_map[k] for k, v in chain_map.items()}
 
-            self.assertIn(
-                (start_seq, end_seq), list(link_map.get_links_between(start_id, end_id))
-            )
+        self.maxDiff = None
+        self.assertCountEqual(
+            expected_links,
+            [
+                (reverse_chain_map[(s1, s2)], reverse_chain_map[(t1, t2)])
+                for s1, s2, t1, t2 in link_map.get_additions()
+            ],
+        )
 
         # Test that everything can reach the create event, but the create event
         # can't reach anything.
@@ -368,24 +400,23 @@ def test_out_of_order_events(self) -> None:
 
         expected_links = [
             (bob_join, create),
-            (power, create),
             (power, bob_join),
-            (alice_invite, create),
             (alice_invite, power),
-            (alice_invite, bob_join),
         ]
 
         # Check that the expected links and only the expected links have been
         # added.
-        self.assertEqual(len(expected_links), len(list(link_map.get_additions())))
+        event_map = {e.event_id: e for e in events}
+        reverse_chain_map = {v: event_map[k] for k, v in chain_map.items()}
 
-        for start, end in expected_links:
-            start_id, start_seq = chain_map[start.event_id]
-            end_id, end_seq = chain_map[end.event_id]
-
-            self.assertIn(
-                (start_seq, end_seq), list(link_map.get_links_between(start_id, end_id))
-            )
+        self.maxDiff = None
+        self.assertCountEqual(
+            expected_links,
+            [
+                (reverse_chain_map[(s1, s2)], reverse_chain_map[(t1, t2)])
+                for s1, s2, t1, t2 in link_map.get_additions()
+            ],
+        )
 
     def persist(
         self,
@@ -489,8 +520,6 @@ def test_simple(self) -> None:
         link_map = _LinkMap()
 
         link_map.add_link((1, 1), (2, 1), new=False)
-        self.assertCountEqual(link_map.get_links_between(1, 2), [(1, 1)])
-        self.assertCountEqual(link_map.get_links_from((1, 1)), [(2, 1)])
         self.assertCountEqual(link_map.get_additions(), [])
         self.assertTrue(link_map.exists_path_from((1, 5), (2, 1)))
         self.assertFalse(link_map.exists_path_from((1, 5), (2, 2)))
@@ -499,18 +528,31 @@ def test_simple(self) -> None:
 
         # Attempting to add a redundant link is ignored.
         self.assertFalse(link_map.add_link((1, 4), (2, 1)))
-        self.assertCountEqual(link_map.get_links_between(1, 2), [(1, 1)])
+        self.assertCountEqual(link_map.get_additions(), [])
 
         # Adding new non-redundant links works
         self.assertTrue(link_map.add_link((1, 3), (2, 3)))
-        self.assertCountEqual(link_map.get_links_between(1, 2), [(1, 1), (3, 3)])
+        self.assertCountEqual(link_map.get_additions(), [(1, 3, 2, 3)])
 
         self.assertTrue(link_map.add_link((2, 5), (1, 3)))
-        self.assertCountEqual(link_map.get_links_between(2, 1), [(5, 3)])
-        self.assertCountEqual(link_map.get_links_between(1, 2), [(1, 1), (3, 3)])
-
         self.assertCountEqual(link_map.get_additions(), [(1, 3, 2, 3), (2, 5, 1, 3)])
 
+    def test_exists_path_from(self) -> None:
+        "Check that `exists_path_from` can handle non-direct links"
+        link_map = _LinkMap()
+
+        link_map.add_link((1, 1), (2, 1), new=False)
+        link_map.add_link((2, 1), (3, 1), new=False)
+
+        self.assertTrue(link_map.exists_path_from((1, 4), (3, 1)))
+        self.assertFalse(link_map.exists_path_from((1, 4), (3, 2)))
+
+        link_map.add_link((1, 5), (2, 3), new=False)
+        link_map.add_link((2, 2), (3, 3), new=False)
+
+        self.assertTrue(link_map.exists_path_from((1, 6), (3, 2)))
+        self.assertFalse(link_map.exists_path_from((1, 4), (3, 2)))
+
 
 class EventChainBackgroundUpdateTestCase(HomeserverTestCase):
     servlets = [", "url": "https://github.com/element-hq/synapse/commit/55b0aa847a61774b6a3acdc4b177a20dc019f01a.patch" } ]
CWE-770: Allocation of Resources Without Limits or Throttling
CVE-2017-13023
The IPv6 mobility parser in tcpdump before 4.9.2 has a buffer over-read in print-mobility.c:mobility_opt_print().
[ { "commit_message": "[PATCH] CVE-2017-13023/IPv6 mobility: Add a bounds check before fetching data This fixes a buffer over-read discovered by Bhargava Shastry, SecT/TU Berlin. Add a test using the capture file supplied by the reporter(s), modified so the capture file won't cause 'tcpdump: pcap_loop: truncated dump file' print-mobility.c | 1 + tests/TESTLIST | 1 + tests/mobility_opt_asan.out | 2 ++ tests/mobility_opt_asan.pcap | Bin 0 -> 256 bytes 4 files changed, 4 insertions(+) create mode 100644 tests/mobility_opt_asan.out create mode 100644 tests/mobility_opt_asan.pcap", "patch_text_b64": "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", "url": "https://github.com/the-tcpdump-group/tcpdump/commit/b8e559afaeb8fe0604a1f8e3ad4dc1445de07a00.patch" } ]
n/a
GHSA-gxqf-4g4p-q3hc
usememos/memos vulnerable to stored Cross-site Scripting
null
[ { "commit_message": "[PATCH] chore: fix XSS in renderer (#875) chore: fix xss in renderer web/src/labs/marked/index.ts | 2 +- web/src/labs/marked/parser/Bold.ts | 3 +-- web/src/labs/marked/parser/BoldEmphasis.ts | 3 +-- web/src/labs/marked/parser/Emphasis.ts | 3 +-- web/src/labs/marked/parser/Link.ts | 2 +- web/src/labs/marked/parser/Strikethrough.ts | 5 ++--- 6 files changed, 7 insertions(+), 11 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/usememos/memos/commit/64e5c343c5f74b0abdf3ac0d21a6139daea58cf8.patch" } ]
null
CVE-2025-1040
Server-Side Template Injection (SSTI) in significant-gravitas/autogpt
AutoGPT versions 0.3.4 and earlier are vulnerable to a Server-Side Template Injection (SSTI) that could lead to Remote Code Execution (RCE). The vulnerability arises from the improper handling of user-supplied format strings in the `AgentOutputBlock` implementation, where malicious input is passed to the Jinja2 templating engine without adequate security measures. Attackers can exploit this flaw to execute arbitrary commands on the host system. The issue is fixed in version 0.4.0.
[ { "commit_message": "[PATCH] fix(backend): Enable Jinja SandboxedEnvironment for TextFormatter (#8891) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We still use plain Jinja objects for text formatting in our block codes. ### Changes 🏗️ Introduced a `TextFormatter` utility class that uses jina SandboxedEnvironment for safer text formatting. ### Checklist 📋 #### For code changes: - [ ] I have clearly listed my changes in the PR description - [ ] I have made a test plan - [ ] I have tested my changes according to the test plan: <!-- Put your test plan here: --> - [ ] ... <details> <summary>Example test plan</summary> - [ ] Create from scratch and execute an agent with at least 3 blocks - [ ] Import an agent from file upload, and confirm it executes correctly - [ ] Upload agent to marketplace - [ ] Import an agent from marketplace and confirm it executes correctly - [ ] Edit an agent from monitor, and confirm it executes correctly </details> #### For configuration changes: - [ ] `.env.example` is updated or already compatible with my changes - [ ] `docker-compose.yml` is updated or already compatible with my changes - [ ] I have included a list of my configuration changes in the PR description (under **Changes**) <details> <summary>Examples of configuration changes</summary> - Changing ports - Adding new services that need to communicate with each other - Secrets or environment variable changes - New or infrastructure changes such as databases </details> .../backend/backend/blocks/basic.py | 12 +++++----- .../backend/backend/blocks/text.py | 17 +++++++------- autogpt_platform/backend/backend/util/text.py | 22 +++++++++++++++++++ 3 files changed, 35 insertions(+), 16 deletions(-) create mode 100644 autogpt_platform/backend/backend/util/text.py", "patch_text_b64": "From 6dba31e0215549604bdcc1aed24e3a1714e75ee2 Mon Sep 17 00:00:00 2001
From: Zamil Majdy <zamil.majdy@agpt.co>
Date: Fri, 6 Dec 2024 11:21:30 +0700
Subject: [PATCH] fix(backend): Enable Jinja SandboxedEnvironment for
 TextFormatter (#8891)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

We still use plain Jinja objects for text formatting in our block codes.

### Changes 🏗️

Introduced a `TextFormatter` utility class that uses jina
SandboxedEnvironment for safer text formatting.

### Checklist 📋

#### For code changes:
- [ ] I have clearly listed my changes in the PR description
- [ ] I have made a test plan
- [ ] I have tested my changes according to the test plan:
  <!-- Put your test plan here: -->
  - [ ] ...

<details>
  <summary>Example test plan</summary>

  - [ ] Create from scratch and execute an agent with at least 3 blocks
- [ ] Import an agent from file upload, and confirm it executes
correctly
  - [ ] Upload agent to marketplace
- [ ] Import an agent from marketplace and confirm it executes correctly
  - [ ] Edit an agent from monitor, and confirm it executes correctly
</details>

#### For configuration changes:
- [ ] `.env.example` is updated or already compatible with my changes
- [ ] `docker-compose.yml` is updated or already compatible with my
changes
- [ ] I have included a list of my configuration changes in the PR
description (under **Changes**)

<details>
  <summary>Examples of configuration changes</summary>

  - Changing ports
  - Adding new services that need to communicate with each other
  - Secrets or environment variable changes
  - New or infrastructure changes such as databases
</details>
---
 .../backend/backend/blocks/basic.py           | 12 +++++-----
 .../backend/backend/blocks/text.py            | 17 +++++++-------
 autogpt_platform/backend/backend/util/text.py | 22 +++++++++++++++++++
 3 files changed, 35 insertions(+), 16 deletions(-)
 create mode 100644 autogpt_platform/backend/backend/util/text.py

diff --git a/autogpt_platform/backend/backend/blocks/basic.py b/autogpt_platform/backend/backend/blocks/basic.py
index 0710565ad088..165399a907a1 100644
--- a/autogpt_platform/backend/backend/blocks/basic.py
+++ b/autogpt_platform/backend/backend/blocks/basic.py
@@ -1,13 +1,11 @@
-import re
 from typing import Any, List
 
-from jinja2 import BaseLoader, Environment
-
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
 from backend.data.model import SchemaField
 from backend.util.mock import MockObject
+from backend.util.text import TextFormatter
 
-jinja = Environment(loader=BaseLoader())
+formatter = TextFormatter()
 
 
 class StoreValueBlock(Block):
@@ -304,9 +302,9 @@ def run(self, input_data: Input, **kwargs) -> BlockOutput:
         """
         if input_data.format:
             try:
-                fmt = re.sub(r"(?<!{){[ a-zA-Z0-9_]+}", r"{\g<0>}", input_data.format)
-                template = jinja.from_string(fmt)
-                yield "output", template.render({input_data.name: input_data.value})
+                yield "output", formatter.format_string(
+                    input_data.format, {input_data.name: input_data.value}
+                )
             except Exception as e:
                 yield "output", f"Error: {e}, {input_data.value}"
         else:
diff --git a/autogpt_platform/backend/backend/blocks/text.py b/autogpt_platform/backend/backend/blocks/text.py
index 1d8c050fa147..b7b6c73fffe0 100644
--- a/autogpt_platform/backend/backend/blocks/text.py
+++ b/autogpt_platform/backend/backend/blocks/text.py
@@ -1,13 +1,11 @@
 import re
 from typing import Any
 
-from jinja2 import BaseLoader, Environment
-
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
-from backend.util import json
+from backend.util import json, text
 
-jinja = Environment(loader=BaseLoader())
+formatter = text.TextFormatter()
 
 
 class MatchTextPatternBlock(Block):
@@ -146,19 +144,20 @@ def __init__(self):
                     "values": {"list": ["Hello", " World!"]},
                     "format": "{% for item in list %}{{ item }}{% endfor %}",
                 },
+                {
+                    "values": {},
+                    "format": "{% set name = 'Alice' %}Hello, World! {{ name }}",
+                },
             ],
             test_output=[
                 ("output", "Hello, World! Alice"),
                 ("output", "Hello World!"),
+                ("output", "Hello, World! Alice"),
             ],
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        # For python.format compatibility: replace all {...} with {{..}}.
-        # But avoid replacing {{...}} to {{{...}}}.
-        fmt = re.sub(r"(?<!{){[ a-zA-Z0-9_]+}", r"{\g<0>}", input_data.format)
-        template = jinja.from_string(fmt)
-        yield "output", template.render(**input_data.values)
+        yield "output", formatter.format_string(input_data.format, input_data.values)
 
 
 class CombineTextsBlock(Block):
diff --git a/autogpt_platform/backend/backend/util/text.py b/autogpt_platform/backend/backend/util/text.py
new file mode 100644
index 000000000000..951339b55d59
--- /dev/null
+++ b/autogpt_platform/backend/backend/util/text.py
@@ -0,0 +1,22 @@
+import re
+
+from jinja2 import BaseLoader
+from jinja2.sandbox import SandboxedEnvironment
+
+
+class TextFormatter:
+    def __init__(self):
+        # Create a sandboxed environment
+        self.env = SandboxedEnvironment(loader=BaseLoader(), autoescape=True)
+
+        # Clear any registered filters, tests, and globals to minimize attack surface
+        self.env.filters.clear()
+        self.env.tests.clear()
+        self.env.globals.clear()
+
+    def format_string(self, template_str: str, values=None, **kwargs) -> str:
+        # For python.format compatibility: replace all {...} with {{..}}.
+        # But avoid replacing {{...}} to {{{...}}}.
+        template_str = re.sub(r"(?<!{){[ a-zA-Z0-9_]+}", r"{\g<0>}", template_str)
+        template = self.env.from_string(template_str)
+        return template.render(values or {}, **kwargs)", "url": "https://github.com/significant-gravitas/autogpt/commit/6dba31e0215549604bdcc1aed24e3a1714e75ee2.patch" } ]
CWE-1336 Improper Neutralization of Special Elements Used in a Template Engine
GHSA-crg2-6xv3-qg5f
Improper Neutralization of Input During Web Page Generation in Jenkins
null
[ { "commit_message": "[PATCH] [SECURITY-1793] .../java/hudson/model/FileParameterValue.java | 8 ++++ .../FileParameterValueSecurity1793Test.java | 47 +++++++++++++++++++ .../jobs/SECURITY-1793/builds/4/build.xml | 41 ++++++++++++++++ .../jobs/SECURITY-1793/builds/4/changelog.xml | 1 + .../builds/4/fileParameters/html.html | 7 +++ .../jobs/SECURITY-1793/builds/4/log | 3 ++ .../jobs/SECURITY-1793/config.xml | 25 ++++++++++ 7 files changed, 132 insertions(+) create mode 100644 test/src/test/java/hudson/model/FileParameterValueSecurity1793Test.java create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/build.xml create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/changelog.xml create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/fileParameters/html.html create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/log create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/config.xml", "patch_text_b64": "From c2d22b241eba718c62996e2ceeb5f2e0e9787f81 Mon Sep 17 00:00:00 2001
From: Daniel Beck <daniel-beck@users.noreply.github.com>
Date: Wed, 11 Mar 2020 08:11:03 +0100
Subject: [PATCH] [SECURITY-1793]

---
 .../java/hudson/model/FileParameterValue.java |  8 ++++
 .../FileParameterValueSecurity1793Test.java   | 47 +++++++++++++++++++
 .../jobs/SECURITY-1793/builds/4/build.xml     | 41 ++++++++++++++++
 .../jobs/SECURITY-1793/builds/4/changelog.xml |  1 +
 .../builds/4/fileParameters/html.html         |  7 +++
 .../jobs/SECURITY-1793/builds/4/log           |  3 ++
 .../jobs/SECURITY-1793/config.xml             | 25 ++++++++++
 7 files changed, 132 insertions(+)
 create mode 100644 test/src/test/java/hudson/model/FileParameterValueSecurity1793Test.java
 create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/build.xml
 create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/changelog.xml
 create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/fileParameters/html.html
 create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/log
 create mode 100644 test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/config.xml

diff --git a/core/src/main/java/hudson/model/FileParameterValue.java b/core/src/main/java/hudson/model/FileParameterValue.java
index 33336cd6b2f3..02d7c25a6f4c 100644
--- a/core/src/main/java/hudson/model/FileParameterValue.java
+++ b/core/src/main/java/hudson/model/FileParameterValue.java
@@ -40,6 +40,7 @@
 import java.util.regex.Pattern;
 import javax.servlet.ServletException;
 
+import jenkins.util.SystemProperties;
 import org.apache.commons.fileupload.FileItem;
 import org.apache.commons.fileupload.FileItemHeaders;
 import org.apache.commons.fileupload.disk.DiskFileItem;
@@ -250,6 +251,13 @@ public void doDynamic(StaplerRequest request, StaplerResponse response) throws S
                     if (request.hasParameter("view")) {
                         response.serveFile(request, data, lastModified, contentLength, "plain.txt");
                     } else {
+                        String csp = SystemProperties.getString(DirectoryBrowserSupport.class.getName() + ".CSP", DirectoryBrowserSupport.DEFAULT_CSP_VALUE);
+                        if (!csp.trim().equals("")) {
+                            // allow users to prevent sending this header by setting empty system property
+                            for (String header : new String[]{"Content-Security-Policy", "X-WebKit-CSP", "X-Content-Security-Policy"}) {
+                                response.setHeader(header, csp);
+                            }
+                        }
                         response.serveFile(request, data, lastModified, contentLength, originalFileName);
                     }
                 } catch (InvalidPathException e) {
diff --git a/test/src/test/java/hudson/model/FileParameterValueSecurity1793Test.java b/test/src/test/java/hudson/model/FileParameterValueSecurity1793Test.java
new file mode 100644
index 000000000000..d1719a3d990c
--- /dev/null
+++ b/test/src/test/java/hudson/model/FileParameterValueSecurity1793Test.java
@@ -0,0 +1,47 @@
+package hudson.model;
+
+import com.gargoylesoftware.htmlunit.html.HtmlPage;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.jvnet.hudson.test.Issue;
+import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.recipes.LocalData;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class FileParameterValueSecurity1793Test {
+
+    @Rule
+    public JenkinsRule j = new JenkinsRule();
+
+    @Issue("SECURITY-1793")
+    @Test
+    @LocalData
+    public void contentSecurityPolicy() throws Exception {
+        FreeStyleProject p = j.jenkins.getItemByFullName("SECURITY-1793", FreeStyleProject.class);
+
+        HtmlPage page = j.createWebClient().goTo("job/" + p.getName() + "/lastSuccessfulBuild/parameters/parameter/html.html/html.html");
+        for (String header : new String[]{"Content-Security-Policy", "X-WebKit-CSP", "X-Content-Security-Policy"}) {
+            assertEquals("Header set: " + header, DirectoryBrowserSupport.DEFAULT_CSP_VALUE, page.getWebResponse().getResponseHeaderValue(header));
+        }
+
+        String propName = DirectoryBrowserSupport.class.getName() + ".CSP";
+        String initialValue = System.getProperty(propName);
+        try {
+            System.setProperty(propName, "");
+            page = j.createWebClient().goTo("job/" + p.getName() + "/lastSuccessfulBuild/parameters/parameter/html.html/html.html");
+            for (String header : new String[]{"Content-Security-Policy", "X-WebKit-CSP", "X-Content-Security-Policy"}) {
+                assertFalse("Header not set: " + header, page.getWebResponse().getResponseHeaders().contains(header));
+            }
+        } finally {
+            if (initialValue == null) {
+                System.clearProperty(DirectoryBrowserSupport.class.getName() + ".CSP");
+            } else {
+                System.setProperty(DirectoryBrowserSupport.class.getName() + ".CSP", initialValue);
+            }
+        }
+    }
+
+}
diff --git a/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/build.xml b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/build.xml
new file mode 100644
index 000000000000..002220e90bd0
--- /dev/null
+++ b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/build.xml
@@ -0,0 +1,41 @@
+<?xml version='1.1' encoding='UTF-8'?>
+<build>
+  <actions>
+    <hudson.model.ParametersAction>
+      <safeParameters class="sorted-set"/>
+      <parameters>
+        <hudson.model.FileParameterValue>
+          <name>html.html</name>
+          <description></description>
+          <originalFileName>html.html</originalFileName>
+          <location>html.html</location>
+        </hudson.model.FileParameterValue>
+      </parameters>
+      <parameterDefinitionNames>
+        <string>html.html</string>
+      </parameterDefinitionNames>
+    </hudson.model.ParametersAction>
+    <hudson.model.CauseAction>
+      <causeBag class="linked-hash-map">
+        <entry>
+          <hudson.model.Cause_-UserIdCause>
+            <userId>admin</userId>
+          </hudson.model.Cause_-UserIdCause>
+          <int>1</int>
+        </entry>
+      </causeBag>
+    </hudson.model.CauseAction>
+  </actions>
+  <queueId>28</queueId>
+  <timestamp>1582828801817</timestamp>
+  <startTime>1582828801820</startTime>
+  <result>SUCCESS</result>
+  <duration>34</duration>
+  <charset>US-ASCII</charset>
+  <keepLog>false</keepLog>
+  <builtOn></builtOn>
+  <workspace>/.../SECURITY-1793</workspace>
+  <hudsonVersion>2.164.4-SNAPSHOT</hudsonVersion>
+  <scm class="hudson.scm.NullChangeLogParser"/>
+  <culprits class="com.google.common.collect.EmptyImmutableSortedSet"/>
+</build>
\ No newline at end of file
diff --git a/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/changelog.xml b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/changelog.xml
new file mode 100644
index 000000000000..a89119166a47
--- /dev/null
+++ b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/changelog.xml
@@ -0,0 +1 @@
+<log/>
\ No newline at end of file
diff --git a/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/fileParameters/html.html b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/fileParameters/html.html
new file mode 100644
index 000000000000..887693d9bd1e
--- /dev/null
+++ b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/fileParameters/html.html
@@ -0,0 +1,7 @@
+<html>
+<body>
+<script>
+alert(1);
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/log b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/log
new file mode 100644
index 000000000000..85002ac9a1b4
--- /dev/null
+++ b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/builds/4/log
@@ -0,0 +1,3 @@
+Building in workspace /.../SECURITY-1793
+Copying file to html.html
+Finished: SUCCESS
diff --git a/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/config.xml b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/config.xml
new file mode 100644
index 000000000000..268f58daf866
--- /dev/null
+++ b/test/src/test/resources/hudson/model/FileParameterValueSecurity1793Test/contentSecurityPolicy/jobs/SECURITY-1793/config.xml
@@ -0,0 +1,25 @@
+<?xml version='1.1' encoding='UTF-8'?>
+<project>
+  <description></description>
+  <keepDependencies>false</keepDependencies>
+  <properties>
+    <hudson.model.ParametersDefinitionProperty>
+      <parameterDefinitions>
+        <hudson.model.FileParameterDefinition>
+          <name>html.html</name>
+          <description></description>
+        </hudson.model.FileParameterDefinition>
+      </parameterDefinitions>
+    </hudson.model.ParametersDefinitionProperty>
+  </properties>
+  <scm class="hudson.scm.NullSCM"/>
+  <canRoam>true</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+  <triggers/>
+  <concurrentBuild>false</concurrentBuild>
+  <builders/>
+  <publishers/>
+  <buildWrappers/>
+</project>
\ No newline at end of file", "url": "https://github.com/jenkinsci/jenkins/commit/c2d22b241eba718c62996e2ceeb5f2e0e9787f81.patch" } ]
null
CVE-2022-29186
Use of Hard-coded Cryptographic Key in rundeck/rundeck, rundeckpro/enterprise
Rundeck is an open source automation service with a web console, command line tools and a WebAPI. Rundeck community and rundeck-enterprise docker images contained a pre-generated SSH keypair. If the id_rsa.pub public key of the keypair was copied to authorized_keys files on remote host, those hosts would allow access to anyone with the exposed private credentials. This misconfiguration only impacts Rundeck Docker instances of PagerDuty® Process Automation On Prem (formerly Rundeck) version 4.0 and earlier, not Debian, RPM or .WAR. Additionally, the id_rsa.pub file would have to be copied from the Docker image filesystem contents without overwriting it and used to configure SSH access on a host. A patch on Rundeck's `main` branch has removed the pre-generated SSH key pair, but it does not remove exposed keys that have been configured. To patch, users must run a script on hosts in their environment to search for exposed keys and rotate them. Two workarounds are available: Do not use any pre-existing public key file from the rundeck docker images to allow SSH access by adding it to authorized_keys files and, if you have copied the public key file included in the docker image, remove it from any authorized_keys files.
[ { "commit_message": "[PATCH 1/2] Remove ssh-keygen from dockerfile docker/ubuntu-base/Dockerfile | 1 - 1 file changed, 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/rundeck/rundeck/commit/16ef7a70b202492f9fbb54d8af4bb8ea0afa10ad.patch" } ]
CWE-321: Use of Hard-coded Cryptographic Key
GHSA-hcg3-q754-cr77
golang.org/x/crypto Vulnerable to Denial of Service (DoS) via Slow or Incomplete Key Exchange
null
[ { "commit_message": "[PATCH] ssh: limit the size of the internal packet queue while waiting for KEX In the SSH protocol, clients and servers execute the key exchange to generate one-time session keys used for encryption and authentication. The key exchange is performed initially after the connection is established and then periodically after a configurable amount of data. While a key exchange is in progress, we add the received packets to an internal queue until we receive SSH_MSG_KEXINIT from the other side. This can result in high memory usage if the other party is slow to respond to the SSH_MSG_KEXINIT packet, or memory exhaustion if a malicious client never responds to an SSH_MSG_KEXINIT packet during a large file transfer. We now limit the internal queue to 64 packets: this means 2MB with the typical 32KB packet size. When the internal queue is full we block further writes until the pending key exchange is completed or there is a read or write error. Thanks to Yuichi Watanabe for reporting this issue. Change-Id: I1ce2214cc16e08b838d4bc346c74c72addafaeec Reviewed-on: https://go-review.googlesource.com/c/crypto/+/652135 Reviewed-by: Neal Patel <nealpatel@google.com> Auto-Submit: Gopher Robot <gobot@golang.org> Reviewed-by: Roland Shoemaker <roland@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> ssh/handshake.go | 47 +++++++-- ssh/handshake_test.go | 220 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 257 insertions(+), 10 deletions(-)", "patch_text_b64": "From 7292932d45d55c7199324ab0027cc86e8198aa22 Mon Sep 17 00:00:00 2001
From: Nicola Murino <nicola.murino@gmail.com>
Date: Sun, 15 Dec 2024 18:08:57 +0100
Subject: [PATCH] ssh: limit the size of the internal packet queue while
 waiting for KEX

In the SSH protocol, clients and servers execute the key exchange to
generate one-time session keys used for encryption and authentication.
The key exchange is performed initially after the connection is
established and then periodically after a configurable amount of data.
While a key exchange is in progress, we add the received packets to an
internal queue until we receive SSH_MSG_KEXINIT from the other side.
This can result in high memory usage if the other party is slow to
respond to the SSH_MSG_KEXINIT packet, or memory exhaustion if a
malicious client never responds to an SSH_MSG_KEXINIT packet during a
large file transfer.
We now limit the internal queue to 64 packets: this means 2MB with the
typical 32KB packet size.
When the internal queue is full we block further writes until the
pending key exchange is completed or there is a read or write error.

Thanks to Yuichi Watanabe for reporting this issue.

Change-Id: I1ce2214cc16e08b838d4bc346c74c72addafaeec
Reviewed-on: https://go-review.googlesource.com/c/crypto/+/652135
Reviewed-by: Neal Patel <nealpatel@google.com>
Auto-Submit: Gopher Robot <gobot@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
---
 ssh/handshake.go      |  47 +++++++--
 ssh/handshake_test.go | 220 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 257 insertions(+), 10 deletions(-)

diff --git a/ssh/handshake.go b/ssh/handshake.go
index fef687db0e..c9202b05da 100644
--- a/ssh/handshake.go
+++ b/ssh/handshake.go
@@ -25,6 +25,11 @@ const debugHandshake = false
 // quickly.
 const chanSize = 16
 
+// maxPendingPackets sets the maximum number of packets to queue while waiting
+// for KEX to complete. This limits the total pending data to maxPendingPackets
+// * maxPacket bytes, which is ~16.8MB.
+const maxPendingPackets = 64
+
 // keyingTransport is a packet based transport that supports key
 // changes. It need not be thread-safe. It should pass through
 // msgNewKeys in both directions.
@@ -73,11 +78,19 @@ type handshakeTransport struct {
 	incoming  chan []byte
 	readError error
 
-	mu               sync.Mutex
-	writeError       error
-	sentInitPacket   []byte
-	sentInitMsg      *kexInitMsg
-	pendingPackets   [][]byte // Used when a key exchange is in progress.
+	mu sync.Mutex
+	// Condition for the above mutex. It is used to notify a completed key
+	// exchange or a write failure. Writes can wait for this condition while a
+	// key exchange is in progress.
+	writeCond      *sync.Cond
+	writeError     error
+	sentInitPacket []byte
+	sentInitMsg    *kexInitMsg
+	// Used to queue writes when a key exchange is in progress. The length is
+	// limited by pendingPacketsSize. Once full, writes will block until the key
+	// exchange is completed or an error occurs. If not empty, it is emptied
+	// all at once when the key exchange is completed in kexLoop.
+	pendingPackets   [][]byte
 	writePacketsLeft uint32
 	writeBytesLeft   int64
 	userAuthComplete bool // whether the user authentication phase is complete
@@ -134,6 +147,7 @@ func newHandshakeTransport(conn keyingTransport, config *Config, clientVersion,
 
 		config: config,
 	}
+	t.writeCond = sync.NewCond(&t.mu)
 	t.resetReadThresholds()
 	t.resetWriteThresholds()
 
@@ -260,6 +274,7 @@ func (t *handshakeTransport) recordWriteError(err error) {
 	defer t.mu.Unlock()
 	if t.writeError == nil && err != nil {
 		t.writeError = err
+		t.writeCond.Broadcast()
 	}
 }
 
@@ -363,6 +378,8 @@ write:
 			}
 		}
 		t.pendingPackets = t.pendingPackets[:0]
+		// Unblock writePacket if waiting for KEX.
+		t.writeCond.Broadcast()
 		t.mu.Unlock()
 	}
 
@@ -577,11 +594,20 @@ func (t *handshakeTransport) writePacket(p []byte) error {
 	}
 
 	if t.sentInitMsg != nil {
-		// Copy the packet so the writer can reuse the buffer.
-		cp := make([]byte, len(p))
-		copy(cp, p)
-		t.pendingPackets = append(t.pendingPackets, cp)
-		return nil
+		if len(t.pendingPackets) < maxPendingPackets {
+			// Copy the packet so the writer can reuse the buffer.
+			cp := make([]byte, len(p))
+			copy(cp, p)
+			t.pendingPackets = append(t.pendingPackets, cp)
+			return nil
+		}
+		for t.sentInitMsg != nil {
+			// Block and wait for KEX to complete or an error.
+			t.writeCond.Wait()
+			if t.writeError != nil {
+				return t.writeError
+			}
+		}
 	}
 
 	if t.writeBytesLeft > 0 {
@@ -598,6 +624,7 @@ func (t *handshakeTransport) writePacket(p []byte) error {
 
 	if err := t.pushPacket(p); err != nil {
 		t.writeError = err
+		t.writeCond.Broadcast()
 	}
 
 	return nil
diff --git a/ssh/handshake_test.go b/ssh/handshake_test.go
index 2bc607b649..019e47fa05 100644
--- a/ssh/handshake_test.go
+++ b/ssh/handshake_test.go
@@ -539,6 +539,226 @@ func TestDisconnect(t *testing.T) {
 	}
 }
 
+type mockKeyingTransport struct {
+	packetConn
+	kexInitAllowed chan struct{}
+	kexInitSent    chan struct{}
+}
+
+func (n *mockKeyingTransport) prepareKeyChange(*algorithms, *kexResult) error {
+	return nil
+}
+
+func (n *mockKeyingTransport) writePacket(packet []byte) error {
+	if packet[0] == msgKexInit {
+		<-n.kexInitAllowed
+		n.kexInitSent <- struct{}{}
+	}
+	return n.packetConn.writePacket(packet)
+}
+
+func (n *mockKeyingTransport) readPacket() ([]byte, error) {
+	return n.packetConn.readPacket()
+}
+
+func (n *mockKeyingTransport) setStrictMode() error { return nil }
+
+func (n *mockKeyingTransport) setInitialKEXDone() {}
+
+func TestHandshakePendingPacketsWait(t *testing.T) {
+	a, b := memPipe()
+
+	trS := &mockKeyingTransport{
+		packetConn:     a,
+		kexInitAllowed: make(chan struct{}, 2),
+		kexInitSent:    make(chan struct{}, 2),
+	}
+	// Allow the first KEX.
+	trS.kexInitAllowed <- struct{}{}
+
+	trC := &mockKeyingTransport{
+		packetConn:     b,
+		kexInitAllowed: make(chan struct{}, 2),
+		kexInitSent:    make(chan struct{}, 2),
+	}
+	// Allow the first KEX.
+	trC.kexInitAllowed <- struct{}{}
+
+	clientConf := &ClientConfig{
+		HostKeyCallback: InsecureIgnoreHostKey(),
+	}
+	clientConf.SetDefaults()
+
+	v := []byte("version")
+	client := newClientTransport(trC, v, v, clientConf, "addr", nil)
+
+	serverConf := &ServerConfig{}
+	serverConf.AddHostKey(testSigners["ecdsa"])
+	serverConf.AddHostKey(testSigners["rsa"])
+	serverConf.SetDefaults()
+	server := newServerTransport(trS, v, v, serverConf)
+
+	if err := server.waitSession(); err != nil {
+		t.Fatalf("server.waitSession: %v", err)
+	}
+	if err := client.waitSession(); err != nil {
+		t.Fatalf("client.waitSession: %v", err)
+	}
+
+	<-trC.kexInitSent
+	<-trS.kexInitSent
+
+	// Allow and request new KEX server side.
+	trS.kexInitAllowed <- struct{}{}
+	server.requestKeyExchange()
+	// Wait until the KEX init is sent.
+	<-trS.kexInitSent
+	// The client is not allowed to respond to the KEX, so writes will be
+	// blocked on the server side once the packets queue is full.
+	for i := 0; i < maxPendingPackets; i++ {
+		p := []byte{msgRequestSuccess, byte(i)}
+		if err := server.writePacket(p); err != nil {
+			t.Errorf("unexpected write error: %v", err)
+		}
+	}
+	// The packets queue is now full, the next write will block.
+	server.mu.Lock()
+	if len(server.pendingPackets) != maxPendingPackets {
+		t.Errorf("unexpected pending packets size; got: %d, want: %d", len(server.pendingPackets), maxPendingPackets)
+	}
+	server.mu.Unlock()
+
+	writeDone := make(chan struct{})
+	go func() {
+		defer close(writeDone)
+
+		p := []byte{msgRequestSuccess, byte(65)}
+		// This write will block until KEX completes.
+		err := server.writePacket(p)
+		if err != nil {
+			t.Errorf("unexpected write error: %v", err)
+		}
+	}()
+
+	// Consume packets on the client side
+	readDone := make(chan bool)
+	go func() {
+		defer close(readDone)
+
+		for {
+			if _, err := client.readPacket(); err != nil {
+				if err != io.EOF {
+					t.Errorf("unexpected read error: %v", err)
+				}
+				break
+			}
+		}
+	}()
+
+	// Allow the client to reply to the KEX and so unblock the write goroutine.
+	trC.kexInitAllowed <- struct{}{}
+	<-trC.kexInitSent
+	<-writeDone
+	// Close the client to unblock the read goroutine.
+	client.Close()
+	<-readDone
+	server.Close()
+}
+
+func TestHandshakePendingPacketsError(t *testing.T) {
+	a, b := memPipe()
+
+	trS := &mockKeyingTransport{
+		packetConn:     a,
+		kexInitAllowed: make(chan struct{}, 2),
+		kexInitSent:    make(chan struct{}, 2),
+	}
+	// Allow the first KEX.
+	trS.kexInitAllowed <- struct{}{}
+
+	trC := &mockKeyingTransport{
+		packetConn:     b,
+		kexInitAllowed: make(chan struct{}, 2),
+		kexInitSent:    make(chan struct{}, 2),
+	}
+	// Allow the first KEX.
+	trC.kexInitAllowed <- struct{}{}
+
+	clientConf := &ClientConfig{
+		HostKeyCallback: InsecureIgnoreHostKey(),
+	}
+	clientConf.SetDefaults()
+
+	v := []byte("version")
+	client := newClientTransport(trC, v, v, clientConf, "addr", nil)
+
+	serverConf := &ServerConfig{}
+	serverConf.AddHostKey(testSigners["ecdsa"])
+	serverConf.AddHostKey(testSigners["rsa"])
+	serverConf.SetDefaults()
+	server := newServerTransport(trS, v, v, serverConf)
+
+	if err := server.waitSession(); err != nil {
+		t.Fatalf("server.waitSession: %v", err)
+	}
+	if err := client.waitSession(); err != nil {
+		t.Fatalf("client.waitSession: %v", err)
+	}
+
+	<-trC.kexInitSent
+	<-trS.kexInitSent
+
+	// Allow and request new KEX server side.
+	trS.kexInitAllowed <- struct{}{}
+	server.requestKeyExchange()
+	// Wait until the KEX init is sent.
+	<-trS.kexInitSent
+	// The client is not allowed to respond to the KEX, so writes will be
+	// blocked on the server side once the packets queue is full.
+	for i := 0; i < maxPendingPackets; i++ {
+		p := []byte{msgRequestSuccess, byte(i)}
+		if err := server.writePacket(p); err != nil {
+			t.Errorf("unexpected write error: %v", err)
+		}
+	}
+	// The packets queue is now full, the next write will block.
+	writeDone := make(chan struct{})
+	go func() {
+		defer close(writeDone)
+
+		p := []byte{msgRequestSuccess, byte(65)}
+		// This write will block until KEX completes.
+		err := server.writePacket(p)
+		if err != io.EOF {
+			t.Errorf("unexpected write error: %v", err)
+		}
+	}()
+
+	// Consume packets on the client side
+	readDone := make(chan bool)
+	go func() {
+		defer close(readDone)
+
+		for {
+			if _, err := client.readPacket(); err != nil {
+				if err != io.EOF {
+					t.Errorf("unexpected read error: %v", err)
+				}
+				break
+			}
+		}
+	}()
+
+	// Close the server to unblock the write after an error
+	server.Close()
+	<-writeDone
+	// Unblock the pending write and close the client to unblock the read
+	// goroutine.
+	trC.kexInitAllowed <- struct{}{}
+	client.Close()
+	<-readDone
+}
+
 func TestHandshakeRekeyDefault(t *testing.T) {
 	clientConf := &ClientConfig{
 		Config: Config{", "url": "https://github.com/golang/crypto/commit/7292932d45d55c7199324ab0027cc86e8198aa22.patch" } ]
null
GHSA-gcff-f9p7-hmfg
null
[ { "commit_message": "[PATCH] net_sched: cls_route: remove the right filter from hashtable route4_change() allocates a new filter and copies values from the old one. After the new filter is inserted into the hash table, the old filter should be removed and freed, as the final step of the update. However, the current code mistakenly removes the new one. This looks apparently wrong to me, and it causes double \"free\" and use-after-free too, as reported by syzbot. Reported-and-tested-by: syzbot+f9b32aaacd60305d9687@syzkaller.appspotmail.com Reported-and-tested-by: syzbot+2f8c233f131943d6056d@syzkaller.appspotmail.com Reported-and-tested-by: syzbot+9c2df9fd5e9445b74e01@syzkaller.appspotmail.com Fixes: 1109c00547fc (\"net: sched: RCU cls_route\") Cc: Jamal Hadi Salim <jhs@mojatatu.com> Cc: Jiri Pirko <jiri@resnulli.us> Cc: John Fastabend <john.fastabend@gmail.com> Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com> Signed-off-by: David S. Miller <davem@davemloft.net> net/sched/cls_route.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/torvalds/linux/commit/ef299cc3fa1a9e1288665a9fdc8bff55629fd359.patch" } ]
null
GHSA-5923-r76v-mprm
Open Redirect Vulnerability in Taguette
null
[ { "commit_message": "[PATCH] Validate 'next' URL from login and cookies prompt taguette/web/base.py | 14 ++++++++++++++ taguette/web/views.py | 8 ++------ tests.py | 35 +++++++++++++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 6 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/remram44/taguette/commit/67de2d2612e7e2572c61cd9627f89c2bfd0f2a36.patch" } ]
null
GHSA-vhrg-v3cv-p247
Deserialization of Untrusted Data in Spring Security
null
[ { "commit_message": "[PATCH] Fix #1599 for 2.7(.10) release-notes/VERSION | 2 + .../deser/BeanDeserializerFactory.java | 23 +++++++++++ .../interop/IllegalTypesCheckTest.java | 40 +++++++++++++++++++ 3 files changed, 65 insertions(+) create mode 100644 src/test/java/com/fasterxml/jackson/databind/interop/IllegalTypesCheckTest.java", "patch_text_b64": "RnJvbSA2Y2UzMmZmZDE4ZmFjYWM2YWJkYmJmNTU5YzgxN2I0N2ZjYjYyMmMxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUYXR1IFNhbG9yYW50YSA8dGF0dS5zYWxvcmFudGFAaWtpLmZpPgpEYXRlOiBUaHUsIDEzIEFwciAyMDE3IDE1OjA4OjEwIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gRml4ICMxNTk5IGZvciAyLjcoLjEwKQoKLS0tCiByZWxlYXNlLW5vdGVzL1ZFUlNJT04gICAgICAgICAgICAgICAgICAgICAgICAgfCAgMiArCiAuLi4vZGVzZXIvQmVhbkRlc2VyaWFsaXplckZhY3RvcnkuamF2YSAgICAgICAgfCAyMyArKysrKysrKysrKwogLi4uL2ludGVyb3AvSWxsZWdhbFR5cGVzQ2hlY2tUZXN0LmphdmEgICAgICAgIHwgNDAgKysrKysrKysrKysrKysrKysrKwogMyBmaWxlcyBjaGFuZ2VkLCA2NSBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvamF2YS9jb20vZmFzdGVyeG1sL2phY2tzb24vZGF0YWJpbmQvaW50ZXJvcC9JbGxlZ2FsVHlwZXNDaGVja1Rlc3QuamF2YQoKZGlmZiAtLWdpdCBhL3JlbGVhc2Utbm90ZXMvVkVSU0lPTiBiL3JlbGVhc2Utbm90ZXMvVkVSU0lPTgppbmRleCA1NzNlNzEwNzg2Li42MmY3NDY1MGRiIDEwMDY0NAotLS0gYS9yZWxlYXNlLW5vdGVzL1ZFUlNJT04KKysrIGIvcmVsZWFzZS1ub3Rlcy9WRVJTSU9OCkBAIC02LDYgKzYsOCBAQCBQcm9qZWN0OiBqYWNrc29uLWRhdGFiaW5kCiAKIDIuNy4xMCAobm90IHlldCByZWxlYXNlZCkKIAorIzE1OTk6IEphY2tzb24gRGVzZXJpYWxpemVyIHNlY3VyaXR5IHZ1bG5lcmFiaWxpdHkKKyAocmVwb3J0ZWQgYnkgYXlvdW5kQGdpdGh1YikKIC0gTWlub3Igcm9idXN0aWZpY2F0aW9uIG9mIG1ldGhvZCByZXNvbHV0aW9uIGluIGBBbm5vdGF0ZWRDbGFzc2AKIAogMi43LjkgKDA0LUZlYi0yMDE3KQpkaWZmIC0tZ2l0IGEvc3JjL21haW4vamF2YS9jb20vZmFzdGVyeG1sL2phY2tzb24vZGF0YWJpbmQvZGVzZXIvQmVhbkRlc2VyaWFsaXplckZhY3RvcnkuamF2YSBiL3NyYy9tYWluL2phdmEvY29tL2Zhc3RlcnhtbC9qYWNrc29uL2RhdGFiaW5kL2Rlc2VyL0JlYW5EZXNlcmlhbGl6ZXJGYWN0b3J5LmphdmEKaW5kZXggOWZjYjY4YjRmNi4uYWQzN2RkMTcwMCAxMDA2NDQKLS0tIGEvc3JjL21haW4vamF2YS9jb20vZmFzdGVyeG1sL2phY2tzb24vZGF0YWJpbmQvZGVzZXIvQmVhbkRlc2VyaWFsaXplckZhY3RvcnkuamF2YQorKysgYi9zcmMvbWFpbi9qYXZhL2NvbS9mYXN0ZXJ4bWwvamFja3Nvbi9kYXRhYmluZC9kZXNlci9CZWFuRGVzZXJpYWxpemVyRmFjdG9yeS5qYXZhCkBAIC0xMzksNiArMTM5LDggQEAgcHVibGljIEpzb25EZXNlcmlhbGl6ZXI8T2JqZWN0PiBjcmVhdGVCZWFuRGVzZXJpYWxpemVyKERlc2VyaWFsaXphdGlvbkNvbnRleHQgY3QKICAgICAgICAgaWYgKCFpc1BvdGVudGlhbEJlYW5UeXBlKHR5cGUuZ2V0UmF3Q2xhc3MoKSkpIHsKICAgICAgICAgICAgIHJldHVybiBudWxsOwogICAgICAgICB9CisgICAgICAgIC8vIEZvciBjaGVja3MgbGlrZSBbZGF0YWJpbmQjMTU5OV0KKyAgICAgICAgY2hlY2tJbGxlZ2FsVHlwZXMoY3R4dCwgdHlwZSwgYmVhbkRlc2MpOwogICAgICAgICAvLyBVc2UgZ2VuZXJpYyBiZWFuIGludHJvc3BlY3Rpb24gdG8gYnVpbGQgZGVzZXJpYWxpemVyCiAgICAgICAgIHJldHVybiBidWlsZEJlYW5EZXNlcmlhbGl6ZXIoY3R4dCwgdHlwZSwgYmVhbkRlc2MpOwogICAgIH0KQEAgLTgzNCw0ICs4MzYsMjUgQEAgcHJvdGVjdGVkIGJvb2xlYW4gaXNJZ25vcmFibGVUeXBlKERlc2VyaWFsaXphdGlvbkNvbmZpZyBjb25maWcsIEJlYW5EZXNjcmlwdGlvbgogICAgICAgICAvLyBXZSBkZWZhdWx0IHRvICdmYWxzZScsIGkuZS4gbm90IGlnbm9yYWJsZQogICAgICAgICByZXR1cm4gKHN0YXR1cyA9PSBudWxsKSA/IGZhbHNlIDogc3RhdHVzLmJvb2xlYW5WYWx1ZSgpOyAKICAgICB9CisKKyAgICAvKioKKyAgICAgKiBAc2luY2UgMi44LjkKKyAgICAgKi8KKyAgICBwcm90ZWN0ZWQgdm9pZCBjaGVja0lsbGVnYWxUeXBlcyhEZXNlcmlhbGl6YXRpb25Db250ZXh0IGN0eHQsIEphdmFUeXBlIHR5cGUsCisgICAgICAgICAgICBCZWFuRGVzY3JpcHRpb24gYmVhbkRlc2MpCisgICAgICAgIHRocm93cyBKc29uTWFwcGluZ0V4Y2VwdGlvbgorICAgIHsKKyAgICAgICAgLy8gVGhlcmUgYXJlIGNlcnRhaW4gbmFzdHkgY2xhc3NlcyB0aGF0IGNvdWxkIGNhdXNlIHByb2JsZW1zLCBtb3N0bHkKKyAgICAgICAgLy8gdmlhIGRlZmF1bHQgdHlwaW5nIC0tIGNhdGNoIHRoZW0gaGVyZS4KKyAgICAgICAgQ2xhc3M8Pz4gcmF3ID0gdHlwZS5nZXRSYXdDbGFzcygpOworICAgICAgICBTdHJpbmcgbmFtZSA9IHJhdy5nZXRTaW1wbGVOYW1lKCk7CisKKyAgICAgICAgaWYgKCJUZW1wbGF0ZXNJbXBsIi5lcXVhbHMobmFtZSkpIHsgLy8gW2RhdGFiaW5kIzE1OTldIAorICAgICAgICAgICAgaWYgKHJhdy5nZXROYW1lKCkuc3RhcnRzV2l0aCgiY29tLnN1bi5vcmcuYXBhY2hlLnhhbGFuIikpIHsKKyAgICAgICAgICAgICAgICB0aHJvdyBKc29uTWFwcGluZ0V4Y2VwdGlvbi5mcm9tKGN0eHQsCisgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcuZm9ybWF0KCJJbGxlZ2FsIHR5cGUgKCVzKSB0byBkZXNlcmlhbGl6ZTogcHJldmVudGVkIGZvciBzZWN1cml0eSByZWFzb25zIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbmFtZSkpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQogfQpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvamF2YS9jb20vZmFzdGVyeG1sL2phY2tzb24vZGF0YWJpbmQvaW50ZXJvcC9JbGxlZ2FsVHlwZXNDaGVja1Rlc3QuamF2YSBiL3NyYy90ZXN0L2phdmEvY29tL2Zhc3RlcnhtbC9qYWNrc29uL2RhdGFiaW5kL2ludGVyb3AvSWxsZWdhbFR5cGVzQ2hlY2tUZXN0LmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uMTkwNmVhZGI2YQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L2phdmEvY29tL2Zhc3RlcnhtbC9qYWNrc29uL2RhdGFiaW5kL2ludGVyb3AvSWxsZWdhbFR5cGVzQ2hlY2tUZXN0LmphdmEKQEAgLTAsMCArMSw0MCBAQAorcGFja2FnZSBjb20uZmFzdGVyeG1sLmphY2tzb24uZGF0YWJpbmQuaW50ZXJvcDsKKworaW1wb3J0IGNvbS5mYXN0ZXJ4bWwuamFja3Nvbi5kYXRhYmluZC4qOworCisvKioKKyAqIFRlc3QgY2FzZShzKSB0byBndWFyZCBhZ2FpbnN0IGhhbmRsaW5nIG9mIHR5cGVzIHRoYXQgYXJlIGlsbGVnYWwgdG8gaGFuZGxlCisgKiBkdWUgdG8gc2VjdXJpdHkgY29uc3RyYWludHMuCisgKi8KK3B1YmxpYyBjbGFzcyBJbGxlZ2FsVHlwZXNDaGVja1Rlc3QgZXh0ZW5kcyBCYXNlTWFwVGVzdAoreworICAgIHN0YXRpYyBjbGFzcyBCZWFuMTU5OSB7CisgICAgICAgIHB1YmxpYyBpbnQgaWQ7CisgICAgICAgIHB1YmxpYyBPYmplY3Qgb2JqOworICAgIH0KKyAgICAKKyAgICBwdWJsaWMgdm9pZCB0ZXN0SXNzdWUxNTk5KCkgdGhyb3dzIEV4Y2VwdGlvbgorICAgIHsKKyAgICAgICAgZmluYWwgU3RyaW5nIEpTT04gPSBhcG9zVG9RdW90ZXMoCisgInsnaWQnOiAxMjQsXG4iCisrIiAnb2JqJzpbICdjb20uc3VuLm9yZy5hcGFjaGUueGFsYW4uaW50ZXJuYWwueHNsdGMudHJheC5UZW1wbGF0ZXNJbXBsJyxcbiIKKysiICB7XG4iCisrIiAgICAndHJhbnNsZXRCeXRlY29kZXMnIDogWyAnQUFJQVpRPT0nIF0sXG4iCisrIiAgICAndHJhbnNsZXROYW1lJyA6ICdhLmInLFxuIgorKyIgICAgJ291dHB1dFByb3BlcnRpZXMnIDogeyB9XG4iCisrIiAgfVxuIgorKyIgXVxuIgorKyJ9IgorICAgICAgICApOworICAgICAgICBPYmplY3RNYXBwZXIgbWFwcGVyID0gbmV3IE9iamVjdE1hcHBlcigpOworICAgICAgICBtYXBwZXIuZW5hYmxlRGVmYXVsdFR5cGluZygpOworICAgICAgICB0cnkgeworICAgICAgICAgICAgbWFwcGVyLnJlYWRWYWx1ZShKU09OLCBCZWFuMTU5OS5jbGFzcyk7CisgICAgICAgICAgICBmYWlsKCJTaG91bGQgbm90IHBhc3MiKTsKKyAgICAgICAgfSBjYXRjaCAoSnNvbk1hcHBpbmdFeGNlcHRpb24gZSkgeworICAgICAgICAgICAgdmVyaWZ5RXhjZXB0aW9uKGUsICJJbGxlZ2FsIHR5cGUiKTsKKyAgICAgICAgICAgIHZlcmlmeUV4Y2VwdGlvbihlLCAidG8gZGVzZXJpYWxpemUiKTsKKyAgICAgICAgICAgIHZlcmlmeUV4Y2VwdGlvbihlLCAicHJldmVudGVkIGZvciBzZWN1cml0eSByZWFzb25zIik7CisgICAgICAgIH0KKyAgICB9Cit9", "url": "https://github.com/FasterXML/jackson-databind/commit/60d459cedcf079c6106ae7da2ac562bc32dcabe1.patch" }, { "commit_message": "[PATCH] Fix #1599 for 2.7(.10) release-notes/VERSION | 2 + .../deser/BeanDeserializerFactory.java | 23 +++++++++++ .../interop/IllegalTypesCheckTest.java | 40 +++++++++++++++++++ 3 files changed, 65 insertions(+) create mode 100644 src/test/java/com/fasterxml/jackson/databind/interop/IllegalTypesCheckTest.java", "patch_text_b64": "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", "url": "https://github.com/FasterXML/jackson-databind/commit/6ce32ffd18facac6abdbbf559c817b47fcb622c.patch" } ]
null
PYSEC-2021-239
null
[ { "commit_message": "[PATCH] Prevent divisions by 0 PiperOrigin-RevId: 371003153 Change-Id: Idef56c95b9fcaeb97f87e18c7a674dbeb5173204 tensorflow/lite/kernels/depthwise_conv.cc | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/tensorflow/tensorflow/commit/cbda3c6b2dbbd3fbdc482ff8c0170a78ec2e97d0.patch" } ]
null
GHSA-qq3j-4f4f-9583
Hugging Face Transformers Regular Expression Denial of Service
null
[ { "commit_message": "[PATCH] Cleanup the regex used for doc preprocessing (#36648) * Cleanup the regex used for doc preprocessing * Run tests src/transformers/testing_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)", "patch_text_b64": "RnJvbSA4Y2I1MjJiNDE5MGJkNTU2Y2U1MWJlMDQ5NDI3MjA2NTBiMWEzZTU3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXR0IDxSb2NrZXRrbmlnaHQxQHVzZXJzLm5vcmVwbHkuZ2l0aHViLmNvbT4KRGF0ZTogRnJpLCAxNCBNYXIgMjAyNSAxMjoxODo0OSArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIENsZWFudXAgdGhlIHJlZ2V4IHVzZWQgZm9yIGRvYyBwcmVwcm9jZXNzaW5nICgjMzY2NDgpCgoqIENsZWFudXAgdGhlIHJlZ2V4IHVzZWQgZm9yIGRvYyBwcmVwcm9jZXNzaW5nCgoqIFJ1biB0ZXN0cwotLS0KIHNyYy90cmFuc2Zvcm1lcnMvdGVzdGluZ191dGlscy5weSB8IDQgKystLQogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvdHJhbnNmb3JtZXJzL3Rlc3RpbmdfdXRpbHMucHkgYi9zcmMvdHJhbnNmb3JtZXJzL3Rlc3RpbmdfdXRpbHMucHkKaW5kZXggNmQyNTczODY5MTA1Li4wYjQzMDdkZmY2MzcgMTAwNjQ0Ci0tLSBhL3NyYy90cmFuc2Zvcm1lcnMvdGVzdGluZ191dGlscy5weQorKysgYi9zcmMvdHJhbnNmb3JtZXJzL3Rlc3RpbmdfdXRpbHMucHkKQEAgLTI3MzIsOCArMjczMiw4IEBAIGRlZiBwcmVwcm9jZXNzX3N0cmluZyhzdHJpbmcsIHNraXBfY3VkYV90ZXN0cyk6CiAgICAgY3VkYSBzdHVmZiBpcyBkZXRlY3RpdmUgKHdpdGggYSBoZXVyaXN0aWMpLCB0aGlzIG1ldGhvZCB3aWxsIHJldHVybiBhbiBlbXB0eSBzdHJpbmcgc28gbm8gZG9jdGVzdCB3aWxsIGJlIHJ1biBmb3IKICAgICBgc3RyaW5nYC4KICAgICAiIiIKLSAgICBjb2RlYmxvY2tfcGF0dGVybiA9IHIiKGBgYCg/OnB5dGhvbnxweSlccypcblxzKj4+PiApKCg/Oi4qP1xuKSo/Lio/YGBgKSIKLSAgICBjb2RlYmxvY2tzID0gcmUuc3BsaXQocmUuY29tcGlsZShjb2RlYmxvY2tfcGF0dGVybiwgZmxhZ3M9cmUuTVVMVElMSU5FIHwgcmUuRE9UQUxMKSwgc3RyaW5nKQorICAgIGNvZGVibG9ja19wYXR0ZXJuID0gciIoYGBgKD86cHl0aG9ufHB5KVxzKlxuXHMqPj4+ICkoLio/YGBgKSIKKyAgICBjb2RlYmxvY2tzID0gcmUuc3BsaXQoY29kZWJsb2NrX3BhdHRlcm4sIHN0cmluZywgZmxhZ3M9cmUuRE9UQUxMKQogICAgIGlzX2N1ZGFfZm91bmQgPSBGYWxzZQogICAgIGZvciBpLCBjb2RlYmxvY2sgaW4gZW51bWVyYXRlKGNvZGVibG9ja3MpOgogICAgICAgICBpZiAibG9hZF9kYXRhc2V0KCIgaW4gY29kZWJsb2NrIGFuZCAiIyBkb2N0ZXN0OiArSUdOT1JFX1JFU1VMVCIgbm90IGluIGNvZGVibG9jazo=", "url": "https://github.com/huggingface/transformers/commit/8cb522b4190bd556ce51be04942720650b1a3e57.patch" } ]
null
PYSEC-2016-24
null
[ { "commit_message": "[PATCH] fix #913: Harden bottle against malformed headers. Bottle now checks against certain control characters (\\n, \\r and \\0) in header names or values and raises a ValueError if the application tries to set an invalid header. bottle.py | 25 ++++++++++++++----------- test/test_environ.py | 14 ++++++++++++++ 2 files changed, 28 insertions(+), 11 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/bottlepy/bottle/commit/6d7e13da0f998820800ecb3fe9ccee4189aefb54.patch" } ]
null
GHSA-prcg-mc23-hgjh
phpmyadmin contains SQL Injection vulnerability
null
[ { "commit_message": "[PATCH] Add ChangeLog entry for #15898 Ref: e1f5dfcd167488a3a72706cb3ebb792a62452e38 Signed-off-by: William Desportes <williamdes@wdes.fr> ChangeLog | 1 + 1 file changed, 1 insertion(+)", "patch_text_b64": "RnJvbSBiYzk4MjQ2NmYwOGRkY2NhZDQ4MDRiYTkyOGY4NGZmOGUyNTEwN2NiIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBXaWxsaWFtIERlc3BvcnRlcyA8d2lsbGlhbWRlc0B3ZGVzLmZyPgpEYXRlOiBUaHUsIDE5IE1hciAyMDIwIDIzOjIxOjQ4ICswMTAwClN1YmplY3Q6IFtQQVRDSF0gQWRkIENoYW5nZUxvZyBlbnRyeSBmb3IgIzE1ODk4CgpSZWY6IGUxZjVkZmNkMTY3NDg4YTNhNzI3MDZjYjNlYmI3OTJhNjI0NTJlMzgKU2lnbmVkLW9mZi1ieTogV2lsbGlhbSBEZXNwb3J0ZXMgPHdpbGxpYW1kZXNAd2Rlcy5mcj4KLS0tCiBDaGFuZ2VMb2cgfCAxICsKIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKQoKZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCA5MDFlYzgzYjVmNWIuLjhjOWVmZjc3ZGFiNyAxMDA2NDQKLS0tIGEvQ2hhbmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtNjEsNiArNjEsNyBAQCBwaHBNeUFkbWluIC0gQ2hhbmdlTG9nCiAtIGlzc3VlICMxNjAyMiBGaXggdW5jYXVnaHQgVHlwZUVycm9yIG9uIGJyb3dzZSBmb3JlaWduZXJzCiAtIGlzc3VlICAgICAgICBGaXggZmFpbHVyZSBpZiByZWxhdGlvbmFsIGRpc3BsYXkgZmllbGQgdmFsdWUgaXMgTlVMTCAtICJEaXNwbGF5IGNvbHVtbiBmb3IgcmVsYXRpb25zaGlwcyIKIC0gaXNzdWUgIzE2MDMzIFJlbW92ZSB2ZW5kb3IgYmluIGZpbGVzIGZyb20gbm9uIHNvdXJjZSB2ZXJzaW9uIG9mIHBocE15QWRtaW4KKy0gaXNzdWUgIzE1ODk4IFtzZWN1cml0eV0gRml4IGVzY2FwZSB0Ymxfc3RvcmFnZV9lbmdpbmUgYXJndW1lbnQgdXNlZCBvbiB0YmxfY3JlYXRlLnBocAogCiA1LjAuMSAoMjAyMC0wMS0wNykKIC0gaXNzdWUgIzE1NzE5IEZpeGVkIGVycm9yIDUwMCB3aGVuIGJyb3dzaW5nIGEgdGFibGUgd2hlbiAkY2ZnWydMaW1pdENoYXJzJ10gdXNlZCBhIHN0cmluZyBhbmQgbm90IGFuIGludCB2YWx1ZQ==", "url": "https://github.com/phpmyadmin/phpmyadmin/commit/bc982466f08ddccad4804ba928f84ff8e25107cb.patch" } ]
null
GHSA-8vhr-8v52-w97w
null
[ { "commit_message": "[PATCH] pinctrl: amd: Use devm_pinctrl_register() for pinctrl registration Use devm_pinctrl_register() for pin control registration and clean error path. Signed-off-by: Laxman Dewangan <ldewangan@nvidia.com> Signed-off-by: Linus Walleij <linus.walleij@linaro.org> drivers/pinctrl/pinctrl-amd.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)", "patch_text_b64": "RnJvbSAyNTFlMjJhYmRlMjE4MzNiM2QyOTU3N2U0ZDhjN2FhY2NkNjUwZWVlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBMYXhtYW4gRGV3YW5nYW4gPGxkZXdhbmdhbkBudmlkaWEuY29tPgpEYXRlOiBXZWQsIDI0IEZlYiAyMDE2IDE0OjQ0OjA3ICswNTMwClN1YmplY3Q6IFtQQVRDSF0gcGluY3RybDogYW1kOiBVc2UgZGV2bV9waW5jdHJsX3JlZ2lzdGVyKCkgZm9yIHBpbmN0cmwKIHJlZ2lzdHJhdGlvbgoKVXNlIGRldm1fcGluY3RybF9yZWdpc3RlcigpIGZvciBwaW4gY29udHJvbCByZWdpc3RyYXRpb24gYW5kIGNsZWFuCmVycm9yIHBhdGguCgpTaWduZWQtb2ZmLWJ5OiBMYXhtYW4gRGV3YW5nYW4gPGxkZXdhbmdhbkBudmlkaWEuY29tPgpTaWduZWQtb2ZmLWJ5OiBMaW51cyBXYWxsZWlqIDxsaW51cy53YWxsZWlqQGxpbmFyby5vcmc+Ci0tLQogZHJpdmVycy9waW5jdHJsL3BpbmN0cmwtYW1kLmMgfCA5ICsrKy0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvcGluY3RybC1hbWQuYyBiL2RyaXZlcnMvcGluY3RybC9waW5jdHJsLWFtZC5jCmluZGV4IGIwZTJlYzBkYWVkMzAyLi42MzRiNGQzMGVlZmIxZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL3BpbmN0cmwtYW1kLmMKKysrIGIvZHJpdmVycy9waW5jdHJsL3BpbmN0cmwtYW1kLmMKQEAgLTc4Myw4ICs3ODMsOCBAQCBzdGF0aWMgaW50IGFtZF9ncGlvX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJZ3Bpb19kZXYtPm5ncm91cHMgPSBBUlJBWV9TSVpFKGtlcm5jel9ncm91cHMpOwogCiAJYW1kX3BpbmN0cmxfZGVzYy5uYW1lID0gZGV2X25hbWUoJnBkZXYtPmRldik7Ci0JZ3Bpb19kZXYtPnBjdHJsID0gcGluY3RybF9yZWdpc3RlcigmYW1kX3BpbmN0cmxfZGVzYywKLQkJCQkJJnBkZXYtPmRldiwgZ3Bpb19kZXYpOworCWdwaW9fZGV2LT5wY3RybCA9IGRldm1fcGluY3RybF9yZWdpc3RlcigmcGRldi0+ZGV2LCAmYW1kX3BpbmN0cmxfZGVzYywKKwkJCQkJCWdwaW9fZGV2KTsKIAlpZiAoSVNfRVJSKGdwaW9fZGV2LT5wY3RybCkpIHsKIAkJZGV2X2VycigmcGRldi0+ZGV2LCAiQ291bGRuJ3QgcmVnaXN0ZXIgcGluY3RybCBkcml2ZXJcbiIpOwogCQlyZXR1cm4gUFRSX0VSUihncGlvX2Rldi0+cGN0cmwpOwpAQCAtNzkyLDcgKzc5Miw3IEBAIHN0YXRpYyBpbnQgYW1kX2dwaW9fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAogCXJldCA9IGdwaW9jaGlwX2FkZF9kYXRhKCZncGlvX2Rldi0+Z2MsIGdwaW9fZGV2KTsKIAlpZiAocmV0KQotCQlnb3RvIG91dDE7CisJCXJldHVybiByZXQ7CiAKIAlyZXQgPSBncGlvY2hpcF9hZGRfcGluX3JhbmdlKCZncGlvX2Rldi0+Z2MsIGRldl9uYW1lKCZwZGV2LT5kZXYpLAogCQkJCTAsIDAsIFRPVEFMX05VTUJFUl9PRl9QSU5TKTsKQEAgLTgyNSw4ICs4MjUsNiBAQCBzdGF0aWMgaW50IGFtZF9ncGlvX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiBvdXQyOgogCWdwaW9jaGlwX3JlbW92ZSgmZ3Bpb19kZXYtPmdjKTsKIAotb3V0MToKLQlwaW5jdHJsX3VucmVnaXN0ZXIoZ3Bpb19kZXYtPnBjdHJsKTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC04MzcsNyArODM1LDYgQEAgc3RhdGljIGludCBhbWRfZ3Bpb19yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlncGlvX2RldiA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwogCiAJZ3Bpb2NoaXBfcmVtb3ZlKCZncGlvX2Rldi0+Z2MpOwotCXBpbmN0cmxfdW5yZWdpc3RlcihncGlvX2Rldi0+cGN0cmwpOwogCiAJcmV0dXJuIDA7CiB9", "url": "https://github.com/torvalds/linux/commit/251e22abde21833b3d29577e4d8c7aaccd650eee.patch" }, { "commit_message": "[PATCH] pinctrl/amd: Drop pinctrl_unregister for devm_ registered device It's not necessary to unregister pin controller device registered with devm_pinctrl_register() and using pinctrl_unregister() leads to a double free. Fixes: 3bfd44306c65 (\"pinctrl: amd: Add support for additional GPIO\") Signed-off-by: Wei Yongjun <weiyongjun1@huawei.com> Signed-off-by: Linus Walleij <linus.walleij@linaro.org> drivers/pinctrl/pinctrl-amd.c | 1 - 1 file changed, 1 deletion(-)", "patch_text_b64": "RnJvbSA4ZGNhNGE0MWYxYWQ2NTA0M2E3OGMyMzM4ZDk3MjVmODU5YzhkMmMzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBXZWkgWW9uZ2p1biA8d2VpeW9uZ2p1bjFAaHVhd2VpLmNvbT4KRGF0ZTogVHVlLCAxNyBKYW4gMjAxNyAxNTo1NTozMiArMDAwMApTdWJqZWN0OiBbUEFUQ0hdIHBpbmN0cmwvYW1kOiBEcm9wIHBpbmN0cmxfdW5yZWdpc3RlciBmb3IgZGV2bV8gcmVnaXN0ZXJlZAogZGV2aWNlCgpJdCdzIG5vdCBuZWNlc3NhcnkgdG8gdW5yZWdpc3RlciBwaW4gY29udHJvbGxlciBkZXZpY2UgcmVnaXN0ZXJlZAp3aXRoIGRldm1fcGluY3RybF9yZWdpc3RlcigpIGFuZCB1c2luZyBwaW5jdHJsX3VucmVnaXN0ZXIoKSBsZWFkcwp0byBhIGRvdWJsZSBmcmVlLgoKRml4ZXM6IDNiZmQ0NDMwNmM2NSAoInBpbmN0cmw6IGFtZDogQWRkIHN1cHBvcnQgZm9yIGFkZGl0aW9uYWwgR1BJTyIpClNpZ25lZC1vZmYtYnk6IFdlaSBZb25nanVuIDx3ZWl5b25nanVuMUBodWF3ZWkuY29tPgpTaWduZWQtb2ZmLWJ5OiBMaW51cyBXYWxsZWlqIDxsaW51cy53YWxsZWlqQGxpbmFyby5vcmc+Ci0tLQogZHJpdmVycy9waW5jdHJsL3BpbmN0cmwtYW1kLmMgfCAxIC0KIDEgZmlsZSBjaGFuZ2VkLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL3BpbmN0cmwtYW1kLmMgYi9kcml2ZXJzL3BpbmN0cmwvcGluY3RybC1hbWQuYwppbmRleCAxZWUxMDdmMTQ3ZDA0Zi4uNmI3NWJkMmI3MWRiMzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9waW5jdHJsLWFtZC5jCisrKyBiL2RyaXZlcnMvcGluY3RybC9waW5jdHJsLWFtZC5jCkBAIC04MzYsNyArODM2LDYgQEAgc3RhdGljIGludCBhbWRfZ3Bpb19yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlncGlvX2RldiA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwogCiAJZ3Bpb2NoaXBfcmVtb3ZlKCZncGlvX2Rldi0+Z2MpOwotCXBpbmN0cmxfdW5yZWdpc3RlcihncGlvX2Rldi0+cGN0cmwpOwogCiAJcmV0dXJuIDA7CiB9", "url": "https://github.com/torvalds/linux/commit/8dca4a41f1ad65043a78c2338d9725f859c8d2c3.patch" } ]
null
GHSA-69jw-4jj8-fcxm
gokey allows secret recovery from a seed file without the master password
null
[ { "commit_message": "[PATCH] Fix a logic bug for the encrypted seed unwrap Apparently the unwrapSeed() never puts decrypted seed bytes into the resulting buffer. This means that decrypted seed only had the initial vector and the authentication tag initialised. This is a breaking change: previously derived passwords/secrets will be invalidated after this change. They should also be rotated. csprng.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSBmMjYxODE5ZTk5ZWExNjk4NDNiZDVhYTNlNjQzZDA0NjI2MGZmNTExIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBJZ25hdCBLb3JjaGFnaW4gPGlnbmF0QGNsb3VkZmxhcmUuY29tPgpEYXRlOiBUdWUsIDE4IE5vdiAyMDI1IDE3OjQyOjU2ICswMDAwClN1YmplY3Q6IFtQQVRDSF0gRml4IGEgbG9naWMgYnVnIGZvciB0aGUgZW5jcnlwdGVkIHNlZWQgdW53cmFwCgpBcHBhcmVudGx5IHRoZSB1bndyYXBTZWVkKCkgbmV2ZXIgcHV0cyBkZWNyeXB0ZWQgc2VlZCBieXRlcyBpbnRvIHRoZSByZXN1bHRpbmcKYnVmZmVyLiBUaGlzIG1lYW5zIHRoYXQgZGVjcnlwdGVkIHNlZWQgb25seSBoYWQgdGhlIGluaXRpYWwgdmVjdG9yIGFuZCB0aGUKYXV0aGVudGljYXRpb24gdGFnIGluaXRpYWxpc2VkLgoKVGhpcyBpcyBhIGJyZWFraW5nIGNoYW5nZTogcHJldmlvdXNseSBkZXJpdmVkIHBhc3N3b3Jkcy9zZWNyZXRzIHdpbGwgYmUKaW52YWxpZGF0ZWQgYWZ0ZXIgdGhpcyBjaGFuZ2UuIFRoZXkgc2hvdWxkIGFsc28gYmUgcm90YXRlZC4KLS0tCiBjc3BybmcuZ28gfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9jc3BybmcuZ28gYi9jc3BybmcuZ28KaW5kZXggNWNlMDU0MS4uYWI3MGUzMiAxMDA2NDQKLS0tIGEvY3Nwcm5nLmdvCisrKyBiL2NzcHJuZy5nbwpAQCAtMTAxLDcgKzEwMSw3IEBAIGZ1bmMgdW53cmFwU2VlZChwYXNzd29yZCBzdHJpbmcsIHNlZWQgW11ieXRlKSAoW11ieXRlLCBlcnJvcikgewogCX0KIAogCXB0IDo9IG1ha2UoW11ieXRlLCBsZW4oc2VlZCkpCi0JXywgZXJyID0gZ2NtLk9wZW4ocHRbMTI6XSwgc2VlZFs6MTJdLCBzZWVkWzEyOl0sIG5pbCkKKwlfLCBlcnIgPSBnY20uT3BlbihwdFsxMjpdWzowXSwgc2VlZFs6MTJdLCBzZWVkWzEyOl0sIG5pbCkKIAlpZiBlcnIgIT0gbmlsIHsKIAkJcmV0dXJuIG5pbCwgZXJyCiAJfQ==", "url": "https://github.com/cloudflare/gokey/commit/f261819e99ea169843bd5aa3e643d046260ff511.patch" } ]
null
GHSA-5f5v-5c3v-gw5v
Silverstripe IE requests not properly behaving with rewritehashlinks
null
[ { "commit_message": "[PATCH] Fixed XSS vulnerability relating to rewrite_hash tests/view/SSViewerTest.php | 19 ++++++++++++++++--- view/SSTemplateParser.php | 2 +- view/SSTemplateParser.php.inc | 2 +- view/SSViewer.php | 4 ++-- 4 files changed, 20 insertions(+), 7 deletions(-)", "patch_text_b64": "RnJvbSA2MDRjMzI4NzEyMDIwNjRhNGFhMTJjM2IzZmQ1ODE0MDIzMTY4NWU1IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBDaHJpc3RvcGhlciBQaXR0IDxjZ3BpdHRAZ21haWwuY29tPgpEYXRlOiBGcmksIDIwIE1hciAyMDE1IDE4OjE3OjUxICsxMzAwClN1YmplY3Q6IFtQQVRDSF0gRml4ZWQgWFNTIHZ1bG5lcmFiaWxpdHkgcmVsYXRpbmcgdG8gcmV3cml0ZV9oYXNoCgotLS0KIHRlc3RzL3ZpZXcvU1NWaWV3ZXJUZXN0LnBocCAgIHwgMTkgKysrKysrKysrKysrKysrKy0tLQogdmlldy9TU1RlbXBsYXRlUGFyc2VyLnBocCAgICAgfCAgMiArLQogdmlldy9TU1RlbXBsYXRlUGFyc2VyLnBocC5pbmMgfCAgMiArLQogdmlldy9TU1ZpZXdlci5waHAgICAgICAgICAgICAgfCAgNCArKy0tCiA0IGZpbGVzIGNoYW5nZWQsIDIwIGluc2VydGlvbnMoKyksIDcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvdGVzdHMvdmlldy9TU1ZpZXdlclRlc3QucGhwIGIvdGVzdHMvdmlldy9TU1ZpZXdlclRlc3QucGhwCmluZGV4IGQ4MzQ5YzUwZDlhLi41NTBlYWEwNDZiMyAxMDA2NDQKLS0tIGEvdGVzdHMvdmlldy9TU1ZpZXdlclRlc3QucGhwCisrKyBiL3Rlc3RzL3ZpZXcvU1NWaWV3ZXJUZXN0LnBocApAQCAtMTEzMSw4ICsxMTMxLDEwIEBAIHB1YmxpYyBmdW5jdGlvbiB0ZXN0VGhlbWVSZXRyaWV2YWwoKSB7CiAKIAlwdWJsaWMgZnVuY3Rpb24gdGVzdFJld3JpdGVIYXNobGlua3MoKSB7CiAJCSRvcmlnID0gQ29uZmlnOjppbnN0KCktPmdldCgnU1NWaWV3ZXInLCAncmV3cml0ZV9oYXNoX2xpbmtzJyk7IAotCQlDb25maWc6Omluc3QoKS0+dXBkYXRlKCdTU1ZpZXdlcicsICdyZXdyaXRlX2hhc2hfbGlua3MnLCB0cnVlKTsgCi0JCQorCQlDb25maWc6Omluc3QoKS0+dXBkYXRlKCdTU1ZpZXdlcicsICdyZXdyaXRlX2hhc2hfbGlua3MnLCB0cnVlKTsKKworCQkkX1NFUlZFUlsnUkVRVUVTVF9VUkknXSA9ICdodHRwOi8vcGF0aC90by9maWxlP2ZvbyJvbmNsaWNrPSJhbGVydChcJ3hzc1wnKSIiJzsKKwogCQkvLyBFbXVsYXRlIFNTVmlld2VyOjpwcm9jZXNzKCkKIAkJJGJhc2UgPSBDb252ZXJ0OjpyYXcyYXR0KCRfU0VSVkVSWydSRVFVRVNUX1VSSSddKTsKIAkJCkBAIC0xMTQzLDYgKzExNDUsOCBAQCBwdWJsaWMgZnVuY3Rpb24gdGVzdFJld3JpdGVIYXNobGlua3MoKSB7CiAJCQk8aHRtbD4KIAkJCQk8aGVhZD48JSBiYXNlX3RhZyAlPjwvaGVhZD4KIAkJCQk8Ym9keT4KKwkJCQk8YSBjbGFzcz0iZXh0ZXJuYWwtaW5saW5lIiBocmVmPSJodHRwOi8vZ29vZ2xlLmNvbSNhbmNob3IiPkV4dGVybmFsSW5saW5lTGluazwvYT4KKwkJCQkkRXh0ZXJuYWxJbnNlcnRlZExpbmsKIAkJCQk8YSBjbGFzcz0iaW5saW5lIiBocmVmPSIjYW5jaG9yIj5JbmxpbmVMaW5rPC9hPgogCQkJCSRJbnNlcnRlZExpbmsKIAkJCQk8c3ZnPjx1c2UgeGxpbms6aHJlZj0iI3Nwcml0ZSI+PC91c2U+PC9zdmc+CkBAIC0xMTUxLDE1ICsxMTU1LDI0IEBAIHB1YmxpYyBmdW5jdGlvbiB0ZXN0UmV3cml0ZUhhc2hsaW5rcygpIHsKIAkJJHRtcGwgPSBuZXcgU1NWaWV3ZXIoJHRtcGxGaWxlKTsKIAkJJG9iaiA9IG5ldyBWaWV3YWJsZURhdGEoKTsKIAkJJG9iai0+SW5zZXJ0ZWRMaW5rID0gJzxhIGNsYXNzPSJpbnNlcnRlZCIgaHJlZj0iI2FuY2hvciI+SW5zZXJ0ZWRMaW5rPC9hPic7CisJCSRvYmotPkV4dGVybmFsSW5zZXJ0ZWRMaW5rID0gJzxhIGNsYXNzPSJleHRlcm5hbC1pbnNlcnRlZCIgaHJlZj0iaHR0cDovL2dvb2dsZS5jb20jYW5jaG9yIj5FeHRlcm5hbEluc2VydGVkTGluazwvYT4nOwogCQkkcmVzdWx0ID0gJHRtcGwtPnByb2Nlc3MoJG9iaik7CiAJCSR0aGlzLT5hc3NlcnRDb250YWlucygKIAkJCSc8YSBjbGFzcz0iaW5zZXJ0ZWQiIGhyZWY9IicgLiAkYmFzZSAuICcjYW5jaG9yIj5JbnNlcnRlZExpbms8L2E+JywKIAkJCSRyZXN1bHQKIAkJKTsKKwkJJHRoaXMtPmFzc2VydENvbnRhaW5zKAorCQkJJzxhIGNsYXNzPSJleHRlcm5hbC1pbnNlcnRlZCIgaHJlZj0iaHR0cDovL2dvb2dsZS5jb20jYW5jaG9yIj5FeHRlcm5hbEluc2VydGVkTGluazwvYT4nLAorCQkJJHJlc3VsdAorCQkpOwogCQkkdGhpcy0+YXNzZXJ0Q29udGFpbnMoCiAJCQknPGEgY2xhc3M9ImlubGluZSIgaHJlZj0iJyAuICRiYXNlIC4gJyNhbmNob3IiPklubGluZUxpbms8L2E+JywKIAkJCSRyZXN1bHQKIAkJKTsKKwkJJHRoaXMtPmFzc2VydENvbnRhaW5zKAorCQkJJzxhIGNsYXNzPSJleHRlcm5hbC1pbmxpbmUiIGhyZWY9Imh0dHA6Ly9nb29nbGUuY29tI2FuY2hvciI+RXh0ZXJuYWxJbmxpbmVMaW5rPC9hPicsCisJCQkkcmVzdWx0CisJCSk7CiAJCSR0aGlzLT5hc3NlcnRDb250YWlucygKIAkJCSc8c3ZnPjx1c2UgeGxpbms6aHJlZj0iI3Nwcml0ZSI+PC91c2U+PC9zdmc+JywKIAkJCSRyZXN1bHQsCkBAIC0xMTkyLDcgKzEyMDUsNyBAQCBwdWJsaWMgZnVuY3Rpb24gdGVzdFJld3JpdGVIYXNobGlua3NJblBocE1vZGUoKSB7CiAJCSRvYmotPkluc2VydGVkTGluayA9ICc8YSBjbGFzcz0iaW5zZXJ0ZWQiIGhyZWY9IiNhbmNob3IiPkluc2VydGVkTGluazwvYT4nOwogCQkkcmVzdWx0ID0gJHRtcGwtPnByb2Nlc3MoJG9iaik7CiAJCSR0aGlzLT5hc3NlcnRDb250YWlucygKLQkJCSc8YSBjbGFzcz0iaW5zZXJ0ZWQiIGhyZWY9Ijw/cGhwIGVjaG8gc3RyaXBfdGFncygnLAorCQkJJzxhIGNsYXNzPSJpbnNlcnRlZCIgaHJlZj0iPD9waHAgZWNobyBDb252ZXJ0OjpyYXcyYXR0KCcsCiAJCQkkcmVzdWx0CiAJCSk7CiAJCS8vIFRPRE8gRml4IGlubGluZSBsaW5rcyBpbiBQSFAgbW9kZQpkaWZmIC0tZ2l0IGEvdmlldy9TU1RlbXBsYXRlUGFyc2VyLnBocCBiL3ZpZXcvU1NUZW1wbGF0ZVBhcnNlci5waHAKaW5kZXggM2MxMTk4MGRjNjkuLmJkODdhMzFhZmE2IDEwMDY0NAotLS0gYS92aWV3L1NTVGVtcGxhdGVQYXJzZXIucGhwCisrKyBiL3ZpZXcvU1NUZW1wbGF0ZVBhcnNlci5waHAKQEAgLTQ2ODQsNyArNDY4NCw3IEBAIGZ1bmN0aW9uIFRleHRfX2ZpbmFsaXNlKCYkcmVzKSB7CiAJCSR0ZXh0ID0gcHJlZ19yZXBsYWNlKAogCQkJJy8oPGFbXj5dK2hyZWYgKj0gKikiIy9pJywKIAkJCSdcXDEiXCcgLiAoQ29uZmlnOjppbnN0KCktPmdldChcJ1NTVmlld2VyXCcsIFwncmV3cml0ZV9oYXNoX2xpbmtzXCcpID8nIC4KLQkJCScgc3RyaXBfdGFncyggJF9TRVJWRVJbXCdSRVFVRVNUX1VSSVwnXSApIDogIiIpIC4gCisJCQknIENvbnZlcnQ6OnJhdzJhdHQoICRfU0VSVkVSW1wnUkVRVUVTVF9VUklcJ10gKSA6ICIiKSAuCiAJCQkJXCcjJywKIAkJCSR0ZXh0CiAJCSk7CmRpZmYgLS1naXQgYS92aWV3L1NTVGVtcGxhdGVQYXJzZXIucGhwLmluYyBiL3ZpZXcvU1NUZW1wbGF0ZVBhcnNlci5waHAuaW5jCmluZGV4IDc0ZmMyN2JiZTJiLi42YmI3YzU1MGRiMiAxMDA2NDQKLS0tIGEvdmlldy9TU1RlbXBsYXRlUGFyc2VyLnBocC5pbmMKKysrIGIvdmlldy9TU1RlbXBsYXRlUGFyc2VyLnBocC5pbmMKQEAgLTExMzgsNyArMTEzOCw3IEBAIGNsYXNzIFNTVGVtcGxhdGVQYXJzZXIgZXh0ZW5kcyBQYXJzZXIgaW1wbGVtZW50cyBUZW1wbGF0ZVBhcnNlciB7CiAJCSR0ZXh0ID0gcHJlZ19yZXBsYWNlKAogCQkJJy8oPGFbXj5dK2hyZWYgKj0gKikiIy9pJywKIAkJCSdcXDEiXCcgLiAoQ29uZmlnOjppbnN0KCktPmdldChcJ1NTVmlld2VyXCcsIFwncmV3cml0ZV9oYXNoX2xpbmtzXCcpID8nIC4KLQkJCScgc3RyaXBfdGFncyggJF9TRVJWRVJbXCdSRVFVRVNUX1VSSVwnXSApIDogIiIpIC4gCisJCQknIENvbnZlcnQ6OnJhdzJhdHQoICRfU0VSVkVSW1wnUkVRVUVTVF9VUklcJ10gKSA6ICIiKSAuCiAJCQkJXCcjJywKIAkJCSR0ZXh0CiAJCSk7CmRpZmYgLS1naXQgYS92aWV3L1NTVmlld2VyLnBocCBiL3ZpZXcvU1NWaWV3ZXIucGhwCmluZGV4IDhhNGViZjA1MjU4Li5kNWZkYjY4YmI5YSAxMDA2NDQKLS0tIGEvdmlldy9TU1ZpZXdlci5waHAKKysrIGIvdmlldy9TU1ZpZXdlci5waHAKQEAgLTExMDksOSArMTEwOSw5IEBAIHB1YmxpYyBmdW5jdGlvbiBwcm9jZXNzKCRpdGVtLCAkYXJndW1lbnRzID0gbnVsbCwgJGluaGVyaXRlZFNjb3BlID0gbnVsbCkgewogCQlpZigkdGhpcy0+cmV3cml0ZUhhc2hsaW5rcyAmJiAkcmV3cml0ZSkgewogCQkJaWYoc3RycG9zKCRvdXRwdXQsICc8YmFzZScpICE9PSBmYWxzZSkgewogCQkJCWlmKCRyZXdyaXRlID09PSAncGhwJykgeyAKLQkJCQkJJHRoaXNVUkxSZWxhdGl2ZVRvQmFzZSA9ICI8P3BocCBlY2hvIHN0cmlwX3RhZ3MoXCRfU0VSVkVSWydSRVFVRVNUX1VSSSddKTsgPz4iOyAKKwkJCQkJJHRoaXNVUkxSZWxhdGl2ZVRvQmFzZSA9ICI8P3BocCBlY2hvIENvbnZlcnQ6OnJhdzJhdHQoXCRfU0VSVkVSWydSRVFVRVNUX1VSSSddKTsgPz4iOwogCQkJCX0gZWxzZSB7IAotCQkJCQkkdGhpc1VSTFJlbGF0aXZlVG9CYXNlID0gc3RyaXBfdGFncygkX1NFUlZFUlsnUkVRVUVTVF9VUkknXSk7IAorCQkJCQkkdGhpc1VSTFJlbGF0aXZlVG9CYXNlID0gQ29udmVydDo6cmF3MmF0dCgkX1NFUlZFUlsnUkVRVUVTVF9VUkknXSk7CiAJCQkJfQogCiAJCQkJJG91dHB1dCA9IHByZWdfcmVwbGFjZSgnLyg8YVtePl0raHJlZiAqPSAqKSIjL2knLCAnXFwxIicgLiAkdGhpc1VSTFJlbGF0aXZlVG9CYXNlIC4gJyMnLCAkb3V0cHV0KTs=", "url": "https://github.com/silverstripe/silverstripe-framework/commit/604c32871202064a4aa12c3b3fd58140231685e5.patch" }, { "commit_message": "[PATCH] Fixed XSS vulnerability relating to rewrite_hash tests/view/SSViewerTest.php | 25 ++++++++++++++++++++++--- view/SSTemplateParser.php | 5 +++-- view/SSTemplateParser.php.inc | 5 +++-- view/SSViewer.php | 4 ++-- 4 files changed, 30 insertions(+), 9 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/silverstripe/silverstripe-framework/commit/bdef4fc7a548c7c243ff86f2db7c16f301a6f120.patch" } ]
null
CVE-2023-42452
Mastodon vulnerable to Stored XSS through the translation feature
Mastodon is a free, open-source social network server based on ActivityPub. In versions on the 4.x branch prior to versions 4.0.10, 4.2.8, and 4.2.0-rc2, under certain conditions, attackers can abuse the translation feature to bypass the server-side HTML sanitization, allowing unescaped HTML to execute in the browser. The impact is limited thanks to Mastodon's strict Content Security Policy, blocking inline scripts, etc. However a CSP bypass or loophole could be exploited to execute malicious XSS. Furthermore, it requires user interaction, as this can only occur upon clicking the “Translate” button on a malicious post. Versions 4.0.10, 4.2.8, and 4.2.0-rc2 contain a patch for this issue.
[ { "commit_message": "[PATCH] Merge pull request from GHSA-2693-xr3m-jhqr app/services/translate_status_service.rb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSBmZjMyNDc1ZjVmNGE4NGViZjk2MTllN2VlZjViZjhiNGMwNzVkMGUyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBDbGFpcmUgPGNsYWlyZS5naXRodWItMzA5Y0BzaXRlZGV0aGliLmNvbT4KRGF0ZTogVHVlLCAxOSBTZXAgMjAyMyAxNjo1MzoyMSArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIE1lcmdlIHB1bGwgcmVxdWVzdCBmcm9tIEdIU0EtMjY5My14cjNtLWpocXIKCi0tLQogYXBwL3NlcnZpY2VzL3RyYW5zbGF0ZV9zdGF0dXNfc2VydmljZS5yYiB8IDQgKysrLQogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2FwcC9zZXJ2aWNlcy90cmFuc2xhdGVfc3RhdHVzX3NlcnZpY2UucmIgYi9hcHAvc2VydmljZXMvdHJhbnNsYXRlX3N0YXR1c19zZXJ2aWNlLnJiCmluZGV4IGMyYjQwNDMzZWQ2ZjEyLi45YWQxNDZhZTdkM2RhOCAxMDA2NDQKLS0tIGEvYXBwL3NlcnZpY2VzL3RyYW5zbGF0ZV9zdGF0dXNfc2VydmljZS5yYgorKysgYi9hcHAvc2VydmljZXMvdHJhbnNsYXRlX3N0YXR1c19zZXJ2aWNlLnJiCkBAIC03NSw3ICs3NSw5IEBAIGRlZiBidWlsZF9zdGF0dXNfdHJhbnNsYXRpb24odHJhbnNsYXRpb25zKQogCiAgICAgICBjYXNlIHNvdXJjZQogICAgICAgd2hlbiA6Y29udGVudAotICAgICAgICBzdGF0dXNfdHJhbnNsYXRpb24uY29udGVudCA9IHVud3JhcF9lbW9qaV9zaG9ydGNvZGVzKHRyYW5zbGF0aW9uLnRleHQpLnRvX2h0bWwKKyAgICAgICAgbm9kZSA9IHVud3JhcF9lbW9qaV9zaG9ydGNvZGVzKHRyYW5zbGF0aW9uLnRleHQpCisgICAgICAgIFNhbml0aXplLm5vZGUhKG5vZGUsIFNhbml0aXplOjpDb25maWc6Ok1BU1RPRE9OX1NUUklDVCkKKyAgICAgICAgc3RhdHVzX3RyYW5zbGF0aW9uLmNvbnRlbnQgPSBub2RlLnRvX2h0bWwKICAgICAgIHdoZW4gOnNwb2lsZXJfdGV4dAogICAgICAgICBzdGF0dXNfdHJhbnNsYXRpb24uc3BvaWxlcl90ZXh0ID0gdW53cmFwX2Vtb2ppX3Nob3J0Y29kZXModHJhbnNsYXRpb24udGV4dCkuY29udGVudAogICAgICAgd2hlbiBQb2xsOjpPcHRpb24=", "url": "https://github.com/mastodon/mastodon/commit/ff32475f5f4a84ebf9619e7eef5bf8b4c075d0e2.patch" } ]
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
CVE-2020-4068
Heap-based Buffer Overflow in APNSwift
In APNSwift 1.0.0, calling APNSwiftSigner.sign(digest:) is likely to result in a heap buffer overflow. This has been fixed in 1.0.1.
[ { "commit_message": "[PATCH] Resolves memory issue (#32) * Resolves #31 Sources/APNSwift/APNSwiftSigner.swift | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-)", "patch_text_b64": "RnJvbSA5N2ZhN2Y2OWRjZGQ4OTE2OGZmZjg0ZTBiYThmOTk5ODgxZWUzZDNmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBLeWxlIEJyb3duaW5nIDxreWxlYnJvd25pbmdAbWUuY29tPgpEYXRlOiBUdWUsIDIzIEp1bCAyMDE5IDEwOjI3OjA3IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gUmVzb2x2ZXMgbWVtb3J5IGlzc3VlICgjMzIpCgoqIFJlc29sdmVzICMzMQotLS0KIFNvdXJjZXMvQVBOU3dpZnQvQVBOU3dpZnRTaWduZXIuc3dpZnQgfCAxMSArKysrLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDQgaW5zZXJ0aW9ucygrKSwgNyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9Tb3VyY2VzL0FQTlN3aWZ0L0FQTlN3aWZ0U2lnbmVyLnN3aWZ0IGIvU291cmNlcy9BUE5Td2lmdC9BUE5Td2lmdFNpZ25lci5zd2lmdAppbmRleCAyN2NlZjcwNy4uNzNkMDZjZDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZXMvQVBOU3dpZnQvQVBOU3dpZnRTaWduZXIuc3dpZnQKKysrIGIvU291cmNlcy9BUE5Td2lmdC9BUE5Td2lmdFNpZ25lci5zd2lmdApAQCAtMzYsOSArMzYsOSBAQCBwdWJsaWMgc3RydWN0IEFQTlN3aWZ0U2lnbmVyIHsKICAgICAgICAgbGV0IGJpbyA9IEJJT19uZXcoQklPX3NfbWVtKCkpCiAgICAgICAgIGRlZmVyIHsgQklPX2ZyZWUoYmlvKSB9CiAgICAgICAgIGxldCByZXMgPSBidWZmZXIud2l0aFVuc2FmZVJlYWRhYmxlQnl0ZXMgeyBwdHIgaW4KLSAgICAgICAgICAgIEludChCSU9fcHV0cyhiaW8sIHB0ci5iYXNlQWRkcmVzcz8uYXNzdW1pbmdNZW1vcnlCb3VuZCh0bzogSW50OC5zZWxmKSkpCisgICAgICAgICAgICBCSU9fd3JpdGUoYmlvLCBwdHIuYmFzZUFkZHJlc3MsIENJbnQocHRyLmNvdW50KSkKICAgICAgICAgfQotICAgICAgICBhc3NlcnQocmVzID49IDAsICJCSU9fcHV0cyBmYWlsZWQiKQorICAgICAgICBhc3NlcnQocmVzID49IDAsICJCSU9fd3JpdGUgZmFpbGVkIikKIAogICAgICAgICBndWFyZCBsZXQgb3BhcXVlUG9pbnRlciA9IE9wYXF1ZVBvaW50ZXIubWFrZShvcHRpb25hbDogUEVNX3JlYWRfYmlvX0VDUHJpdmF0ZUtleShiaW8hLCBuaWwsIG5pbCwgbmlsKSkgZWxzZSB7CiAgICAgICAgICAgICB0aHJvdyBBUE5Td2lmdEVycm9yLlNpZ25pbmdFcnJvci5pbnZhbGlkQXV0aEtleQpAQCAtNTAsMTcgKzUwLDE0IEBAIHB1YmxpYyBzdHJ1Y3QgQVBOU3dpZnRTaWduZXIgewogICAgICAgICB9CiAgICAgICAgIGRlZmVyIHsgRUNEU0FfU0lHX2ZyZWUoc2lnKSB9CiAKLSAgICAgICAgdmFyIGRlckVuY29kZWRTaWduYXR1cmU6IFVuc2FmZU11dGFibGVQb2ludGVyPFVJbnQ4Pj8KKyAgICAgICAgdmFyIGRlckVuY29kZWRTaWduYXR1cmU6IFVuc2FmZU11dGFibGVQb2ludGVyPENVbnNpZ25lZENoYXI+PwogICAgICAgICBsZXQgZGVyTGVuZ3RoID0gaTJkX0VDRFNBX1NJRyhzaWcsICZkZXJFbmNvZGVkU2lnbmF0dXJlKQogICAgICAgICBndWFyZCBsZXQgZGVyQ29weSA9IGRlckVuY29kZWRTaWduYXR1cmUsIGRlckxlbmd0aCA+IDAgZWxzZSB7CiAgICAgICAgICAgICB0aHJvdyBBUE5Td2lmdEVycm9yLlNpZ25pbmdFcnJvci5pbnZhbGlkQVNOMQogICAgICAgICB9CiAKICAgICAgICAgdmFyIGRlckJ5dGVzID0gQnl0ZUJ1ZmZlckFsbG9jYXRvcigpLmJ1ZmZlcihjYXBhY2l0eTogSW50KGRlckxlbmd0aCkpCi0gICAgICAgIGZvciBiIGluIDAgLi48IEludChkZXJMZW5ndGgpIHsKLSAgICAgICAgICAgIGRlckJ5dGVzLndyaXRlQnl0ZXMoW2RlckNvcHlbYl1dKQotICAgICAgICB9Ci0KKyAgICAgICAgZGVyQnl0ZXMud3JpdGVCeXRlcyhVbnNhZmVCdWZmZXJQb2ludGVyPENVbnNpZ25lZENoYXI+KHN0YXJ0OiBkZXJDb3B5LCBjb3VudDogSW50KGRlckxlbmd0aCkpKQogICAgICAgICByZXR1cm4gZGVyQnl0ZXMKICAgICB9CiB9", "url": "https://github.com/kylebrowning/APNSwift/commit/97fa7f69dcdd89168fff84e0ba8f999881ee3d3f.patch" } ]
CWE-122: Heap-based Buffer Overflow
GHSA-2jff-xpp2-45x2
null
[ { "commit_message": "[PATCH] More changes to mitigate: CVE-2010-3843 CVE-2010-3844 src/interfaces/gtk/ec_gtk_conf.c | 4 +--- src/interfaces/gtk/ec_gtk_mitm.c | 6 +++--- 2 files changed, 4 insertions(+), 6 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/Ettercap/ettercap/commit/4ef3ede30181eca9add74305ad26dbcb0c3686a0.patch" } ]
null
PYSEC-2015-26
null
[ { "commit_message": "[PATCH] Fix XSS reported on Security list MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit No CVE-ID yet August 18, 2015 Reported to Quantopian by Juan Broullón <thebrowfc@gmail.com>... If you create a new folder in the iPython file browser and set Javascript code as its name the code injected will be executed. So, if I create a folder called \"><img src=x onerror=alert(document.cookie)> and then I access to it, the cookies will be prompted. The XSS code is also executed if you access a link pointing directly at the folder. jik notebook/notebookapp.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/jupyter/notebook/commit/35f32dd2da804d108a3a3585b69ec3295b2677ed.patch" }, { "commit_message": "[PATCH] Fix XSS reported on Security list MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit No CVE-ID yet August 18, 2015 Reported to Quantopian by Juan Broullón <thebrowfc@gmail.com>... If you create a new folder in the iPython file browser and set Javascript code as its name the code injected will be executed. So, if I create a folder called \"><img src=x onerror=alert(document.cookie)> and then I access to it, the cookies will be prompted. The XSS code is also executed if you access a link pointing directly at the folder. jik IPython/html/notebookapp.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ipython/ipython/commit/3ab41641cf6fce3860c73d5cf4645aa12e1e5892.patch" }, { "commit_message": "[PATCH] Fix XSS reported on Security list MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit No CVE-ID yet August 18, 2015 Reported to Quantopian by Juan Broullón <thebrowfc@gmail.com>... If you create a new folder in the iPython file browser and set Javascript code as its name the code injected will be executed. So, if I create a folder called \"><img src=x onerror=alert(document.cookie)> and then I access to it, the cookies will be prompted. The XSS code is also executed if you access a link pointing directly at the folder. jik notebook/notebookapp.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/jupyter/notebook/commit/dd9876381f0ef09873d8c5f6f2063269172331e3.patch" } ]
null
GHSA-7xwj-5r4v-429p
NPE in TFLite
null
[ { "commit_message": "[PATCH] Fix a null pointer exception in SVDF This is due to not checking that `GetVariableInput` returns non-null tensor. Also fix a potential null pointer exception in `GetVariableInput`. PiperOrigin-RevId: 385160147 Change-Id: Iadf3f0705b036a9014d27caa5a8bbd91f4c4c401 tensorflow/lite/kernels/kernel_util.cc | 1 + tensorflow/lite/kernels/svdf.cc | 1 + 2 files changed, 2 insertions(+)", "patch_text_b64": "RnJvbSA1YjA0OGU4N2U0ZTU1OTkwZGFlNmI1NDdhZGQ0ZGFlNTlmNGUxYzc2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWhhaSBNYXJ1c2VhYyA8bWloYWltYXJ1c2VhY0Bnb29nbGUuY29tPgpEYXRlOiBGcmksIDE2IEp1bCAyMDIxIDA5OjE0OjMxIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gRml4IGEgbnVsbCBwb2ludGVyIGV4Y2VwdGlvbiBpbiBTVkRGCgpUaGlzIGlzIGR1ZSB0byBub3QgY2hlY2tpbmcgdGhhdCBgR2V0VmFyaWFibGVJbnB1dGAgcmV0dXJucyBub24tbnVsbCB0ZW5zb3IuCgpBbHNvIGZpeCBhIHBvdGVudGlhbCBudWxsIHBvaW50ZXIgZXhjZXB0aW9uIGluIGBHZXRWYXJpYWJsZUlucHV0YC4KClBpcGVyT3JpZ2luLVJldklkOiAzODUxNjAxNDcKQ2hhbmdlLUlkOiBJYWRmM2YwNzA1YjAzNmE5MDE0ZDI3Y2FhNWE4YmJkOTFmNGM0YzQwMQotLS0KIHRlbnNvcmZsb3cvbGl0ZS9rZXJuZWxzL2tlcm5lbF91dGlsLmNjIHwgMSArCiB0ZW5zb3JmbG93L2xpdGUva2VybmVscy9zdmRmLmNjICAgICAgICB8IDEgKwogMiBmaWxlcyBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS90ZW5zb3JmbG93L2xpdGUva2VybmVscy9rZXJuZWxfdXRpbC5jYyBiL3RlbnNvcmZsb3cvbGl0ZS9rZXJuZWxzL2tlcm5lbF91dGlsLmNjCmluZGV4IGM2NGE0OWQzMTZiMjE3Li42YTUzNzU3YmJkZmY2NyAxMDA2NDQKLS0tIGEvdGVuc29yZmxvdy9saXRlL2tlcm5lbHMva2VybmVsX3V0aWwuY2MKKysrIGIvdGVuc29yZmxvdy9saXRlL2tlcm5lbHMva2VybmVsX3V0aWwuY2MKQEAgLTExOSw2ICsxMTksNyBAQCBUZkxpdGVTdGF0dXMgR2V0SW5wdXRTYWZlKGNvbnN0IFRmTGl0ZUNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFRmTGl0ZU5vZGUqIG5vZGUsCiBUZkxpdGVUZW5zb3IqIEdldFZhcmlhYmxlSW5wdXQoVGZMaXRlQ29udGV4dCogY29udGV4dCwgY29uc3QgVGZMaXRlTm9kZSogbm9kZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgaW5kZXgpIHsKICAgVGZMaXRlVGVuc29yKiB0ZW5zb3IgPSBHZXRNdXRhYmxlSW5wdXQoY29udGV4dCwgbm9kZSwgaW5kZXgpOworICBpZiAodGVuc29yID09IG51bGxwdHIpIHJldHVybiBudWxscHRyOwogICByZXR1cm4gdGVuc29yLT5pc192YXJpYWJsZSA/IHRlbnNvciA6IG51bGxwdHI7CiB9CiAKZGlmZiAtLWdpdCBhL3RlbnNvcmZsb3cvbGl0ZS9rZXJuZWxzL3N2ZGYuY2MgYi90ZW5zb3JmbG93L2xpdGUva2VybmVscy9zdmRmLmNjCmluZGV4IDMxYjhiMzJjOTgyOTVhLi42YzAyNTA4ZTI2YjFkYSAxMDA2NDQKLS0tIGEvdGVuc29yZmxvdy9saXRlL2tlcm5lbHMvc3ZkZi5jYworKysgYi90ZW5zb3JmbG93L2xpdGUva2VybmVscy9zdmRmLmNjCkBAIC0yOTksNiArMjk5LDcgQEAgVGZMaXRlU3RhdHVzIEV2YWwoVGZMaXRlQ29udGV4dCogY29udGV4dCwgVGZMaXRlTm9kZSogbm9kZSkgewogICAgICAgICAgICAgICAgICAgICBHZXRUZW1wb3JhcnlTYWZlKGNvbnRleHQsIG5vZGUsIC8qaW5kZXg9Ki8wLCAmc2NyYXRjaCkpOwogCiAgIFRmTGl0ZVRlbnNvciogc3RhdGUgPSBHZXRWYXJpYWJsZUlucHV0KGNvbnRleHQsIG5vZGUsIGtTdGF0ZVRlbnNvcik7CisgIFRGX0xJVEVfRU5TVVJFKGNvbnRleHQsIHN0YXRlICE9IG51bGxwdHIpOwogICBUZkxpdGVUZW5zb3IqIG91dHB1dDsKICAgVEZfTElURV9FTlNVUkVfT0soY29udGV4dCwKICAgICAgICAgICAgICAgICAgICAgR2V0T3V0cHV0U2FmZShjb250ZXh0LCBub2RlLCBrT3V0cHV0VGVuc29yLCAmb3V0cHV0KSk7", "url": "https://github.com/tensorflow/tensorflow/commit/5b048e87e4e55990dae6b547add4dae59f4e1c76.patch" } ]
null
CVE-2012-1121
MantisBT before 1.2.9 does not properly check permissions, which allows remote authenticated users with manager privileges to (1) modify or (2) delete global categories.
[ { "commit_message": "[PATCH] User must have global access to update global categories The user's global access level must be >= $g_manage_site_threshold to be allowed to add, edit or delete global categories. Prior to this, once a user had been defined as Manager on at least one project, they could freely update global categories. Also prevents such updates through URL manipulation. Fixes #13561 manage_proj_cat_delete.php | 4 ++-- manage_proj_cat_edit_page.php | 4 ++-- manage_proj_page.php | 10 +++++++++- 3 files changed, 13 insertions(+), 5 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/mantisbt/mantisbt/commit/9443258724e84cb388aa1865b775beaecd80596d.patch" } ]
n/a
GHSA-j5vm-7qcc-2wwg
Kopia: Storage connection credentials written to console on "repository status" CLI command with JSON output
null
[ { "commit_message": "[PATCH] fix(cli): Ensure scrubber checks all fields recursively for sensitive tags (#3589) * Fix ScrubSensitiveData to scrub recursively * Extend test with additional cases internal/scrubber/scrub_sensitive.go | 17 ++++++++++++ internal/scrubber/scrub_sensitive_test.go | 32 ++++++++++++++++++++--- 2 files changed, 45 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/kopia/kopia/commit/1d6f852cd6534f4bea978cbdc85c583803d79f77.patch" } ]
null
GHSA-vh3x-525m-jp4r
heap-buffer-overflow in MicroPython
null
[ { "commit_message": "[PATCH] py/objint: Fix int.to_bytes() buffer size checks. Fixes and improvements to `int.to_bytes()` are: - No longer overflows if byte size is 0 (closes #13041). - Raises OverflowError in any case where number won't fit into byte length (now matches CPython, previously MicroPython would return a truncated bytes object). - Document that `micropython int.to_bytes()` doesn't implement the optional signed kwarg, but will behave as if `signed=True` when the integer is negative (this is the current behaviour). Add tests for this also. Requires changes for small ints, MPZ large ints, and \"long long\" large ints. Adds a new set of unit tests for ints between 32 and 64 bits to increase coverage of \"long long\" large ints, which are otherwise untested. Tested on unix port (64 bit small ints, MPZ long ints) and Zephyr STM32WB board (32 bit small ints, long long large ints). This work was funded through GitHub Sponsors. Signed-off-by: Angus Gratton <angus@redyak.com.au> docs/library/builtins.rst | 4 ++ py/misc.h | 33 +++++++++++++ py/mpz.c | 32 ++++++++----- py/mpz.h | 9 ++-- py/objint.c | 37 +++++++++++---- py/objint.h | 3 +- py/objint_longlong.c | 20 +++++++- py/objint_mpz.c | 4 +- tests/basics/int_bytes.py | 73 +++++++++++++++++++++++++++++ tests/basics/int_bytes_int64.py | 52 ++++++++++++++++++++ tests/basics/int_bytes_intbig.py | 48 +++++++++++++++++++ tests/cpydiff/types_int_to_bytes.py | 16 +++++++ 12 files changed, 302 insertions(+), 29 deletions(-) create mode 100644 tests/basics/int_bytes_int64.py create mode 100644 tests/cpydiff/types_int_to_bytes.py", "patch_text_b64": "From 908ab1ceca15ee6fd0ef82ca4cba770a3ec41894 Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Wed, 29 Nov 2023 11:23:16 +1100
Subject: [PATCH] py/objint: Fix int.to_bytes() buffer size checks.

Fixes and improvements to `int.to_bytes()` are:
- No longer overflows if byte size is 0 (closes #13041).
- Raises OverflowError in any case where number won't fit into byte length
  (now matches CPython, previously MicroPython would return a truncated
  bytes object).
- Document that `micropython int.to_bytes()` doesn't implement the optional
  signed kwarg, but will behave as if `signed=True` when the integer is
  negative (this is the current behaviour).  Add tests for this also.

Requires changes for small ints, MPZ large ints, and "long long" large
ints.

Adds a new set of unit tests for ints between 32 and 64 bits to increase
coverage of "long long" large ints, which are otherwise untested.

Tested on unix port (64 bit small ints, MPZ long ints) and Zephyr STM32WB
board (32 bit small ints, long long large ints).

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 docs/library/builtins.rst           |  4 ++
 py/misc.h                           | 33 +++++++++++++
 py/mpz.c                            | 32 ++++++++-----
 py/mpz.h                            |  9 ++--
 py/objint.c                         | 37 +++++++++++----
 py/objint.h                         |  3 +-
 py/objint_longlong.c                | 20 +++++++-
 py/objint_mpz.c                     |  4 +-
 tests/basics/int_bytes.py           | 73 +++++++++++++++++++++++++++++
 tests/basics/int_bytes_int64.py     | 52 ++++++++++++++++++++
 tests/basics/int_bytes_intbig.py    | 48 +++++++++++++++++++
 tests/cpydiff/types_int_to_bytes.py | 16 +++++++
 12 files changed, 302 insertions(+), 29 deletions(-)
 create mode 100644 tests/basics/int_bytes_int64.py
 create mode 100644 tests/cpydiff/types_int_to_bytes.py

diff --git a/docs/library/builtins.rst b/docs/library/builtins.rst
index 7a0229c2aaaf6..e489375b1f917 100644
--- a/docs/library/builtins.rst
+++ b/docs/library/builtins.rst
@@ -82,6 +82,10 @@ Functions and types
       In MicroPython, `byteorder` parameter must be positional (this is
       compatible with CPython).
 
+      .. note:: The optional ``signed`` kwarg from CPython is not supported.
+                MicroPython currently converts negative integers as signed,
+                and positive as unsigned. (:ref:`Details <cpydiff_types_int_to_bytes>`.)
+
 .. function:: isinstance()
 
 .. function:: issubclass()
diff --git a/py/misc.h b/py/misc.h
index 9f8a8c1e13e53..cf1810d4e784b 100644
--- a/py/misc.h
+++ b/py/misc.h
@@ -343,13 +343,46 @@ static uint32_t mp_clz(uint32_t x) {
     return _BitScanReverse(&lz, x) ? (sizeof(x) * 8 - 1) - lz : 0;
 }
 
+static uint32_t mp_clzl(unsigned long x) {
+    unsigned long lz = 0;
+    return _BitScanReverse(&lz, x) ? (sizeof(x) * 8 - 1) - lz : 0;
+}
+
+#ifdef _WIN64
+static uint32_t mp_clzll(unsigned long long x) {
+    unsigned long lz = 0;
+    return _BitScanReverse64(&lz, x) ? (sizeof(x) * 8 - 1) - lz : 0;
+}
+#else
+// Microsoft don't ship _BitScanReverse64 on Win32, so emulate it
+static uint32_t mp_clzll(unsigned long long x) {
+    unsigned long h = x >> 32;
+    return h ? mp_clzl(h) : (mp_clzl(x) + 32);
+}
+#endif
+
 static uint32_t mp_ctz(uint32_t x) {
     unsigned long tz = 0;
     return _BitScanForward(&tz, x) ? tz : 0;
 }
 #else
 #define mp_clz(x) __builtin_clz(x)
+#define mp_clzl(x) __builtin_clzl(x)
+#define mp_clzll(x) __builtin_clzll(x)
 #define mp_ctz(x) __builtin_ctz(x)
 #endif
 
+// mp_int_t can be larger than long, i.e. Windows 64-bit, nan-box variants
+static inline uint32_t mp_clz_mpi(mp_int_t x) {
+    MP_STATIC_ASSERT(sizeof(mp_int_t) == sizeof(long long)
+        || sizeof(mp_int_t) == sizeof(long));
+
+    // ugly, but should compile to single intrinsic unless O0 is set
+    if (sizeof(mp_int_t) == sizeof(long)) {
+        return mp_clzl(x);
+    } else {
+        return mp_clzll(x);
+    }
+}
+
 #endif // MICROPY_INCLUDED_PY_MISC_H
diff --git a/py/mpz.c b/py/mpz.c
index 502d4e1c138f0..750664ad9aaf8 100644
--- a/py/mpz.c
+++ b/py/mpz.c
@@ -1589,7 +1589,7 @@ bool mpz_as_uint_checked(const mpz_t *i, mp_uint_t *value) {
     return true;
 }
 
-void mpz_as_bytes(const mpz_t *z, bool big_endian, size_t len, byte *buf) {
+bool mpz_as_bytes(const mpz_t *z, bool big_endian, bool as_signed, size_t len, byte *buf) {
     byte *b = buf;
     if (big_endian) {
         b += len;
@@ -1598,6 +1598,8 @@ void mpz_as_bytes(const mpz_t *z, bool big_endian, size_t len, byte *buf) {
     int bits = 0;
     mpz_dbl_dig_t d = 0;
     mpz_dbl_dig_t carry = 1;
+    size_t olen = len; // bytes in output buffer
+    bool ok = true;
     for (size_t zlen = z->len; zlen > 0; --zlen) {
         bits += DIG_SIZE;
         d = (d << DIG_SIZE) | *zdig++;
@@ -1607,28 +1609,32 @@ void mpz_as_bytes(const mpz_t *z, bool big_endian, size_t len, byte *buf) {
                 val = (~val & 0xff) + carry;
                 carry = val >> 8;
             }
+
+            if (!olen) {
+                // Buffer is full, only OK if all remaining bytes are zeroes
+                ok = ok && ((byte)val == 0);
+                continue;
+            }
+
             if (big_endian) {
                 *--b = val;
-                if (b == buf) {
-                    return;
-                }
             } else {
                 *b++ = val;
-                if (b == buf + len) {
-                    return;
-                }
             }
+            olen--;
         }
     }
 
-    // fill remainder of buf with zero/sign extension of the integer
-    if (big_endian) {
-        len = b - buf;
+    if (as_signed && olen == 0 && len > 0) {
+        // If output exhausted then ensure there was enough space for the sign bit
+        byte most_sig = big_endian ? buf[0] : buf[len - 1];
+        ok = ok && (bool)(most_sig & 0x80) == (bool)z->neg;
     } else {
-        len = buf + len - b;
-        buf = b;
+        // fill remainder of buf with zero/sign extension of the integer
+        memset(big_endian ? buf : b, z->neg ? 0xff : 0x00, olen);
     }
-    memset(buf, z->neg ? 0xff : 0x00, len);
+
+    return ok;
 }
 
 #if MICROPY_PY_BUILTINS_FLOAT
diff --git a/py/mpz.h b/py/mpz.h
index d27f5724047ae..6f1ac930b0214 100644
--- a/py/mpz.h
+++ b/py/mpz.h
@@ -93,9 +93,9 @@ typedef int8_t mpz_dbl_dig_signed_t;
 typedef struct _mpz_t {
     // Zero has neg=0, len=0.  Negative zero is not allowed.
     size_t neg : 1;
-    size_t fixed_dig : 1;
-    size_t alloc : (8 * sizeof(size_t) - 2);
-    size_t len;
+    size_t fixed_dig : 1; // flag, 'dig' buffer cannot be reallocated
+    size_t alloc : (8 * sizeof(size_t) - 2); // number of entries allocated in 'dig'
+    size_t len; // number of entries used in 'dig'
     mpz_dig_t *dig;
 } mpz_t;
 
@@ -145,7 +145,8 @@ static inline size_t mpz_max_num_bits(const mpz_t *z) {
 mp_int_t mpz_hash(const mpz_t *z);
 bool mpz_as_int_checked(const mpz_t *z, mp_int_t *value);
 bool mpz_as_uint_checked(const mpz_t *z, mp_uint_t *value);
-void mpz_as_bytes(const mpz_t *z, bool big_endian, size_t len, byte *buf);
+// Returns true if 'z' fit into 'len' bytes of 'buf' without overflowing, 'buf' is truncated otherwise.
+bool mpz_as_bytes(const mpz_t *z, bool big_endian, bool as_signed, size_t len, byte *buf);
 #if MICROPY_PY_BUILTINS_FLOAT
 mp_float_t mpz_as_float(const mpz_t *z);
 #endif
diff --git a/py/objint.c b/py/objint.c
index 6caa608f33035..467a4714ef197 100644
--- a/py/objint.c
+++ b/py/objint.c
@@ -421,29 +421,50 @@ static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(int_from_bytes_fun_obj, 3, 4, int_fro
 static MP_DEFINE_CONST_CLASSMETHOD_OBJ(int_from_bytes_obj, MP_ROM_PTR(&int_from_bytes_fun_obj));
 
 static mp_obj_t int_to_bytes(size_t n_args, const mp_obj_t *args) {
-    // TODO: Support signed param (assumes signed=False)
+    // TODO: Support signed (currently behaves as if signed=(val < 0))
     (void)n_args;
+    bool overflow;
 
-    mp_int_t len = mp_obj_get_int(args[1]);
-    if (len < 0) {
+    mp_int_t dlen = mp_obj_get_int(args[1]);
+    if (dlen < 0) {
         mp_raise_ValueError(NULL);
     }
     bool big_endian = args[2] != MP_OBJ_NEW_QSTR(MP_QSTR_little);
 
     vstr_t vstr;
-    vstr_init_len(&vstr, len);
+    vstr_init_len(&vstr, dlen);
     byte *data = (byte *)vstr.buf;
-    memset(data, 0, len);
 
     #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
     if (!mp_obj_is_small_int(args[0])) {
-        mp_obj_int_to_bytes_impl(args[0], big_endian, len, data);
+        overflow = !mp_obj_int_to_bytes_impl(args[0], big_endian, dlen, data);
     } else
     #endif
     {
         mp_int_t val = MP_OBJ_SMALL_INT_VALUE(args[0]);
-        size_t l = MIN((size_t)len, sizeof(val));
-        mp_binary_set_int(l, big_endian, data + (big_endian ? (len - l) : 0), val);
+        int slen = 0;  // Number of bytes to represent val
+
+        // This logic has a twin in objint_longlong.c
+        if (val > 0) {
+            slen = (sizeof(mp_int_t) * 8 - mp_clz_mpi(val) + 7) / 8;
+        } else if (val < -1) {
+            slen = (sizeof(mp_int_t) * 8 - mp_clz_mpi(~val) + 8) / 8;
+        } else {
+            // clz of 0 is defined, so 0 and -1 map to 0 and 1
+            slen = -val;
+        }
+
+        if (slen <= dlen) {
+            memset(data, val < 0 ? 0xFF : 0x00, dlen);
+            mp_binary_set_int(slen, big_endian, data + (big_endian ? (dlen - slen) : 0), val);
+            overflow = false;
+        } else {
+            overflow = true;
+        }
+    }
+
+    if (overflow) {
+        mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("buffer too small"));
     }
 
     return mp_obj_new_bytes_from_vstr(&vstr);
diff --git a/py/objint.h b/py/objint.h
index 5eed87705dedb..28930e35adb49 100644
--- a/py/objint.h
+++ b/py/objint.h
@@ -55,7 +55,8 @@ char *mp_obj_int_formatted_impl(char **buf, size_t *buf_size, size_t *fmt_size,
     int base, const char *prefix, char base_char, char comma);
 mp_int_t mp_obj_int_hash(mp_obj_t self_in);
 mp_obj_t mp_obj_int_from_bytes_impl(bool big_endian, size_t len, const byte *buf);
-void mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf);
+// Returns true if 'self_in' fit into 'len' bytes of 'buf' without overflowing, 'buf' is truncated otherwise.
+bool mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf);
 int mp_obj_int_sign(mp_obj_t self_in);
 mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in);
 mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in);
diff --git a/py/objint_longlong.c b/py/objint_longlong.c
index ee499e0265b32..00fe5636c1607 100644
--- a/py/objint_longlong.c
+++ b/py/objint_longlong.c
@@ -57,10 +57,27 @@ mp_obj_t mp_obj_int_from_bytes_impl(bool big_endian, size_t len, const byte *buf
     return mp_obj_new_int_from_ll(value);
 }
 
-void mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf) {
+bool mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf) {
     assert(mp_obj_is_exact_type(self_in, &mp_type_int));
     mp_obj_int_t *self = self_in;
     long long val = self->val;
+    size_t slen; // Number of bytes to represent val
+
+    // This logic has a twin in objint.c
+    if (val > 0) {
+        slen = (sizeof(long long) * 8 - mp_clzll(val) + 7) / 8;
+    } else if (val < -1) {
+        slen = (sizeof(long long) * 8 - mp_clzll(~val) + 8) / 8;
+    } else {
+        // clz of 0 is defined, so 0 and -1 map to 0 and 1
+        slen = -val;
+    }
+
+    if (slen > len) {
+        return false; // Would overflow
+        // TODO: Determine whether to copy and truncate, as some callers probably expect this...?
+    }
+
     if (big_endian) {
         byte *b = buf + len;
         while (b > buf) {
@@ -73,6 +90,7 @@ void mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byt
             val >>= 8;
         }
     }
+    return true;
 }
 
 int mp_obj_int_sign(mp_obj_t self_in) {
diff --git a/py/objint_mpz.c b/py/objint_mpz.c
index 600316a42abba..4a1a685bbd42e 100644
--- a/py/objint_mpz.c
+++ b/py/objint_mpz.c
@@ -112,10 +112,10 @@ mp_obj_t mp_obj_int_from_bytes_impl(bool big_endian, size_t len, const byte *buf
     return MP_OBJ_FROM_PTR(o);
 }
 
-void mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf) {
+bool mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf) {
     assert(mp_obj_is_exact_type(self_in, &mp_type_int));
     mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
-    mpz_as_bytes(&self->mpz, big_endian, len, buf);
+    return mpz_as_bytes(&self->mpz, big_endian, self->mpz.neg, len, buf);
 }
 
 int mp_obj_int_sign(mp_obj_t self_in) {
diff --git a/tests/basics/int_bytes.py b/tests/basics/int_bytes.py
index d1837ea75ca4a..15c12640e951b 100644
--- a/tests/basics/int_bytes.py
+++ b/tests/basics/int_bytes.py
@@ -1,3 +1,5 @@
+import sys
+
 print((10).to_bytes(1, "little"))
 print((111111).to_bytes(4, "little"))
 print((100).to_bytes(10, "little"))
@@ -20,3 +22,74 @@
     (1).to_bytes(-1, "little")
 except ValueError:
     print("ValueError")
+
+# zero byte destination should also raise an error
+try:
+    (1).to_bytes(0, "little")
+except OverflowError:
+    print("OverflowError")
+
+# except for converting 0 to a zero-length byte array
+print((0).to_bytes(0, "big"))
+
+# byte length can fit the integer directly
+print((0xFF).to_bytes(1, "little"))
+print((0xFF).to_bytes(1, "big"))
+print((0xEFF).to_bytes(2, "little"))
+print((0xEFF).to_bytes(2, "big"))
+print((0xCDEFF).to_bytes(3, "little"))
+print((0xCDEFF).to_bytes(3, "big"))
+
+# OverFlowError if not big enough
+
+try:
+    (0x123).to_bytes(1, "big")
+except OverflowError:
+    print("OverflowError")
+
+try:
+    (0x12345).to_bytes(2, "big")
+except OverflowError:
+    print("OverflowError")
+
+try:
+    (0x1234567).to_bytes(3, "big")
+except OverflowError:
+    print("OverflowError")
+
+
+# negative representations
+
+# MicroPython int.to_bytes() behaves as if signed=True for negative numbers
+if "micropython" in repr(sys.implementation):
+
+    def to_bytes_compat(i, l, e):
+        return i.to_bytes(l, e)
+else:
+    # Implement MicroPython compatible behaviour for CPython
+    def to_bytes_compat(i, l, e):
+        return i.to_bytes(l, e, signed=i < 0)
+
+
+print(to_bytes_compat(-1, 1, "little"))
+print(to_bytes_compat(-1, 3, "little"))
+print(to_bytes_compat(-1, 1, "big"))
+print(to_bytes_compat(-1, 3, "big"))
+print(to_bytes_compat(-128, 1, "big"))
+print(to_bytes_compat(-32768, 2, "big"))
+print(to_bytes_compat(-(1 << 23), 3, "big"))
+
+try:
+    print(to_bytes_compat(-129, 1, "big"))
+except OverflowError:
+    print("OverflowError")
+
+try:
+    print(to_bytes_compat(-32769, 2, "big"))
+except OverflowError:
+    print("OverflowError")
+
+try:
+    print(to_bytes_compat(-(1 << 23) - 1, 2, "big"))
+except OverflowError:
+    print("OverflowError")
diff --git a/tests/basics/int_bytes_int64.py b/tests/basics/int_bytes_int64.py
new file mode 100644
index 0000000000000..032dbccc5b14e
--- /dev/null
+++ b/tests/basics/int_bytes_int64.py
@@ -0,0 +1,52 @@
+import sys
+
+# Depending on the port, the numbers in this test may be implemented as "small"
+# native 64 bit ints, arbitrary precision large ints, or large integers using 64-bit
+# long longs.
+
+try:
+    x = int.from_bytes(b"\x6F\xAB\xCD\x12\x34\x56\x78\xFB", "big")
+except OverflowError:
+    print("SKIP")  # Port can't represent this size of integer at all
+    raise SystemExit
+
+print(hex(x))
+b = x.to_bytes(8, "little")
+print(b)
+print(x.to_bytes(8, "big"))
+
+# padding in output
+print(x.to_bytes(20, "little"))
+print(x.to_bytes(20, "big"))
+
+# check that extra zero bytes don't change the internal int value
+print(int.from_bytes(b + bytes(10), "little") == x)
+
+# can't write to a zero-length bytes object
+try:
+    x.to_bytes(0, "little")
+except OverflowError:
+    print("OverflowError")
+
+# or one that it too short
+try:
+    x.to_bytes(7, "big")
+except OverflowError:
+    print("OverflowError")
+
+# negative representations
+
+# MicroPython int.to_bytes() behaves as if signed=True for negative numbers
+if "micropython" in repr(sys.implementation):
+
+    def to_bytes_compat(i, l, e):
+        return i.to_bytes(l, e)
+else:
+    # Implement MicroPython compatible behaviour for CPython
+    def to_bytes_compat(i, l, e):
+        return i.to_bytes(l, e, signed=i < 0)
+
+
+print(to_bytes_compat(-x, 8, "little"))
+print(to_bytes_compat(-x, 20, "big"))
+print(to_bytes_compat(-x, 20, "little"))
diff --git a/tests/basics/int_bytes_intbig.py b/tests/basics/int_bytes_intbig.py
index 147362bef1378..13cf5d0085890 100644
--- a/tests/basics/int_bytes_intbig.py
+++ b/tests/basics/int_bytes_intbig.py
@@ -1,3 +1,5 @@
+import sys
+
 print((2**64).to_bytes(9, "little"))
 print((2**64).to_bytes(9, "big"))
 
@@ -10,5 +12,51 @@
 print(il.to_bytes(20, "little"))
 print(ib.to_bytes(20, "big"))
 
+# check padding comes out correctly
+print(il.to_bytes(40, "little"))
+print(ib.to_bytes(40, "big"))
+
 # check that extra zero bytes don't change the internal int value
 print(int.from_bytes(b + bytes(10), "little") == int.from_bytes(b, "little"))
+
+# can't write to a zero-length bytes object
+try:
+    ib.to_bytes(0, "little")
+except OverflowError:
+    print("OverflowError")
+
+# or one that it too short
+try:
+    ib.to_bytes(18, "big")
+except OverflowError:
+    print("OverflowError")
+
+# negative representations
+
+# MicroPython int.to_bytes() behaves as if signed=True for negative numbers
+if "micropython" in repr(sys.implementation):
+
+    def to_bytes_compat(i, l, e):
+        return i.to_bytes(l, e)
+else:
+    # Implement MicroPython compatible behaviour for CPython
+    def to_bytes_compat(i, l, e):
+        return i.to_bytes(l, e, signed=i < 0)
+
+
+print(to_bytes_compat(-ib, 20, "big"))
+print(to_bytes_compat(ib * -ib, 40, "big"))
+
+# case where an additional byte is needed for sign bit
+ib = (2**64) - 1
+print(ib.to_bytes(8, "little"))
+
+ib *= -1
+
+try:
+    print(to_bytes_compat(ib, 8, "little"))
+except OverflowError:
+    print("OverflowError")
+
+print(to_bytes_compat(ib, 9, "little"))
+print(to_bytes_compat(ib, 9, "big"))
diff --git a/tests/cpydiff/types_int_to_bytes.py b/tests/cpydiff/types_int_to_bytes.py
new file mode 100644
index 0000000000000..6530a2a32ecb7
--- /dev/null
+++ b/tests/cpydiff/types_int_to_bytes.py
@@ -0,0 +1,16 @@
+"""
+categories: Types,int
+description: ``to_bytes`` method doesn't implement signed parameter.
+cause: The ``signed`` keyword-only parameter is not implemented for ``int.to_bytes()``.
+
+When the integer is negative, MicroPython behaves the same as CPython ``int.to_bytes(..., signed=True)``
+
+When the integer is non-negative, MicroPython behaves the same as CPython ``int.to_bytes(..., signed=False)``.
+
+(The difference is subtle, but in CPython a positive integer converted with ``signed=True`` may require one byte more in the output length, in order to fit the 0 sign bit.)
+
+workaround: Take care when calling ``to_bytes()`` on an integer value which may be negative.
+"""
+
+x = -1
+print(x.to_bytes(1, "big"))", "url": "https://github.com/micropython/micropython/commit/908ab1ceca15ee6fd0ef82ca4cba770a3ec41894.patch" } ]
null
PYSEC-2021-670
null
[ { "commit_message": "[PATCH] Fix `tf.raw_ops.QuantizeAndDequantizeV4Grad` CHECK failure. PiperOrigin-RevId: 370532425 Change-Id: I767721be266851b63d8fe55e7ac6be0af6017f6c tensorflow/core/kernels/quantize_and_dequantize_op.cc | 10 ++++++++++ 1 file changed, 10 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/tensorflow/tensorflow/commit/20431e9044cf2ad3c0323c34888b192f3289af6b.patch" } ]
null
CVE-2020-14214
Zammad before 3.3.1, when Domain Based Assignment is enabled, relies on a claimed e-mail address for authorization decisions. An attacker can register a new account that will have access to all tickets of an arbitrary Organization.
[ { "commit_message": "[PATCH] Fixes issue #2907 - Password strength settings are ignored when creating new customer accounts. Make login available to verified users only. .../app/controllers/email_verify.coffee | 57 ++++--------- .../javascripts/app/controllers/signup.coffee | 47 +++++++---- .../app/controllers/user_profile.coffee | 28 +++++++ .../widget/user_signup_check.coffee | 82 ------------------- .../app/views/signup/verify.jst.eco | 16 ++++ app/controllers/users_controller.rb | 26 +++--- app/models/user.rb | 2 +- lib/auth/internal.rb | 6 +- .../signup_password_change_and_reset_test.rb | 55 ++----------- 9 files changed, 120 insertions(+), 199 deletions(-) delete mode 100644 app/assets/javascripts/app/controllers/widget/user_signup_check.coffee create mode 100644 app/assets/javascripts/app/views/signup/verify.jst.eco", "patch_text_b64": "From 40148392426f626cb779c76d6bdda0f67bd6069d Mon Sep 17 00:00:00 2001
From: Rolf Schmidt <rolf.schmidt@znuny.com>
Date: Tue, 2 Jun 2020 14:21:08 +0200
Subject: [PATCH] Fixes issue #2907 - Password strength settings are ignored
 when creating new customer accounts. Make login available to verified users
 only.

---
 .../app/controllers/email_verify.coffee       | 57 ++++---------
 .../javascripts/app/controllers/signup.coffee | 47 +++++++----
 .../app/controllers/user_profile.coffee       | 28 +++++++
 .../widget/user_signup_check.coffee           | 82 -------------------
 .../app/views/signup/verify.jst.eco           | 16 ++++
 app/controllers/users_controller.rb           | 26 +++---
 app/models/user.rb                            |  2 +-
 lib/auth/internal.rb                          |  6 +-
 .../signup_password_change_and_reset_test.rb  | 55 ++-----------
 9 files changed, 120 insertions(+), 199 deletions(-)
 delete mode 100644 app/assets/javascripts/app/controllers/widget/user_signup_check.coffee
 create mode 100644 app/assets/javascripts/app/views/signup/verify.jst.eco

diff --git a/app/assets/javascripts/app/controllers/email_verify.coffee b/app/assets/javascripts/app/controllers/email_verify.coffee
index 1f0ad43a2e83..ae0c5b7d45c0 100644
--- a/app/assets/javascripts/app/controllers/email_verify.coffee
+++ b/app/assets/javascripts/app/controllers/email_verify.coffee
@@ -1,7 +1,6 @@
 class Index extends App.Controller
   constructor: ->
     super
-    @authenticateCheckRedirect()
     @verifyCall()
 
   verifyCall: =>
@@ -11,45 +10,23 @@ class Index extends App.Controller
       url:         "#{@apiPath}/users/email_verify"
       data:        JSON.stringify(token: @token)
       processData: true
-      success:     @success
-      error:       @error
-    )
-
-  success: =>
-    new Success(el: @el)
-
-  error: =>
-    new Fail(el: @el)
-
-class Success extends App.ControllerContent
-  constructor: ->
-    super
-    @render()
-
-    # rerender view, e. g. on language change
-    @bind 'ui:rerender', =>
-      @render()
-
-  render: =>
-    @renderScreenSuccess(
-      detail: 'Woo hoo! Your email address has been verified!'
-    )
-    delay = =>
-      @navigate '#'
-    @delay(delay, 20500)
-
-class Fail extends App.ControllerContent
-  constructor: ->
-    super
-    @render()
-
-    # rerender view, e. g. on language change
-    @bind 'ui:rerender', =>
-      @render()
-
-  render: =>
-    @renderScreenError(
-      detail: 'Unable to verify email. Please contact your administrator.'
+      success: (data, status, xhr) =>
+        App.Auth.loginCheck()
+        @navigate '#'
+
+        @notify
+          type:      'success'
+          msg:       App.i18n.translateContent('Woo hoo! Your email address has been verified!')
+          removeAll: true
+          timeout: 2000
+
+      error: (data, status, xhr) =>
+        @navigate '#'
+
+        @notify
+          type:      'error'
+          msg:       App.i18n.translateContent('Unable to verify email. Please contact your administrator.')
+          removeAll: true
     )
 
 App.Config.set('email_verify/:token', Index, 'Routes')
diff --git a/app/assets/javascripts/app/controllers/signup.coffee b/app/assets/javascripts/app/controllers/signup.coffee
index be1ec2cea0db..ff3374c58363 100644
--- a/app/assets/javascripts/app/controllers/signup.coffee
+++ b/app/assets/javascripts/app/controllers/signup.coffee
@@ -2,6 +2,7 @@ class Index extends App.ControllerContent
   events:
     'submit form': 'submit'
     'click .submit': 'submit'
+    'click .js-submitResend': 'resend'
     'click .cancel': 'cancel'
 
   constructor: ->
@@ -61,31 +62,41 @@ class Index extends App.ControllerContent
     # save user
     user.save(
       done: (r) =>
-        App.Auth.login(
-          data:
-            username: @params.login
-            password: @params.password
-          success: @success
-          error: @error
+        @html App.view('signup/verify')(
+          email: @params.email
         )
       fail: (settings, details) =>
         @formEnable(e)
-        @form.showAlert(details.error_human || details.error || 'Unable to update object!')
+        if _.isArray(details.error)
+          @form.showAlert( App.i18n.translateInline( details.error[0], details.error[1] ) )
+        else
+          @form.showAlert(details.error_human || details.error || 'Unable to update object!')
     )
 
-  success: (data, status, xhr) =>
+  resend: (e) =>
+    e.preventDefault()
+    @formDisable(e)
+    @resendParams = @formParam(e.target)
+
+    @ajax(
+      id:          'email_verify_send'
+      type:        'POST'
+      url:         @apiPath + '/users/email_verify_send'
+      data:        JSON.stringify(email: @resendParams.email)
+      processData: true
+      success: (data, status, xhr) =>
+        @formEnable(e)
 
-    # login check
-    App.Auth.loginCheck()
+        # add notify
+        @notify
+          type:      'success'
+          msg:       App.i18n.translateContent('Email sent to "%s". Please verify your email address.', @params.email)
+          removeAll: true
 
-    # add notify
-    @notify
-      type:      'success'
-      msg:       App.i18n.translateContent('Thanks for joining. Email sent to "%s". Please verify your email address.', @params.email)
-      removeAll: true
-
-    # redirect to #
-    @navigate '#'
+        if data.token && @Config.get('developer_mode') is true
+          @navigate "#email_verify/#{data.token}"
+      error: @error
+    )
 
   error: (xhr, statusText, error) =>
     detailsRaw = xhr.responseText
diff --git a/app/assets/javascripts/app/controllers/user_profile.coffee b/app/assets/javascripts/app/controllers/user_profile.coffee
index 9ea7773cd607..1fbfcf5c3b90 100644
--- a/app/assets/javascripts/app/controllers/user_profile.coffee
+++ b/app/assets/javascripts/app/controllers/user_profile.coffee
@@ -77,6 +77,8 @@ class App.UserProfile extends App.Controller
 class ActionRow extends App.ObserverActionRow
   model: 'User'
   observe:
+    verified: true
+    source: true
     organization_id: true
 
   showHistory: (user) =>
@@ -100,6 +102,25 @@ class ActionRow extends App.ObserverActionRow
   newTicket: (user) =>
     @navigate("ticket/create/customer/#{user.id}")
 
+  resendVerificationEmail: (user) =>
+    @ajax(
+      id:          'email_verify_send'
+      type:        'POST'
+      url:         @apiPath + '/users/email_verify_send'
+      data:        JSON.stringify(email: user.email)
+      processData: true
+      success: (data, status, xhr) =>
+        @notify
+          type:      'success'
+          msg:       App.i18n.translateContent('Email sent to "%s". Please let the user verify his email address.', user.email)
+          removeAll: true
+      error: (data, status, xhr) =>
+        @notify
+          type:      'error'
+          msg:       App.i18n.translateContent('Failed to sent Email "%s". Please contact an administrator.', user.email)
+          removeAll: true
+    )
+
   actions: (user) =>
     actions = [
       {
@@ -121,6 +142,13 @@ class ActionRow extends App.ObserverActionRow
         callback: @editUser
       }
 
+      if user.verified isnt true && user.source is 'signup'
+        actions.push({
+          name:     'resend_verification_email'
+          title:    'Resend verification email'
+          callback: @resendVerificationEmail
+        })
+
     actions
 
 class Object extends App.ObserverController
diff --git a/app/assets/javascripts/app/controllers/widget/user_signup_check.coffee b/app/assets/javascripts/app/controllers/widget/user_signup_check.coffee
deleted file mode 100644
index e42e3ba6dedf..000000000000
--- a/app/assets/javascripts/app/controllers/widget/user_signup_check.coffee
+++ /dev/null
@@ -1,82 +0,0 @@
-class Widget extends App.Controller
-  constructor: ->
-
-    # for browser test
-    App.Event.bind('user_signup_verify', (user) ->
-      new Modal(user: user)
-      'user_signup_verify'
-    )
-
-    App.Event.bind('auth:login', (user) =>
-      return if !user
-      @verifyLater(user.id)
-      'user_signup_verify'
-    )
-    user = App.User.current()
-    @verifyLater(user.id) if user?
-
-  verifyLater: (userId) =>
-    delay = =>
-      @verify(userId)
-    @delay(delay, 5000, 'user_signup_verify_dialog')
-
-  verify: (userId) ->
-    return if !userId
-    return if !App.User.exists(userId)
-    user = App.User.find(userId)
-    return if user.source isnt 'signup'
-    return if user.verified is true
-    currentTime = new Date().getTime()
-    createdAt = Date.parse(user.created_at)
-    diff = currentTime - createdAt
-    max = 1000 * 60 * 30 # show message if account is older then 30 minutes
-    return if diff < max
-    new Modal(user: user)
-
-class Modal extends App.ControllerModal
-  backdrop: false
-  keyboard: false
-  head: 'Account not verified'
-  small: true
-  buttonClose: false
-  buttonCancel: false
-  buttonSubmit: 'Resend verification email'
-
-  constructor: ->
-    super
-
-  content: =>
-    if !@sent
-      return App.i18n.translateContent('Your account has not been verified. Please click the link in the verification email.')
-    content = App.i18n.translateContent('We\'ve sent an email to _%s_. Click the link in the email to verify your account.', @user.email)
-    content += '<br><br>'
-    content += App.i18n.translateContent('If you don\'t see the email, check other places it might be, like your junk, spam, social, or other folders.')
-    content
-
-  onSubmit: =>
-    @ajax(
-      id:          'email_verify_send'
-      type:        'POST'
-      url:         @apiPath + '/users/email_verify_send'
-      data:        JSON.stringify(email: @user.email)
-      processData: true
-      success:     @success
-      error:       @error
-    )
-
-  success: (data) =>
-    @sent = true
-    @update()
-
-    # if in developer mode, redirect to verify
-    if data.token && @Config.get('developer_mode') is true
-      redirect = =>
-        @close()
-        @navigate "#email_verify/#{data.token}"
-      App.Delay.set(redirect, 4000)
-
-  error: =>
-    @contentInline = App.i18n.translateContent('Unable to send verify email.')
-    @update()
-
-App.Config.set('user_signup', Widget, 'Widgets')
diff --git a/app/assets/javascripts/app/views/signup/verify.jst.eco b/app/assets/javascripts/app/views/signup/verify.jst.eco
new file mode 100644
index 000000000000..fe9814eae41d
--- /dev/null
+++ b/app/assets/javascripts/app/views/signup/verify.jst.eco
@@ -0,0 +1,16 @@
+<div class="signup fullscreen">
+  <div class="fullscreen-center">
+    <div class="hero-unit fullscreen-body">
+      <h1><%- @T('Registration successful!') %></h1>
+      <p><%- @T('Thanks for joining. Email sent to "%s".', @email) %></p>
+      <p><%- @T('Please click the link in the verification email.') %> <%- @T('If you don\'t see the email, check other places it might be, like your junk, spam, social, or other folders.') %></p>
+      <form>
+        <input type="hidden" name="email" value="<%= @email %>">
+        <div class="form-controls">
+          <a class="btn btn--text btn--subtle js-cancel" href="#login"><%- @T('Go Back') %></a>
+          <button class="btn btn--primary js-submitResend align-right"><%- @T('Resend verification email') %></button>
+        </div>
+      </form>
+    </div>
+  </div>
+</div>
diff --git a/app/controllers/users_controller.rb b/app/controllers/users_controller.rb
index 45c3080fbeda..d8cd88313364 100644
--- a/app/controllers/users_controller.rb
+++ b/app/controllers/users_controller.rb
@@ -4,7 +4,7 @@ class UsersController < ApplicationController
   include ChecksUserAttributesByCurrentUserPermission
 
   prepend_before_action -> { authorize! }, only: %i[import_example import_start search history]
-  prepend_before_action :authentication_check, except: %i[create password_reset_send password_reset_verify image]
+  prepend_before_action :authentication_check, except: %i[create password_reset_send password_reset_verify image email_verify email_verify_send]
   prepend_before_action :authentication_check_only, only: [:create]
 
   # @path       [GET] /users
@@ -140,6 +140,15 @@ def create
       exists = User.exists?(email: clean_params[:email].downcase.strip)
       raise Exceptions::UnprocessableEntity, "Email address '#{clean_params[:email].downcase.strip}' is already used for other user." if exists
 
+      # check password policy
+      if clean_params[:password].present?
+        result = password_policy(clean_params[:password])
+        if result != true
+          render json: { error: result }, status: :unprocessable_entity
+          return
+        end
+      end
+
       user = User.new(clean_params)
       user.associations_from_param(params)
       user.updated_by_id = 1
@@ -499,6 +508,8 @@ def email_verify
     user = User.signup_verify_via_token(params[:token], current_user)
     raise Exceptions::UnprocessableEntity, 'Invalid token!' if !user
 
+    current_user_set(user)
+
     render json: { message: 'ok', user_email: user.email }, status: :ok
   end
 
@@ -527,17 +538,12 @@ def email_verify_send
     raise Exceptions::UnprocessableEntity, 'No email!' if !params[:email]
 
     user = User.find_by(email: params[:email].downcase)
-    if !user
+    if !user || user.verified == true
       # result is always positive to avoid leaking of existing user accounts
       render json: { message: 'ok' }, status: :ok
       return
     end
 
-    #if user.verified == true
-    #  render json: { error: 'Already verified!' }, status: :unprocessable_entity
-    #  return
-    #end
-
     Token.create(action: 'Signup', user_id: user.id)
 
     result = User.signup_new_token(user)
@@ -1029,13 +1035,13 @@ def import_start
 
   def password_policy(password)
     if Setting.get('password_min_size').to_i > password.length
-      return ["Can\'t update password, it must be at least %s characters long!", Setting.get('password_min_size')]
+      return ['Invalid password, it must be at least %s characters long!', Setting.get('password_min_size')]
     end
     if Setting.get('password_need_digit').to_i == 1 && password !~ /\d/
-      return ["Can't update password, it must contain at least 1 digit!"]
+      return ['Invalid password, it must contain at least 1 digit!']
     end
     if Setting.get('password_min_2_lower_2_upper_characters').to_i == 1 && ( password !~ /[A-Z].*[A-Z]/ || password !~ /[a-z].*[a-z]/ )
-      return ["Can't update password, it must contain at least 2 lowercase and 2 uppercase characters!"]
+      return ['Invalid password, it must contain at least 2 lowercase and 2 uppercase characters!']
     end
 
     true
diff --git a/app/models/user.rb b/app/models/user.rb
index c5b3a3e1d1df..d4076a9ed7bf 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -586,7 +586,7 @@ def self.password_reset_via_token(token, password)
     return if !user
 
     # reset password
-    user.update!(password: password)
+    user.update!(password: password, verified: true)
 
     # delete token
     Token.find_by(action: 'PasswordReset', name: token).destroy
diff --git a/lib/auth/internal.rb b/lib/auth/internal.rb
index 5da889903c3f..60ccb771b171 100644
--- a/lib/auth/internal.rb
+++ b/lib/auth/internal.rb
@@ -12,7 +12,11 @@ def valid?(user, password)
         return true
       end
 
-      PasswordHash.verified?(user.password, password)
+      password_verified = PasswordHash.verified?(user.password, password)
+
+      raise Exceptions::NotAuthorized, 'Please verify your account before you can login!' if !user.verified && user.source == 'signup' && password_verified
+
+      password_verified
     end
 
     private
diff --git a/test/browser/signup_password_change_and_reset_test.rb b/test/browser/signup_password_change_and_reset_test.rb
index 333329384e3c..aa868db5660c 100644
--- a/test/browser/signup_password_change_and_reset_test.rb
+++ b/test/browser/signup_password_change_and_reset_test.rb
@@ -23,65 +23,26 @@ def test_signup
     )
     set(
       css:   'input[name="password"]',
-      value: 'some-pass',
+      value: 'some-pass-123',
     )
     set(
       css:   'input[name="password_confirm"]',
-      value: 'some-pass',
+      value: 'some-pass-123',
     )
     click(css: 'button.js-submit')
 
-    watch_for_disappear(
-      css:     '.signup',
-      timeout: 10,
-    )
-
-    match(
-      css:       '.user-menu .user a',
-      value:     signup_user_email,
-      attribute: 'title',
-    )
-
-    # check email verify
-    location(url: "#{browser_url}#email_verify/not_existing")
     watch_for(
       css:   '#content',
-      value: 'Unable to verify email',
+      value: 'Registration successful!',
     )
-    logout()
 
-    login(
-      username: signup_user_email,
-      password: 'some-pass',
-      url:      "#{browser_url}#email_verify/not_existing2",
-    )
-    watch_for(
-      css:   '#content',
-      value: 'Unable to verify email',
-    )
-    execute(
-      js: 'App.Event.trigger("user_signup_verify", App.Session.get())',
-    )
-    modal_ready()
-    click(css: '.modal .js-submit')
+    # auto login via token trick in dev mode
+    click(css: '.signup .js-submitResend')
 
-    execute(
-      js: 'App.Auth.logout()',
-    )
-    sleep 6
     watch_for(
-      css: '#login',
-    )
-    login(
-      username: signup_user_email,
-      password: 'some-pass',
-    )
-    watch_for(
-      css:   '#content',
-      value: 'Your email address has been verified',
+      css:   '.content.active',
+      value: 'Welcome!',
     )
-    modal_disappear()
-    sleep 2
 
     # change password
     click(css: '.navbar-items-personal .user a')
@@ -109,7 +70,7 @@ def test_signup
 
     set(
       css:   'input[name="password_old"]',
-      value: 'some-pass',
+      value: 'some-pass-123',
     )
     set(
       css:   'input[name="password_new_confirm"]',", "url": "https://github.com/zammad/zammad/commit/40148392426f626cb779c76d6bdda0f67bd6069d.patch" } ]
n/a
GHSA-92wm-vqxv-vpf9
null
[ { "commit_message": "[PATCH] add some additonal permission checks to the webdav backend apps/dav/lib/connector/sabre/objecttree.php | 33 ++++++++++++++++--- .../tests/unit/connector/sabre/objecttree.php | 20 +++++++++++ .../integration/features/bootstrap/WebDav.php | 18 +++++++++- .../features/webdav-related.feature | 32 ++++++++++++++++++ 4 files changed, 97 insertions(+), 6 deletions(-)", "patch_text_b64": "From 3491400261c1454a9a30d3ec96969573330120cc Mon Sep 17 00:00:00 2001
From: Bjoern Schiessle <bjoern@schiessle.org>
Date: Thu, 30 Jun 2016 15:05:13 +0200
Subject: [PATCH] add some additonal permission checks to the webdav backend

---
 apps/dav/lib/connector/sabre/objecttree.php   | 33 ++++++++++++++++---
 .../tests/unit/connector/sabre/objecttree.php | 20 +++++++++++
 .../integration/features/bootstrap/WebDav.php | 18 +++++++++-
 .../features/webdav-related.feature           | 32 ++++++++++++++++++
 4 files changed, 97 insertions(+), 6 deletions(-)

diff --git a/apps/dav/lib/connector/sabre/objecttree.php b/apps/dav/lib/connector/sabre/objecttree.php
index f38dfe679c758..c952a68e9a2b3 100644
--- a/apps/dav/lib/connector/sabre/objecttree.php
+++ b/apps/dav/lib/connector/sabre/objecttree.php
@@ -71,7 +71,7 @@ public function init(\Sabre\DAV\INode $rootNode, \OC\Files\View $view, \OCP\File
 	 * is present.
 	 *
 	 * @param string $path chunk file path to convert
-	 * 
+	 *
 	 * @return string path to real file
 	 */
 	private function resolveChunkFile($path) {
@@ -184,16 +184,29 @@ public function getNodeForPath($path) {
 	 *
 	 * @param string $sourcePath The path to the file which should be moved
 	 * @param string $destinationPath The full destination path, so not just the destination parent node
-	 * @throws \Sabre\DAV\Exception\BadRequest
-	 * @throws \Sabre\DAV\Exception\ServiceUnavailable
-	 * @throws \Sabre\DAV\Exception\Forbidden
 	 * @return int
+	 * @throws FileLocked
+	 * @throws Forbidden
+	 * @throws InvalidPath
+	 * @throws \Sabre\DAV\Exception\Forbidden
+	 * @throws \Sabre\DAV\Exception\Locked
+	 * @throws \Sabre\DAV\Exception\NotFound
+	 * @throws \Sabre\DAV\Exception\ServiceUnavailable
 	 */
 	public function move($sourcePath, $destinationPath) {
 		if (!$this->fileView) {
 			throw new \Sabre\DAV\Exception\ServiceUnavailable('filesystem not setup');
 		}
 
+		$infoDestination = $this->fileView->getFileInfo(dirname($destinationPath));
+		$infoSource = $this->fileView->getFileInfo($sourcePath);
+		$destinationPermission = $infoDestination && $infoDestination->isUpdateable();
+		$sourcePermission =  $infoSource && $infoSource->isDeletable();
+
+		if (!$destinationPermission || !$sourcePermission) {
+			throw new Forbidden('No permissions to move object.');
+		}
+
 		$targetNodeExists = $this->nodeExists($destinationPath);
 		$sourceNode = $this->getNodeForPath($sourcePath);
 		if ($sourceNode instanceof \Sabre\DAV\ICollection && $targetNodeExists) {
@@ -263,14 +276,24 @@ public function move($sourcePath, $destinationPath) {
 	 *
 	 * @param string $source
 	 * @param string $destination
+	 * @throws FileLocked
+	 * @throws Forbidden
+	 * @throws InvalidPath
+	 * @throws \Exception
+	 * @throws \Sabre\DAV\Exception\Locked
+	 * @throws \Sabre\DAV\Exception\NotFound
 	 * @throws \Sabre\DAV\Exception\ServiceUnavailable
-	 * @return void
 	 */
 	public function copy($source, $destination) {
 		if (!$this->fileView) {
 			throw new \Sabre\DAV\Exception\ServiceUnavailable('filesystem not setup');
 		}
 
+		$info = $this->fileView->getFileInfo(dirname($destination));
+		if ($info && !$info->isUpdateable()) {
+			throw new Forbidden('No permissions to copy object.');
+		}
+		
 		// this will trigger existence check
 		$this->getNodeForPath($source);
 
diff --git a/apps/dav/tests/unit/connector/sabre/objecttree.php b/apps/dav/tests/unit/connector/sabre/objecttree.php
index e5e858ef17b36..5b0dcae21b544 100644
--- a/apps/dav/tests/unit/connector/sabre/objecttree.php
+++ b/apps/dav/tests/unit/connector/sabre/objecttree.php
@@ -56,6 +56,11 @@ public function rename($path1, $path2) {
 	public function getRelativePath($path) {
 		return $path;
 	}
+
+	public function getFileInfo($path, $includeMountPoints = true) {
+		$objectTreeTest = new ObjectTreeTest();
+		return $objectTreeTest->getFileInfoMock();
+	}
 }
 
 /**
@@ -67,6 +72,21 @@ public function getRelativePath($path) {
  */
 class ObjectTree extends \Test\TestCase {
 
+	public function getFileInfoMock() {
+		$mock = $this->getMock('\OCP\Files\FileInfo');
+		$mock
+			->expects($this->any())
+			->method('isDeletable')
+			->willReturn(true);
+		$mock
+			->expects($this->any())
+			->method('isUpdateable')
+			->willReturn(true);
+
+		return $mock;
+	}
+
+
 	/**
 	 * @dataProvider moveFailedProvider
 	 * @expectedException \Sabre\DAV\Exception\Forbidden
diff --git a/build/integration/features/bootstrap/WebDav.php b/build/integration/features/bootstrap/WebDav.php
index 0a4624ccc2b1c..785c20325bbf6 100644
--- a/build/integration/features/bootstrap/WebDav.php
+++ b/build/integration/features/bootstrap/WebDav.php
@@ -64,9 +64,25 @@ public function userMovesFile($user, $fileSource, $fileDestination){
 		$this->response = $this->makeDavRequest($user, "MOVE", $fileSource, $headers);
 	}
 
+
+
 	/**
-	 * @When /^Downloading file "([^"]*)" with range "([^"]*)"$/
+	 * @When /^User "([^"]*)" copies file "([^"]*)" to "([^"]*)"$/
+	 * @param string $user
+	 * @param string $fileSource
+	 * @param string $fileDestination
 	 */
+	public function userCopiesFileTo($user, $fileSource, $fileDestination) {
+		$fullUrl = substr($this->baseUrl, 0, -4) . $this->davPath;
+		$headers['Destination'] = $fullUrl . $fileDestination;
+		try {
+			$this->response = $this->makeDavRequest($user, 'COPY', $fileSource, $headers);
+		} catch (\GuzzleHttp\Exception\ClientException $e) {
+			// 4xx and 5xx responses cause an exception
+			$this->response = $e->getResponse();
+		}
+	}
+
 	public function downloadFileWithRange($fileSource, $range){
 		$fullUrl = substr($this->baseUrl, 0, -4) . $this->davPath;
 		$headers['Range'] = $range;
diff --git a/build/integration/features/webdav-related.feature b/build/integration/features/webdav-related.feature
index c6d2919db8de3..577c85564bf41 100644
--- a/build/integration/features/webdav-related.feature
+++ b/build/integration/features/webdav-related.feature
@@ -241,3 +241,35 @@ Feature: webdav-related
 			| 0 |
 			| 1 |
 			| 3 |
+
+
+	Scenario: Copying files into a folder with edit permissions
+		Given using dav path "remote.php/webdav"
+		And user "user0" exists
+		And user "user1" exists
+		And As an "user1"
+		And user "user1" created a folder "/testcopypermissionsAllowed"
+		And as "user1" creating a share with
+			| path | testcopypermissionsAllowed |
+			| shareType | 0 |
+			| permissions | 31 |
+			| shareWith | user0 |
+		And User "user0" uploads file with content "copytest" to "/copytest.txt"
+		When User "user0" copies file "/copytest.txt" to "/testcopypermissionsAllowed/copytest.txt"
+		Then the HTTP status code should be "201"
+
+
+	Scenario: Copying files into a folder without edit permissions
+		Given using dav path "remote.php/webdav"
+		And user "user0" exists
+		And user "user1" exists
+		And As an "user1"
+		And user "user1" created a folder "/testcopypermissionsNotAllowed"
+		And as "user1" creating a share with
+			| path | testcopypermissionsNotAllowed |
+			| shareType | 0 |
+			| permissions | 1 |
+			| shareWith | user0 |
+		And User "user0" uploads file with content "copytest" to "/copytest.txt"
+		When User "user0" copies file "/copytest.txt" to "/testcopypermissionsNotAllowed/copytest.txt"
+		Then the HTTP status code should be "403"", "url": "https://github.com/nextcloud/server/commit/3491400261c1454a9a30d3ec96969573330120cc.patch" }, { "commit_message": "[PATCH] Additional perm check in Webdav lib/private/connector/sabre/objecttree.php | 5 ++ tests/lib/connector/sabre/objecttree.php | 82 ++++++++++++++++++++++ 2 files changed, 87 insertions(+)", "patch_text_b64": "RnJvbSAwNjIyZTYzNWQ5N2NiMTdjNWUxMzYzZTM3MGJiODI2OGNjM2QyNTQ3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBWaW5jZW50IFBldHJ5IDxwdmluY2U4MUBvd25jbG91ZC5jb20+CkRhdGU6IFdlZCwgNiBKdWwgMjAxNiAxNzo1NDoxOCArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIEFkZGl0aW9uYWwgcGVybSBjaGVjayBpbiBXZWJkYXYKCi0tLQogbGliL3ByaXZhdGUvY29ubmVjdG9yL3NhYnJlL29iamVjdHRyZWUucGhwIHwgIDUgKysKIHRlc3RzL2xpYi9jb25uZWN0b3Ivc2FicmUvb2JqZWN0dHJlZS5waHAgICB8IDgyICsrKysrKysrKysrKysrKysrKysrKysKIDIgZmlsZXMgY2hhbmdlZCwgODcgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2xpYi9wcml2YXRlL2Nvbm5lY3Rvci9zYWJyZS9vYmplY3R0cmVlLnBocCBiL2xpYi9wcml2YXRlL2Nvbm5lY3Rvci9zYWJyZS9vYmplY3R0cmVlLnBocAppbmRleCA4YWFmMjZmMGNjMGYuLmVkNjdjM2YyYzE2ZiAxMDA2NDQKLS0tIGEvbGliL3ByaXZhdGUvY29ubmVjdG9yL3NhYnJlL29iamVjdHRyZWUucGhwCisrKyBiL2xpYi9wcml2YXRlL2Nvbm5lY3Rvci9zYWJyZS9vYmplY3R0cmVlLnBocApAQCAtMjcwLDYgKzI3MCwxMSBAQCBwdWJsaWMgZnVuY3Rpb24gY29weSgkc291cmNlLCAkZGVzdGluYXRpb24pIHsKIAkJCXRocm93IG5ldyBJbnZhbGlkUGF0aCgkZXgtPmdldE1lc3NhZ2UoKSk7CiAJCX0KIAorCQkvLyBXZWJkYXYncyBjb3B5IHdpbGwgaW1wbGljaXRseSBkbyBhIGRlbGV0ZStjcmVhdGUsIHNvIG9ubHkgY3JlYXRlK2RlbGV0ZSBwZXJtaXNzaW9ucyBhcmUgcmVxdWlyZWQKKwkJaWYgKCEkdGhpcy0+ZmlsZVZpZXctPmlzQ3JlYXRhYmxlKCRkZXN0aW5hdGlvbkRpcikpIHsKKwkJCXRocm93IG5ldyBcU2FicmVcREFWXEV4Y2VwdGlvblxGb3JiaWRkZW4oKTsKKwkJfQorCiAJCXRyeSB7CiAJCQkkdGhpcy0+ZmlsZVZpZXctPmNvcHkoJHNvdXJjZSwgJGRlc3RpbmF0aW9uKTsKIAkJfSBjYXRjaCAoU3RvcmFnZU5vdEF2YWlsYWJsZUV4Y2VwdGlvbiAkZSkgewpkaWZmIC0tZ2l0IGEvdGVzdHMvbGliL2Nvbm5lY3Rvci9zYWJyZS9vYmplY3R0cmVlLnBocCBiL3Rlc3RzL2xpYi9jb25uZWN0b3Ivc2FicmUvb2JqZWN0dHJlZS5waHAKaW5kZXggNjIwYTg1MzgzNTMwLi42ZDAwMmY3MzdmMWUgMTAwNjQ0Ci0tLSBhL3Rlc3RzL2xpYi9jb25uZWN0b3Ivc2FicmUvb2JqZWN0dHJlZS5waHAKKysrIGIvdGVzdHMvbGliL2Nvbm5lY3Rvci9zYWJyZS9vYmplY3R0cmVlLnBocApAQCAtMTE5LDYgKzExOSw4OCBAQCBwcml2YXRlIGZ1bmN0aW9uIG1vdmVUZXN0KCRzb3VyY2UsICRkZXN0aW5hdGlvbiwgJHVwZGF0YWJsZXMsICRkZWxldGFibGVzKSB7CiAJCSRvYmplY3RUcmVlLT5tb3ZlKCRzb3VyY2UsICRkZXN0aW5hdGlvbik7CiAJfQogCisJcHVibGljIGZ1bmN0aW9uIGNvcHlEYXRhUHJvdmlkZXIoKSB7CisJCXJldHVybiBbCisJCQkvLyBjb3B5IGludG8gc2FtZSBkaXIKKwkJCVsnYScsICdiJywgJyddLAorCQkJLy8gY29weSBpbnRvIHNhbWUgZGlyCisJCQlbJ2EvYScsICdhL2InLCAnYSddLAorCQkJLy8gY29weSBpbnRvIGFub3RoZXIgZGlyCisJCQlbJ2EnLCAnc3ViL2EnLCAnc3ViJ10sCisJCV07CisJfQorCisJLyoqCisJICogQGRhdGFQcm92aWRlciBjb3B5RGF0YVByb3ZpZGVyCisJICovCisJcHVibGljIGZ1bmN0aW9uIHRlc3RDb3B5KCRzb3VyY2VQYXRoLCAkdGFyZ2V0UGF0aCwgJHRhcmdldFBhcmVudCkgeworCQkkdmlldyA9ICR0aGlzLT5nZXRNb2NrKCdcT0NcRmlsZXNcVmlldycpOworCQkkdmlldy0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQorCQkJLT5tZXRob2QoJ3ZlcmlmeVBhdGgnKQorCQkJLT53aXRoKCR0YXJnZXRQYXJlbnQpCisJCQktPndpbGwoJHRoaXMtPnJldHVyblZhbHVlKHRydWUpKTsKKwkJJHZpZXctPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKKwkJCS0+bWV0aG9kKCdpc0NyZWF0YWJsZScpCisJCQktPndpdGgoJHRhcmdldFBhcmVudCkKKwkJCS0+d2lsbCgkdGhpcy0+cmV0dXJuVmFsdWUodHJ1ZSkpOworCQkkdmlldy0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQorCQkJLT5tZXRob2QoJ2NvcHknKQorCQkJLT53aXRoKCRzb3VyY2VQYXRoLCAkdGFyZ2V0UGF0aCkKKwkJCS0+d2lsbCgkdGhpcy0+cmV0dXJuVmFsdWUodHJ1ZSkpOworCisJCSRpbmZvID0gbmV3IEZpbGVJbmZvKCcnLCBudWxsLCBudWxsLCBhcnJheSgpLCBudWxsKTsKKworCQkkcm9vdERpciA9IG5ldyBcT0NcQ29ubmVjdG9yXFNhYnJlXERpcmVjdG9yeSgkdmlldywgJGluZm8pOworCQkkb2JqZWN0VHJlZSA9ICR0aGlzLT5nZXRNb2NrKCdcT0NcQ29ubmVjdG9yXFNhYnJlXE9iamVjdFRyZWUnLAorCQkJYXJyYXkoJ25vZGVFeGlzdHMnLCAnZ2V0Tm9kZUZvclBhdGgnKSwKKwkJCWFycmF5KCRyb290RGlyLCAkdmlldykpOworCisJCSRvYmplY3RUcmVlLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCisJCQktPm1ldGhvZCgnZ2V0Tm9kZUZvclBhdGgnKQorCQkJLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygkc291cmNlUGF0aCkpCisJCQktPndpbGwoJHRoaXMtPnJldHVyblZhbHVlKGZhbHNlKSk7CisKKwkJLyoqIEB2YXIgJG9iamVjdFRyZWUgXE9DXENvbm5lY3RvclxTYWJyZVxPYmplY3RUcmVlICovCisJCSRtb3VudE1hbmFnZXIgPSBcT0NcRmlsZXNcRmlsZXN5c3RlbTo6Z2V0TW91bnRNYW5hZ2VyKCk7CisJCSRvYmplY3RUcmVlLT5pbml0KCRyb290RGlyLCAkdmlldywgJG1vdW50TWFuYWdlcik7CisJCSRvYmplY3RUcmVlLT5jb3B5KCRzb3VyY2VQYXRoLCAkdGFyZ2V0UGF0aCk7CisJfQorCisJLyoqCisJICogQGRhdGFQcm92aWRlciBjb3B5RGF0YVByb3ZpZGVyCisJICogQGV4cGVjdGVkRXhjZXB0aW9uIFxTYWJyZVxEQVZcRXhjZXB0aW9uXEZvcmJpZGRlbgorCSAqLworCXB1YmxpYyBmdW5jdGlvbiB0ZXN0Q29weUZhaWxOb3RDcmVhdGFibGUoJHNvdXJjZVBhdGgsICR0YXJnZXRQYXRoLCAkdGFyZ2V0UGFyZW50KSB7CisJCSR2aWV3ID0gJHRoaXMtPmdldE1vY2soJ1xPQ1xGaWxlc1xWaWV3Jyk7CisJCSR2aWV3LT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCisJCQktPm1ldGhvZCgndmVyaWZ5UGF0aCcpCisJCQktPndpdGgoJHRhcmdldFBhcmVudCkKKwkJCS0+d2lsbCgkdGhpcy0+cmV0dXJuVmFsdWUodHJ1ZSkpOworCQkkdmlldy0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQorCQkJLT5tZXRob2QoJ2lzQ3JlYXRhYmxlJykKKwkJCS0+d2l0aCgkdGFyZ2V0UGFyZW50KQorCQkJLT53aWxsKCR0aGlzLT5yZXR1cm5WYWx1ZShmYWxzZSkpOworCQkkdmlldy0+ZXhwZWN0cygkdGhpcy0+bmV2ZXIoKSkKKwkJCS0+bWV0aG9kKCdjb3B5Jyk7CisKKwkJJGluZm8gPSBuZXcgRmlsZUluZm8oJycsIG51bGwsIG51bGwsIGFycmF5KCksIG51bGwpOworCisJCSRyb290RGlyID0gbmV3IFxPQ1xDb25uZWN0b3JcU2FicmVcRGlyZWN0b3J5KCR2aWV3LCAkaW5mbyk7CisJCSRvYmplY3RUcmVlID0gJHRoaXMtPmdldE1vY2soJ1xPQ1xDb25uZWN0b3JcU2FicmVcT2JqZWN0VHJlZScsCisJCQlhcnJheSgnbm9kZUV4aXN0cycsICdnZXROb2RlRm9yUGF0aCcpLAorCQkJYXJyYXkoJHJvb3REaXIsICR2aWV3KSk7CisKKwkJJG9iamVjdFRyZWUtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKKwkJCS0+bWV0aG9kKCdnZXROb2RlRm9yUGF0aCcpCisJCQktPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKCRzb3VyY2VQYXRoKSkKKwkJCS0+d2lsbCgkdGhpcy0+cmV0dXJuVmFsdWUoZmFsc2UpKTsKKworCQkvKiogQHZhciAkb2JqZWN0VHJlZSBcT0NcQ29ubmVjdG9yXFNhYnJlXE9iamVjdFRyZWUgKi8KKwkJJG1vdW50TWFuYWdlciA9IFxPQ1xGaWxlc1xGaWxlc3lzdGVtOjpnZXRNb3VudE1hbmFnZXIoKTsKKwkJJG9iamVjdFRyZWUtPmluaXQoJHJvb3REaXIsICR2aWV3LCAkbW91bnRNYW5hZ2VyKTsKKwkJJG9iamVjdFRyZWUtPmNvcHkoJHNvdXJjZVBhdGgsICR0YXJnZXRQYXRoKTsKKwl9CisKIAkvKioKIAkgKiBAZGF0YVByb3ZpZGVyIG5vZGVGb3JQYXRoUHJvdmlkZXIKIAkgKi8=", "url": "https://github.com/owncloud/core/commit/0622e635d97cb17c5e1363e370bb8268cc3d2547.patch" }, { "commit_message": "[PATCH] Additional perm check in Webdav apps/dav/lib/connector/sabre/objecttree.php | 5 + .../tests/unit/connector/sabre/objecttree.php | 82 +++++++++++++ .../integration/features/bootstrap/WebDav.php | 28 ++++- .../features/webdav-related.feature | 111 +++++++++++++++++- 4 files changed, 222 insertions(+), 4 deletions(-)", "patch_text_b64": "From 121a3304a0c37ccda0e1b63ddc528cba9121a36e Mon Sep 17 00:00:00 2001
From: Vincent Petry <pvince81@owncloud.com>
Date: Wed, 6 Jul 2016 17:54:18 +0200
Subject: [PATCH] Additional perm check in Webdav

---
 apps/dav/lib/connector/sabre/objecttree.php   |   5 +
 .../tests/unit/connector/sabre/objecttree.php |  82 +++++++++++++
 .../integration/features/bootstrap/WebDav.php |  28 ++++-
 .../features/webdav-related.feature           | 111 +++++++++++++++++-
 4 files changed, 222 insertions(+), 4 deletions(-)

diff --git a/apps/dav/lib/connector/sabre/objecttree.php b/apps/dav/lib/connector/sabre/objecttree.php
index f38dfe679c75..b26cc68b2622 100644
--- a/apps/dav/lib/connector/sabre/objecttree.php
+++ b/apps/dav/lib/connector/sabre/objecttree.php
@@ -281,6 +281,11 @@ public function copy($source, $destination) {
 			throw new InvalidPath($ex->getMessage());
 		}
 
+		// Webdav's copy will implicitly do a delete+create, so only create+delete permissions are required
+		if (!$this->fileView->isCreatable($destinationDir)) {
+			throw new \Sabre\DAV\Exception\Forbidden();
+		}
+
 		try {
 			$this->fileView->copy($source, $destination);
 		} catch (StorageNotAvailableException $e) {
diff --git a/apps/dav/tests/unit/connector/sabre/objecttree.php b/apps/dav/tests/unit/connector/sabre/objecttree.php
index e5e858ef17b3..a04b501bc6cc 100644
--- a/apps/dav/tests/unit/connector/sabre/objecttree.php
+++ b/apps/dav/tests/unit/connector/sabre/objecttree.php
@@ -142,6 +142,88 @@ private function moveTest($source, $destination, $updatables, $deletables) {
 		$objectTree->move($source, $destination);
 	}
 
+	public function copyDataProvider() {
+		return [
+			// copy into same dir
+			['a', 'b', ''],
+			// copy into same dir
+			['a/a', 'a/b', 'a'],
+			// copy into another dir
+			['a', 'sub/a', 'sub'],
+		];
+	}
+
+	/**
+	 * @dataProvider copyDataProvider
+	 */
+	public function testCopy($sourcePath, $targetPath, $targetParent) {
+		$view = $this->getMock('\OC\Files\View');
+		$view->expects($this->once())
+			->method('verifyPath')
+			->with($targetParent)
+			->will($this->returnValue(true));
+		$view->expects($this->once())
+			->method('isCreatable')
+			->with($targetParent)
+			->will($this->returnValue(true));
+		$view->expects($this->once())
+			->method('copy')
+			->with($sourcePath, $targetPath)
+			->will($this->returnValue(true));
+
+		$info = new FileInfo('', null, null, array(), null);
+
+		$rootDir = new \OCA\DAV\Connector\Sabre\Directory($view, $info);
+		$objectTree = $this->getMock('\OCA\DAV\Connector\Sabre\ObjectTree',
+			array('nodeExists', 'getNodeForPath'),
+			array($rootDir, $view));
+
+		$objectTree->expects($this->once())
+			->method('getNodeForPath')
+			->with($this->identicalTo($sourcePath))
+			->will($this->returnValue(false));
+
+		/** @var $objectTree \OCA\DAV\Connector\Sabre\ObjectTree */
+		$mountManager = \OC\Files\Filesystem::getMountManager();
+		$objectTree->init($rootDir, $view, $mountManager);
+		$objectTree->copy($sourcePath, $targetPath);
+	}
+
+	/**
+	 * @dataProvider copyDataProvider
+	 * @expectedException \Sabre\DAV\Exception\Forbidden
+	 */
+	public function testCopyFailNotCreatable($sourcePath, $targetPath, $targetParent) {
+		$view = $this->getMock('\OC\Files\View');
+		$view->expects($this->once())
+			->method('verifyPath')
+			->with($targetParent)
+			->will($this->returnValue(true));
+		$view->expects($this->once())
+			->method('isCreatable')
+			->with($targetParent)
+			->will($this->returnValue(false));
+		$view->expects($this->never())
+			->method('copy');
+
+		$info = new FileInfo('', null, null, array(), null);
+
+		$rootDir = new \OCA\DAV\Connector\Sabre\Directory($view, $info);
+		$objectTree = $this->getMock('\OCA\DAV\Connector\Sabre\ObjectTree',
+			array('nodeExists', 'getNodeForPath'),
+			array($rootDir, $view));
+
+		$objectTree->expects($this->once())
+			->method('getNodeForPath')
+			->with($this->identicalTo($sourcePath))
+			->will($this->returnValue(false));
+
+		/** @var $objectTree \OCA\DAV\Connector\Sabre\ObjectTree */
+		$mountManager = \OC\Files\Filesystem::getMountManager();
+		$objectTree->init($rootDir, $view, $mountManager);
+		$objectTree->copy($sourcePath, $targetPath);
+	}
+
 	/**
 	 * @dataProvider nodeForPathProvider
 	 */
diff --git a/build/integration/features/bootstrap/WebDav.php b/build/integration/features/bootstrap/WebDav.php
index 0a4624ccc2b1..f7861399d768 100644
--- a/build/integration/features/bootstrap/WebDav.php
+++ b/build/integration/features/bootstrap/WebDav.php
@@ -61,7 +61,27 @@ public function userMovedFile($user, $fileSource, $fileDestination){
 	public function userMovesFile($user, $fileSource, $fileDestination){
 		$fullUrl = substr($this->baseUrl, 0, -4) . $this->davPath;
 		$headers['Destination'] = $fullUrl . $fileDestination;
-		$this->response = $this->makeDavRequest($user, "MOVE", $fileSource, $headers);
+		try {
+			$this->response = $this->makeDavRequest($user, "MOVE", $fileSource, $headers);
+		} catch (\GuzzleHttp\Exception\ClientException $e) {
+			$this->response = $e->getResponse();
+		}
+	}
+
+	/**
+	 * @When /^User "([^"]*)" copies file "([^"]*)" to "([^"]*)"$/
+	 * @param string $user
+	 * @param string $fileSource
+	 * @param string $fileDestination
+	 */
+	public function userCopiesFile($user, $fileSource, $fileDestination){
+		$fullUrl = substr($this->baseUrl, 0, -4) . $this->davPath;
+		$headers['Destination'] = $fullUrl . $fileDestination;
+		try {
+			$this->response = $this->makeDavRequest($user, "COPY", $fileSource, $headers);
+		} catch (\GuzzleHttp\Exception\ClientException $e) {
+			$this->response = $e->getResponse();
+		}
 	}
 
 	/**
@@ -110,7 +130,11 @@ public function downloadedContentWhenDownloadindShouldBe($fileSource, $range, $c
 	 * @When Downloading file :fileName
 	 */
 	public function downloadingFile($fileName) {
-		$this->response = $this->makeDavRequest($this->currentUser, 'GET', $fileName, []);
+		try {
+			$this->response = $this->makeDavRequest($this->currentUser, 'GET', $fileName, []);
+		} catch (\GuzzleHttp\Exception\ClientException $e) {
+			$this->response = $e->getResponse();
+		}
 	}
 
 	/**
diff --git a/build/integration/features/webdav-related.feature b/build/integration/features/webdav-related.feature
index 45a364992515..eb4bb3aa7bb1 100644
--- a/build/integration/features/webdav-related.feature
+++ b/build/integration/features/webdav-related.feature
@@ -2,12 +2,119 @@ Feature: webdav-related
 	Background:
 		Given using api version "1"
 
-	Scenario: moving a file old way
+	Scenario: Moving a file
 		Given using dav path "remote.php/webdav"
 		And As an "admin"
 		And user "user0" exists
-		When User "user0" moves file "/textfile0.txt" to "/FOLDER/textfile0.txt"
+		And As an "user0"
+		When User "user0" moves file "/welcome.txt" to "/FOLDER/welcome.txt"
 		Then the HTTP status code should be "201"
+		And Downloading file "/FOLDER/welcome.txt"
+		And Downloaded content should start with "Welcome to your ownCloud account!"
+
+	Scenario: Moving and overwriting a file old way
+		Given using dav path "remote.php/webdav"
+		And As an "admin"
+		And user "user0" exists
+		And As an "user0"
+		When User "user0" moves file "/welcome.txt" to "/textfile0.txt"
+		Then the HTTP status code should be "204"
+		And Downloading file "/textfile0.txt"
+		And Downloaded content should start with "Welcome to your ownCloud account!"
+
+	Scenario: Moving a file to a folder with no permissions
+		Given using dav path "remote.php/webdav"
+		And As an "admin"
+		And user "user0" exists
+		And user "user1" exists
+		And As an "user1"
+		And user "user1" created a folder "/testshare"
+		And as "user1" creating a share with
+		  | path | testshare |
+		  | shareType | 0 |
+		  | permissions | 1 |
+		  | shareWith | user0 |
+		And As an "user0"
+		When User "user0" moves file "/textfile0.txt" to "/testshare/textfile0.txt"
+		Then the HTTP status code should be "403"
+		And Downloading file "/testshare/textfile0.txt"
+		And the HTTP status code should be "404"
+
+	Scenario: Moving a file to overwrite a file in a folder with no permissions
+		Given using dav path "remote.php/webdav"
+		And As an "admin"
+		And user "user0" exists
+		And user "user1" exists
+		And As an "user1"
+		And user "user1" created a folder "/testshare"
+		And as "user1" creating a share with
+		  | path | testshare |
+		  | shareType | 0 |
+		  | permissions | 1 |
+		  | shareWith | user0 |
+		And User "user1" copies file "/welcome.txt" to "/testshare/overwritethis.txt"
+		And As an "user0"
+		When User "user0" moves file "/textfile0.txt" to "/testshare/overwritethis.txt"
+		Then the HTTP status code should be "403"
+		And Downloading file "/testshare/overwritethis.txt"
+		And Downloaded content should start with "Welcome to your ownCloud account!"
+
+	Scenario: Copying a file
+		Given using dav path "remote.php/webdav"
+		And As an "admin"
+		And user "user0" exists
+		And As an "user0"
+		When User "user0" copies file "/welcome.txt" to "/FOLDER/welcome.txt"
+		Then the HTTP status code should be "201"
+		And Downloading file "/FOLDER/welcome.txt"
+		And Downloaded content should start with "Welcome to your ownCloud account!"
+
+	Scenario: Copying and overwriting a file
+		Given using dav path "remote.php/webdav"
+		And As an "admin"
+		And user "user0" exists
+		And As an "user0"
+		When User "user0" copies file "/welcome.txt" to "/textfile1.txt"
+		Then the HTTP status code should be "204"
+		And Downloading file "/textfile1.txt"
+		And Downloaded content should start with "Welcome to your ownCloud account!"
+
+	Scenario: Copying a file to a folder with no permissions
+		Given using dav path "remote.php/webdav"
+		And As an "admin"
+		And user "user0" exists
+		And user "user1" exists
+		And As an "user1"
+		And user "user1" created a folder "/testshare"
+		And as "user1" creating a share with
+		  | path | testshare |
+		  | shareType | 0 |
+		  | permissions | 1 |
+		  | shareWith | user0 |
+		And As an "user0"
+		When User "user0" copies file "/textfile0.txt" to "/testshare/textfile0.txt"
+		Then the HTTP status code should be "403"
+		And Downloading file "/testshare/textfile0.txt"
+		And the HTTP status code should be "404"
+
+	Scenario: Copying a file to overwrite a file into a folder with no permissions
+		Given using dav path "remote.php/webdav"
+		And As an "admin"
+		And user "user0" exists
+		And user "user1" exists
+		And As an "user1"
+		And user "user1" created a folder "/testshare"
+		And as "user1" creating a share with
+		  | path | testshare |
+		  | shareType | 0 |
+		  | permissions | 1 |
+		  | shareWith | user0 |
+		And User "user1" copies file "/welcome.txt" to "/testshare/overwritethis.txt"
+		And As an "user0"
+		When User "user0" copies file "/textfile0.txt" to "/testshare/overwritethis.txt"
+		Then the HTTP status code should be "403"
+		And Downloading file "/testshare/overwritethis.txt"
+		And Downloaded content should start with "Welcome to your ownCloud account!"
 
 	Scenario: download a file with range
 		Given using dav path "remote.php/webdav"", "url": "https://github.com/owncloud/core/commit/121a3304a0c37ccda0e1b63ddc528cba9121a36e.patch" }, { "commit_message": "[PATCH] Additional perm check in Webdav lib/private/connector/sabre/objecttree.php | 8 ++ tests/lib/connector/sabre/objecttree.php | 85 +++++++++++++++++++++- 2 files changed, 91 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/owncloud/core/commit/acbbadb71ceee7f01da347f7dcd519beda78cc47.patch" }, { "commit_message": "[PATCH] Additional perm check in Webdav lib/private/connector/sabre/objecttree.php | 5 ++ tests/lib/connector/sabre/objecttree.php | 82 ++++++++++++++++++++++ 2 files changed, 87 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/owncloud/core/commit/c0a4b7b3f38ad2eaf506484b3b92ec678cb021c9.patch" } ]
null
CVE-2023-49291
Improper Sanitization of Branch Name Leads to Arbitrary Code Injection
tj-actions/branch-names is a Github action to retrieve branch or tag names with support for all events. The `tj-actions/branch-names` GitHub Actions improperly references the `github.event.pull_request.head.ref` and `github.head_ref` context variables within a GitHub Actions `run` step. The head ref variable is the branch name and can be used to execute arbitrary code using a specially crafted branch name. As a result an attacker can use this vulnerability to steal secrets from or abuse `GITHUB_TOKEN` permissions. This vulnerability has been addressed in version 7.0.7. Users are advised to upgrade. There are no known workarounds for this vulnerability.
[ { "commit_message": "[PATCH 1/4] security: prevent arbitrary code injection via untrusted inputs action.yml | 56 ++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 37 insertions(+), 19 deletions(-)", "patch_text_b64": "From 73b5e05c8551b0ea18e91f7ae8acd38ce5ea4ede Mon Sep 17 00:00:00 2001
From: Tonye Jack <jtonye@ymail.com>
Date: Sat, 2 Dec 2023 22:39:12 -0700
Subject: [PATCH 1/4] security: prevent arbitrary code injection via untrusted
 inputs

---
 action.yml | 56 ++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 19 deletions(-)

diff --git a/action.yml b/action.yml
index 7343c700..6b417e84 100644
--- a/action.yml
+++ b/action.yml
@@ -37,12 +37,18 @@ runs:
   using: "composite"
   steps:
     - id: branch
+      env:
+        GITHUB_REF: ${{ github.ref }}
+        GITHUB_BASE_REF: ${{ github.event.pull_request.base.ref || github.base_ref }}
+        GITHUB_HEAD_REF: ${{ github.event.pull_request.head.ref || github.head_ref }}
+        GITHUB_EVENT_BASE_REF: ${{ github.event.base_ref }}
+        INPUTS_STRIP_TAG_PREFIX: ${{ inputs.strip_tag_prefix }}
       run: |
         # "Set branch names..."
-        if [[ "${{ github.ref }}" != "refs/tags/"* ]]; then
-          BASE_REF=$(printf "%q" "${{ github.event.pull_request.base.ref || github.base_ref }}")
-          HEAD_REF=$(printf "%q" "${{ github.event.pull_request.head.ref || github.head_ref }}")
-          REF=$(printf "%q" "${{ github.ref }}")
+        if [[ "$GITHUB_REF" != "refs/tags/"* ]]; then
+          BASE_REF=$(printf "%q" "$GITHUB_BASE_REF")
+          HEAD_REF=$(printf "%q" "$GITHUB_HEAD_REF")
+          REF=$(printf "%q" "$GITHUB_REF")
 
           BASE_REF=${BASE_REF/refs\/heads\//}
           HEAD_REF=${HEAD_REF/refs\/heads\//}
@@ -53,42 +59,54 @@ runs:
           echo "head_ref_branch=$(eval printf "%s" "$HEAD_REF")" >> "$GITHUB_OUTPUT"
           echo "ref_branch=$(eval printf "%s" "$REF_BRANCH")" >> "$GITHUB_OUTPUT"
         else
-          BASE_REF=$(printf "%q" "${{ github.event.base_ref }}")
-          BASE_REF=${BASE_REF/refs\/heads\/${{ inputs.strip_tag_prefix }}/}
+          BASE_REF=$(printf "%q" "$GITHUB_EVENT_BASE_REF")
+          BASE_REF=${BASE_REF/refs\/heads\/$INPUTS_STRIP_TAG_PREFIX/}
           
           echo "base_ref_branch=$(eval printf "%s" "$BASE_REF")" >> "$GITHUB_OUTPUT"
         fi
       shell: bash
     - id: current_branch
+      env:
+        GITHUB_REF: ${{ github.ref }}
+        GITHUB_EVENT_NAME: ${{ github.event_name }}
+        HEAD_REF_BRANCH: ${{ steps.branch.outputs.head_ref_branch }}
+        REF_BRANCH: ${{ steps.branch.outputs.ref_branch }}
       run: |
         # "Set the current branch name..."
-        if [[ "${{ github.ref }}" != "refs/tags/"* ]]; then
-          if [[ ${{ github.event_name }} == *"pull_request"* ]]; then
-            echo "current_branch=${{ steps.branch.outputs.head_ref_branch }}" >> "$GITHUB_OUTPUT"
+        if [[ "$GITHUB_REF" != "refs/tags/"* ]]; then
+          if [[ "$GITHUB_EVENT_NAME" == *"pull_request"* ]]; then
+            echo "current_branch=$HEAD_REF_BRANCH" >> "$GITHUB_OUTPUT"
           else
-            echo "current_branch=${{ steps.branch.outputs.ref_branch }}" >> "$GITHUB_OUTPUT"
+            echo "current_branch=$REF_BRANCH" >> "$GITHUB_OUTPUT"
           fi
         fi
-      shell: bash
-    - id: default
+      shell: bash    - id: default
+      env:
+        GITHUB_REF: ${{ github.ref }}
+        CURRENT_BRANCH: ${{ steps.current_branch.outputs.current_branch }}
+        DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+        FORK: ${{ github.event.pull_request.head.repo.fork }}
       run: |
         # "Set the default branch name..."
-        if [[ "${{ github.ref }}" != "refs/tags/"* ]]; then
-          if [[ "${{ steps.current_branch.outputs.current_branch }}" == "${{ github.event.repository.default_branch }}" && "${{ github.event.pull_request.head.repo.fork }}" != "true" ]]; then
+        if [[ "$GITHUB_REF" != "refs/tags/"* ]]; then
+          if [[ "$CURRENT_BRANCH" == "$DEFAULT_BRANCH" && "$FORK" != "true" ]]; then
             echo "is_default=true" >> "$GITHUB_OUTPUT"
-            echo "default_branch=${{ github.event.repository.default_branch }}" >> "$GITHUB_OUTPUT"
+            echo "default_branch=$DEFAULT_BRANCH" >> "$GITHUB_OUTPUT"
           else
             echo "is_default=false" >> "$GITHUB_OUTPUT"
-            echo "default_branch=${{ github.event.repository.default_branch }}" >> "$GITHUB_OUTPUT"
+            echo "default_branch=$DEFAULT_BRANCH" >> "$GITHUB_OUTPUT"
           fi
         fi
       shell: bash
     - id: tag
+      env:
+        GITHUB_REF: ${{ github.ref }}
+        INPUTS_STRIP_TAG_PREFIX: ${{ inputs.strip_tag_prefix }}
       run: |
         # "Set the tag name..."
-        if [[ "${{ github.ref }}" == "refs/tags/"* ]]; then
-          REF=$(printf "%q" "${{ github.ref }}")
-          TAG=${REF/refs\/tags\/${{ inputs.strip_tag_prefix }}/}
+        if [[ "$GITHUB_REF" == "refs/tags/"* ]]; then
+          REF=$(printf "%q" "$GITHUB_REF")
+          TAG=${REF/refs\/tags\/$INPUTS_STRIP_TAG_PREFIX/}
 
           echo "tag=$(eval printf "%s" "$TAG")" >> "$GITHUB_OUTPUT"
           echo "is_tag=true" >> "$GITHUB_OUTPUT"

From 610e9803309427800eaee5dcde8de48e946f02e3 Mon Sep 17 00:00:00 2001
From: Tonye Jack <jtonye@ymail.com>
Date: Sat, 2 Dec 2023 22:42:21 -0700
Subject: [PATCH 2/4] Fix indentation

---
 action.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/action.yml b/action.yml
index 6b417e84..bc0d18f7 100644
--- a/action.yml
+++ b/action.yml
@@ -80,7 +80,8 @@ runs:
             echo "current_branch=$REF_BRANCH" >> "$GITHUB_OUTPUT"
           fi
         fi
-      shell: bash    - id: default
+      shell: bash  
+    - id: default
       env:
         GITHUB_REF: ${{ github.ref }}
         CURRENT_BRANCH: ${{ steps.current_branch.outputs.current_branch }}

From 6a7e02263c0eeb64d7ca5dc54a91e0064f54679b Mon Sep 17 00:00:00 2001
From: Tonye Jack <jtonye@ymail.com>
Date: Sat, 2 Dec 2023 22:47:24 -0700
Subject: [PATCH 3/4] Update action.yml

---
 action.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/action.yml b/action.yml
index bc0d18f7..2bb7a016 100644
--- a/action.yml
+++ b/action.yml
@@ -80,7 +80,7 @@ runs:
             echo "current_branch=$REF_BRANCH" >> "$GITHUB_OUTPUT"
           fi
         fi
-      shell: bash  
+      shell: bash
     - id: default
       env:
         GITHUB_REF: ${{ github.ref }}

From d1dce85278f56712618c88f991af7bdaa2d1e1d7 Mon Sep 17 00:00:00 2001
From: Tonye Jack <jtonye@ymail.com>
Date: Sat, 2 Dec 2023 23:18:56 -0700
Subject: [PATCH 4/4] Update action.yml

---
 action.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/action.yml b/action.yml
index 2bb7a016..f99cae56 100644
--- a/action.yml
+++ b/action.yml
@@ -107,7 +107,7 @@ runs:
         # "Set the tag name..."
         if [[ "$GITHUB_REF" == "refs/tags/"* ]]; then
           REF=$(printf "%q" "$GITHUB_REF")
-          TAG=${REF/refs\/tags\/$INPUTS_STRIP_TAG_PREFIX/}
+          TAG="${REF/refs\/tags\/$INPUTS_STRIP_TAG_PREFIX/}"
 
           echo "tag=$(eval printf "%s" "$TAG")" >> "$GITHUB_OUTPUT"
           echo "is_tag=true" >> "$GITHUB_OUTPUT"", "url": "https://github.com/tj-actions/branch-names/commit/4923d1ca41f928c24f1c1b3af9daaadfb71e6337.patch" }, { "commit_message": "[PATCH] security: remove vulnerable events from test .github/workflows/test.yml | 2 -- 1 file changed, 2 deletions(-)", "patch_text_b64": "RnJvbSA3MjZmZTliYTVlOWRhNGZjYzcxNjIyM2I3OTk0ZmZkMDM1OGFmMDYwIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb255ZSBKYWNrIDxqdG9ueWVAeW1haWwuY29tPgpEYXRlOiBTYXQsIDIgRGVjIDIwMjMgMjM6MzE6NDMgLTA3MDAKU3ViamVjdDogW1BBVENIXSBzZWN1cml0eTogcmVtb3ZlIHZ1bG5lcmFibGUgZXZlbnRzIGZyb20gdGVzdAoKLS0tCiAuZ2l0aHViL3dvcmtmbG93cy90ZXN0LnltbCB8IDIgLS0KIDEgZmlsZSBjaGFuZ2VkLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhLy5naXRodWIvd29ya2Zsb3dzL3Rlc3QueW1sIGIvLmdpdGh1Yi93b3JrZmxvd3MvdGVzdC55bWwKaW5kZXggM2QyZjA3NWYuLjU3YWFhMWMxIDEwMDY0NAotLS0gYS8uZ2l0aHViL3dvcmtmbG93cy90ZXN0LnltbAorKysgYi8uZ2l0aHViL3dvcmtmbG93cy90ZXN0LnltbApAQCAtOCw4ICs4LDYgQEAgb246CiAgICAgICAtIG1haW4KICAgcmVsZWFzZToKICAgICB0eXBlczogW3B1Ymxpc2hlZCwgY3JlYXRlZF0KLSAgcHVsbF9yZXF1ZXN0X3JldmlldzoKLSAgcHVsbF9yZXF1ZXN0X3RhcmdldDoKICAgcHVsbF9yZXF1ZXN0OgogICAgIGJyYW5jaGVzOgogICAgICAgLSBtYWlu", "url": "https://github.com/tj-actions/branch-names/commit/6c999acf206f5561e19f46301bb310e9e70d8815.patch" }, { "commit_message": "[PATCH] security: remove vulnerable events from test .github/workflows/test.yml | 2 -- 1 file changed, 2 deletions(-)", "patch_text_b64": "RnJvbSA3MjZmZTliYTVlOWRhNGZjYzcxNjIyM2I3OTk0ZmZkMDM1OGFmMDYwIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb255ZSBKYWNrIDxqdG9ueWVAeW1haWwuY29tPgpEYXRlOiBTYXQsIDIgRGVjIDIwMjMgMjM6MzE6NDMgLTA3MDAKU3ViamVjdDogW1BBVENIXSBzZWN1cml0eTogcmVtb3ZlIHZ1bG5lcmFibGUgZXZlbnRzIGZyb20gdGVzdAoKLS0tCiAuZ2l0aHViL3dvcmtmbG93cy90ZXN0LnltbCB8IDIgLS0KIDEgZmlsZSBjaGFuZ2VkLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhLy5naXRodWIvd29ya2Zsb3dzL3Rlc3QueW1sIGIvLmdpdGh1Yi93b3JrZmxvd3MvdGVzdC55bWwKaW5kZXggM2QyZjA3NWYuLjU3YWFhMWMxIDEwMDY0NAotLS0gYS8uZ2l0aHViL3dvcmtmbG93cy90ZXN0LnltbAorKysgYi8uZ2l0aHViL3dvcmtmbG93cy90ZXN0LnltbApAQCAtOCw4ICs4LDYgQEAgb246CiAgICAgICAtIG1haW4KICAgcmVsZWFzZToKICAgICB0eXBlczogW3B1Ymxpc2hlZCwgY3JlYXRlZF0KLSAgcHVsbF9yZXF1ZXN0X3JldmlldzoKLSAgcHVsbF9yZXF1ZXN0X3RhcmdldDoKICAgcHVsbF9yZXF1ZXN0OgogICAgIGJyYW5jaGVzOgogICAgICAgLSBtYWlu", "url": "https://github.com/tj-actions/branch-names/commit/726fe9ba5e9da4fcc716223b7994ffd0358af060.patch" } ]
CWE-20: Improper Input Validation
GHSA-4hr6-49g3-g573
null
[ { "commit_message": "[PATCH] fixed #2576 src/filters/dasher.c | 5 +++++ src/filters/dmx_avi.c | 1 + src/filters/reframe_mhas.c | 7 ++++--- src/scene_manager/swf_parse.c | 5 ++--- 4 files changed, 12 insertions(+), 6 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/gpac/gpac/commit/4607052c482a51dbdacfe1ade10645c181d07b07.patch" } ]
null
GHSA-rp9c-7g4x-v5p2
null
[ { "commit_message": "[PATCH] [media] dvb-usb-v2: avoid use-after-free I ran into a stack frame size warning because of the on-stack copy of the USB device structure: drivers/media/usb/dvb-usb-v2/dvb_usb_core.c: In function 'dvb_usbv2_disconnect': drivers/media/usb/dvb-usb-v2/dvb_usb_core.c:1029:1: error: the frame size of 1104 bytes is larger than 1024 bytes [-Werror=frame-larger-than=] Copying a device structure like this is wrong for a number of other reasons too aside from the possible stack overflow. One of them is that the dev_info() call will print the name of the device later, but AFAICT we have only copied a pointer to the name earlier and the actual name has been freed by the time it gets printed. This removes the on-stack copy of the device and instead copies the device name using kstrdup(). I'm ignoring the possible failure here as both printk() and kfree() are able to deal with NULL pointers. Signed-off-by: Arnd Bergmann <arnd@arndb.de> Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com> drivers/media/usb/dvb-usb-v2/dvb_usb_core.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/torvalds/linux/commit/005145378c9ad7575a01b6ce1ba118fb427f583a.patch" } ]
null
GHSA-wv28-7fpw-fj49
Lektor does not sanitize database path traversal
null
[ { "commit_message": "[PATCH] Sanitize DB path traversal (#1179) * test: check that make_editor_session rejects funky paths * fix: validate path in make_editor_session * test: check that untrusted_to_os_path prevents traversal to parent * fix[untrusted_to_os_path]: prevent traversal to parent directories lektor/editor.py | 13 +++++++++++++ lektor/utils.py | 5 +++-- tests/test_editor.py | 1 + tests/test_utils.py | 16 ++++++++++++++++ 4 files changed, 33 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/lektor/lektor/commit/7393d87bd354e43120937789956175064e4610a0.patch" } ]
null
GHSA-h97q-54jx-527j
null
[ { "commit_message": "[PATCH] fix(accounts): security enhancement src/controllers/api/v1/routes.js | 1 + src/controllers/api/v1/users.js | 98 +++++++++++++++++++ .../js/angularjs/controllers/profile.js | 2 +- 3 files changed, 100 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/polonel/trudesk/commit/83fd5a89319ba2c2f5934722e39b08aba9b3a4ac.patch" } ]
null
CVE-2022-0266
Authorization Bypass Through User-Controlled Key in livehelperchat/livehelperchat
Authorization Bypass Through User-Controlled Key in Packagist remdex/livehelperchat prior to 3.92v.
[ { "commit_message": "[PATCH] Display logic should match backand logic lhc_web/modules/lhuser/delete.php | 5 +++++ lhc_web/modules/lhuser/deletegroup.php | 5 +++++ 2 files changed, 10 insertions(+)", "patch_text_b64": "RnJvbSBjYzExMjJhZWQwZDFhZDlmMDU3NTdlYWVhMmFiOWU2YTkyNDc3NmJkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBSZW1pZ2lqdXMgS2ltaW5hcyA8cmVtZGV4QGdtYWlsLmNvbT4KRGF0ZTogVHVlLCAxOCBKYW4gMjAyMiAwMDoxODozNiAtMDUwMApTdWJqZWN0OiBbUEFUQ0hdIERpc3BsYXkgbG9naWMgc2hvdWxkIG1hdGNoIGJhY2thbmQgbG9naWMKCi0tLQogbGhjX3dlYi9tb2R1bGVzL2xodXNlci9kZWxldGUucGhwICAgICAgfCA1ICsrKysrCiBsaGNfd2ViL21vZHVsZXMvbGh1c2VyL2RlbGV0ZWdyb3VwLnBocCB8IDUgKysrKysKIDIgZmlsZXMgY2hhbmdlZCwgMTAgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2xoY193ZWIvbW9kdWxlcy9saHVzZXIvZGVsZXRlLnBocCBiL2xoY193ZWIvbW9kdWxlcy9saHVzZXIvZGVsZXRlLnBocAppbmRleCA3YjI3MzE3OTg3Li5hMTgyMDNiMGYyIDEwMDY0NAotLS0gYS9saGNfd2ViL21vZHVsZXMvbGh1c2VyL2RlbGV0ZS5waHAKKysrIGIvbGhjX3dlYi9tb2R1bGVzL2xodXNlci9kZWxldGUucGhwCkBAIC0xMCw2ICsxMCwxMSBAQAogICAgIGV4aXQ7CiB9CiAKK2lmICgoaW50KSRQYXJhbXNbJ3VzZXJfcGFyYW1ldGVycyddWyd1c2VyX2lkJ10gPT0gMSkgeworICAgIGRpZSgnYWRtaW4gYWNjb3VudCBuZXZlciBjYW4gYmUgZGVsZXRlZCEnKTsKKyAgICBleGl0OworfQorCiAkZGVwYXJ0YW1lbnQgPSBlckxoY29yZUNsYXNzVXNlcjo6Z2V0U2Vzc2lvbigpLT5sb2FkKCAnZXJMaGNvcmVDbGFzc01vZGVsVXNlcicsICRQYXJhbXNbJ3VzZXJfcGFyYW1ldGVycyddWyd1c2VyX2lkJ10pOwogZXJMaGNvcmVDbGFzc1VzZXI6OmdldFNlc3Npb24oKS0+ZGVsZXRlKCRkZXBhcnRhbWVudCk7CiAKZGlmZiAtLWdpdCBhL2xoY193ZWIvbW9kdWxlcy9saHVzZXIvZGVsZXRlZ3JvdXAucGhwIGIvbGhjX3dlYi9tb2R1bGVzL2xodXNlci9kZWxldGVncm91cC5waHAKaW5kZXggNDQ3YmQ5OGIzZC4uMTg0Y2U4MjViOCAxMDA2NDQKLS0tIGEvbGhjX3dlYi9tb2R1bGVzL2xodXNlci9kZWxldGVncm91cC5waHAKKysrIGIvbGhjX3dlYi9tb2R1bGVzL2xodXNlci9kZWxldGVncm91cC5waHAKQEAgLTUsNiArNSwxMSBAQAogCWV4aXQ7CiB9CiAKK2lmICgoaW50KSRQYXJhbXNbJ3VzZXJfcGFyYW1ldGVycyddWydncm91cF9pZCddID09IDEpIHsKKyAgICBkaWUoJ2FkbWluIGFjY291bnQgbmV2ZXIgY2FuIGJlIGRlbGV0ZWQhJyk7CisgICAgZXhpdDsKK30KKwogZXJMaGNvcmVDbGFzc0dyb3VwOjpkZWxldGVHcm91cCgoaW50KSRQYXJhbXNbJ3VzZXJfcGFyYW1ldGVycyddWydncm91cF9pZCddKTsKIAogZXJMaGNvcmVDbGFzc0FkbWluQ2hhdFZhbGlkYXRvckhlbHBlcjo6Y2xlYXJVc2Vyc0NhY2hlKCk7", "url": "https://github.com/livehelperchat/livehelperchat/commit/cc1122aed0d1ad9f05757eaea2ab9e6a924776bd.patch" } ]
CWE-639 Authorization Bypass Through User-Controlled Key
GHSA-vpq9-rx6p-23hj
null
[ { "commit_message": "[PATCH] Update VCounter Update VCounter mod/statistik/vcounter.php | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/auracms/AuraCMS/commit/4fe9d0d31a32df392f4d6ced8e5c25ed4af19ade.patch" }, { "commit_message": "[PATCH] AuraCMS Update Vulnerability SQL Injection in content.php images/header/1378798712-ban1.png | Bin 25333 -> 0 bytes images/header/1378799316-ban2.png | Bin 59902 -> 0 bytes images/header/1378799702-ban3.png | Bin 66304 -> 0 bytes images/header/1378799866-ban5.png | Bin 47489 -> 0 bytes images/header/1378801253-ban6.png | Bin 85674 -> 0 bytes mod/content/content.php | 2 +- 6 files changed, 1 insertion(+), 1 deletion(-) delete mode 100644 images/header/1378798712-ban1.png delete mode 100644 images/header/1378799316-ban2.png delete mode 100644 images/header/1378799702-ban3.png delete mode 100644 images/header/1378799866-ban5.png delete mode 100644 images/header/1378801253-ban6.png", "patch_text_b64": "From 790f66ffbc4f23a6e13636fc79d0aa1a7d81e747 Mon Sep 17 00:00:00 2001
From: AuraCMS <admin@auracms.org>
Date: Tue, 14 Jan 2014 11:02:30 +0700
Subject: [PATCH] AuraCMS

Update Vulnerability SQL Injection in content.php
---
 images/header/1378798712-ban1.png | Bin 25333 -> 0 bytes
 images/header/1378799316-ban2.png | Bin 59902 -> 0 bytes
 images/header/1378799702-ban3.png | Bin 66304 -> 0 bytes
 images/header/1378799866-ban5.png | Bin 47489 -> 0 bytes
 images/header/1378801253-ban6.png | Bin 85674 -> 0 bytes
 mod/content/content.php           |   2 +-
 6 files changed, 1 insertion(+), 1 deletion(-)
 delete mode 100644 images/header/1378798712-ban1.png
 delete mode 100644 images/header/1378799316-ban2.png
 delete mode 100644 images/header/1378799702-ban3.png
 delete mode 100644 images/header/1378799866-ban5.png
 delete mode 100644 images/header/1378801253-ban6.png

diff --git a/images/header/1378798712-ban1.png b/images/header/1378798712-ban1.png
deleted file mode 100644
index d1fb2c068a2b96a99e2837c103c0eb0c4c3300e7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 25333
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

diff --git a/images/header/1378799316-ban2.png b/images/header/1378799316-ban2.png
deleted file mode 100644
index 53a05e7c842fc2962f420b6110d8230e1c7dc31b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 59902
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
Y)b*mdo--ER+~3~ISZWDbMSaNs*}?G;ZvX%Q

diff --git a/images/header/1378799702-ban3.png b/images/header/1378799702-ban3.png
deleted file mode 100644
index 3f4e0354014edc5834b64067e73034721840cb51..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 66304
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

diff --git a/images/header/1378799866-ban5.png b/images/header/1378799866-ban5.png
deleted file mode 100644
index 4d378e3f0e6b87eb71c97fac15e0a8d2548fc6f2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 47489
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

diff --git a/images/header/1378801253-ban6.png b/images/header/1378801253-ban6.png
deleted file mode 100644
index b38ea669142a79151f5ce395e0431d2120c45b9d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 85674
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%0Dvj^6*Hb5#98~`0axD@
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%0D)|*06yMMec*=5NH)0A
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
F{{au?p_%{y

diff --git a/mod/content/content.php b/mod/content/content.php
index 50a62e1..28cfbf9 100644
--- a/mod/content/content.php
+++ b/mod/content/content.php
@@ -88,7 +88,7 @@
 		<h2>Pencarian Berita</h2>
 		<div class="border" style="text-align:center;"><img src="mod/content/images/banner_searching_data.gif" alt="Searching Data" /></div>';
 		
-		$search	= !isset($_GET['search']) ? cleanText($_POST['search']) : cleanText($_GET['search']);
+		$search	= !isset($_GET['search']) ? mysqli_real_escape_string(cleanText($_POST['search'])) : mysqli_real_escape_string(cleanText($_GET['search']));
 		
 		if(!$search){
 			$tengah .= '<div class="error">Maaf Anda Belum Memasukkan Kata Pencarian</div>';", "url": "https://github.com/auracms/AuraCMS/commit/790f66ffbc4f23a6e13636fc79d0aa1a7d81e747.patch" } ]
null
GHSA-vw4j-wqq5-5pv6
null
[ { "commit_message": "[PATCH] Update trigger_referral.php to prevent SQL Injection Upload/plugins/gimmie/trigger_referral.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)", "patch_text_b64": "RnJvbSA3MTk0YTA5MzUzZGQyNGEyNzQ2NzgzODNhNDQxOGYyZmQzZmNlNmY3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5ueSBDaGVvayA8ZGFubnlAZ2ltbWlld29ybGQuY29tPgpEYXRlOiBNb24sIDggU2VwIDIwMTQgMTc6MTQ6MjcgKzA4MDAKU3ViamVjdDogW1BBVENIXSBVcGRhdGUgdHJpZ2dlcl9yZWZlcnJhbC5waHAgdG8gcHJldmVudCBTUUwgSW5qZWN0aW9uCgotLS0KIFVwbG9hZC9wbHVnaW5zL2dpbW1pZS90cmlnZ2VyX3JlZmVycmFsLnBocCB8IDQgKystLQogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9VcGxvYWQvcGx1Z2lucy9naW1taWUvdHJpZ2dlcl9yZWZlcnJhbC5waHAgYi9VcGxvYWQvcGx1Z2lucy9naW1taWUvdHJpZ2dlcl9yZWZlcnJhbC5waHAKaW5kZXggNmRiODJlMS4uM2JkMDA4YyAxMDA2NDQKLS0tIGEvVXBsb2FkL3BsdWdpbnMvZ2ltbWllL3RyaWdnZXJfcmVmZXJyYWwucGhwCisrKyBiL1VwbG9hZC9wbHVnaW5zL2dpbW1pZS90cmlnZ2VyX3JlZmVycmFsLnBocApAQCAtMiw3ICsyLDcgQEAKIHJlcXVpcmVfb25jZShESVIgLiAnL3BsdWdpbnMvZ2ltbWllL2Z1bmN0aW9ucy5waHAnKTsKIHJlcXVpcmVfb25jZShESVIgLiAnL3BsdWdpbnMvZ2ltbWllL09BdXRoLnBocCcpOwogCi0kdXNlcnNxbCAgPSAkdmJ1bGxldGluLT5kYi0+cXVlcnlfcmVhZCgiU0VMRUNUIGB1c2VyaWRgLCBgdXNlcm5hbWVgLCBgZW1haWxgIEZST00gIiAuIFRBQkxFX1BSRUZJWCAuICJ1c2VyIFdIRVJFIGB1c2VybmFtZWAgPSAnIiAuICRfUE9TVFsncmVmZXJyZXJuYW1lJ10gLiAiJyIpOworJHVzZXJzcWwgID0gJHZidWxsZXRpbi0+ZGItPnF1ZXJ5X3JlYWQoIlNFTEVDVCBgdXNlcmlkYCwgYHVzZXJuYW1lYCwgYGVtYWlsYCBGUk9NICIgLiBUQUJMRV9QUkVGSVggLiAidXNlciBXSEVSRSBgdXNlcm5hbWVgID0gIiAuICR2YnVsbGV0aW4tPmRiLT5lc2NhcGVfc3RyaW5nKCRfUE9TVFsncmVmZXJyZXJuYW1lJ10pKTsKICR1c2VyICAgPSAkdmJ1bGxldGluLT5kYi0+ZmV0Y2hfYXJyYXkoJHVzZXJzcWwpOwogCiAkbXlfcGxheWVyX3VpZCAgICAgICAgPSAkdXNlclsnZW1haWwnXTsKQEAgLTI4LDQgKzI4LDQgQEAKICAgcmV0dXJuOwogfQogCi0/PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKKz8+", "url": "https://github.com/gimmie/vbulletin-v4/commit/7194a09353dd24a274678383a4418f2fd3fce6f7.patch" } ]
null
GHSA-7h2r-j97g-f327
null
[ { "commit_message": "[PATCH] fix CVE-2025-6257 html escaping editor input eurofxref.php | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/joostdekeijzer/wp_eurofxref/commit/131108428f0d88dab1070048350bdd54f10c36a0.patch" } ]
null
CVE-2022-2941
The WP-UserOnline plugin for WordPress has multiple Stored Cross-Site Scripting vulnerabilities in versions up to, and including 2.88.0. This is due to the fact that all fields in the "Naming Conventions" section do not properly sanitize user input, nor escape it on output. This makes it possible for authenticated attackers, with administrative privileges, to inject JavaScript code into the setting that will execute whenever a user accesses the injected page. This only affects multi-site installations and installations where unfiltered_html has been disabled.
[ { "commit_message": "[PATCH] Fixed XSS. Props Juampa Rodriguez README.md | 5 ++++- admin.php | 18 ++++++++++++++---- wp-useronline.php | 2 +- 3 files changed, 19 insertions(+), 6 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/lesterchan/wp-useronline/commit/59c76b20e4e27489f93dee4ef1254d6204e08b3c.patch" } ]
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
GHSA-7h8g-7wrh-4jfh
null
[ { "commit_message": "[PATCH] Implemented \"[ #315668 ] Disable loading of external entities in XML parsing by default\". .../xerces/XercesSAXParserFactoryImpl.java | 41 ++++++++----------- 1 file changed, 16 insertions(+), 25 deletions(-)", "patch_text_b64": "From aba6681660f65af7f1676434da68c10298c30200 Mon Sep 17 00:00:00 2001
From: ebruchez <ebruchez@orbeon.com>
Date: Fri, 3 Dec 2010 16:32:48 -0800
Subject: [PATCH] Implemented "[ #315668 ] Disable loading of external entities
 in XML parsing by default".

---
 .../xerces/XercesSAXParserFactoryImpl.java    | 41 ++++++++-----------
 1 file changed, 16 insertions(+), 25 deletions(-)

diff --git a/src/java/org/orbeon/oxf/xml/xerces/XercesSAXParserFactoryImpl.java b/src/java/org/orbeon/oxf/xml/xerces/XercesSAXParserFactoryImpl.java
index c4c59e48b08..fc0d716f414 100644
--- a/src/java/org/orbeon/oxf/xml/xerces/XercesSAXParserFactoryImpl.java
+++ b/src/java/org/orbeon/oxf/xml/xerces/XercesSAXParserFactoryImpl.java
@@ -4,13 +4,9 @@
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXNotRecognizedException;
 
-import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Hashtable;
-import java.util.Map;
+import java.util.*;
 
 /**
  * Boasts a couple of improvements over the 'stock' xerces parser factory.
@@ -42,23 +38,17 @@ public class XercesSAXParserFactoryImpl extends SAXParserFactory {
     static {
         {
             final OrbeonParserConfiguration configuration = XercesSAXParser.makeConfig(false, true);
-            final Collection features = configuration.getRecognizedFeatures();
-            recognizedFeaturesNonValidatingXInclude = Collections.unmodifiableCollection(features);
+            final Collection recognizedFeatures = configuration.getRecognizedFeatures();
+            recognizedFeaturesNonValidatingXInclude = Collections.unmodifiableCollection(recognizedFeatures);
             defaultFeaturesNonValidatingXInclude = configuration.getFeatures();
-            // This was being done in XMLUtils.createSaxParserFactory before.  Maybe want to
-            // move it back if we decide to make this class more general purpose.
-            defaultFeaturesNonValidatingXInclude.put("http://xml.org/sax/features/namespaces", Boolean.TRUE);
-            defaultFeaturesNonValidatingXInclude.put("http://xml.org/sax/features/namespace-prefixes", Boolean.FALSE);
+            addDefaultFeatures(defaultFeaturesNonValidatingXInclude);
         }
         {
             final OrbeonParserConfiguration configuration = XercesSAXParser.makeConfig(false, false);
             final Collection features = configuration.getRecognizedFeatures();
             recognizedFeaturesNonValidatingNoXInclude = Collections.unmodifiableCollection(features);
             defaultFeaturesNonValidatingNoXInclude = configuration.getFeatures();
-            // This was being done in XMLUtils.createSaxParserFactory before.  Maybe want to
-            // move it back if we decide to make this class more general purpose.
-            defaultFeaturesNonValidatingNoXInclude.put("http://xml.org/sax/features/namespaces", Boolean.TRUE);
-            defaultFeaturesNonValidatingNoXInclude.put("http://xml.org/sax/features/namespace-prefixes", Boolean.FALSE);
+            addDefaultFeatures(defaultFeaturesNonValidatingNoXInclude);
         }
 
         {
@@ -66,23 +56,25 @@ public class XercesSAXParserFactoryImpl extends SAXParserFactory {
             final Collection features = configuration.getRecognizedFeatures();
             recognizedFeaturesValidatingXInclude = Collections.unmodifiableCollection(features);
             defaultFeaturesValidatingXInclude = configuration.getFeatures();
-            // This was being done in XMLUtils.createSaxParserFactory before.  Maybe want to
-            // move it back if we decide to make this class more general purpose.
-            defaultFeaturesValidatingXInclude.put("http://xml.org/sax/features/namespaces", Boolean.TRUE);
-            defaultFeaturesValidatingXInclude.put("http://xml.org/sax/features/namespace-prefixes", Boolean.FALSE);
+            addDefaultFeatures(defaultFeaturesValidatingXInclude);
         }
         {
             final OrbeonParserConfiguration configuration = XercesSAXParser.makeConfig(true, false);
             final Collection features = configuration.getRecognizedFeatures();
             recognizedFeaturesValidatingNoXInclude = Collections.unmodifiableCollection(features);
             defaultFeaturesValidatingNoXInclude = configuration.getFeatures();
-            // This was being done in XMLUtils.createSaxParserFactory before.  Maybe want to
-            // move it back if we decide to make this class more general purpose.
-            defaultFeaturesValidatingNoXInclude.put("http://xml.org/sax/features/namespaces", Boolean.TRUE);
-            defaultFeaturesValidatingNoXInclude.put("http://xml.org/sax/features/namespace-prefixes", Boolean.FALSE);
+            addDefaultFeatures(defaultFeaturesValidatingNoXInclude);
         }
     }
 
+    private static void addDefaultFeatures(Map features) {
+        features.put("http://xml.org/sax/features/namespaces", Boolean.TRUE);
+        features.put("http://xml.org/sax/features/namespace-prefixes", Boolean.FALSE);
+        // For security purposes, disable external entities
+        features.put("http://xml.org/sax/features/external-general-entities", Boolean.FALSE);
+        features.put("http://xml.org/sax/features/external-parameter-entities", Boolean.FALSE);
+    }
+
     private final Hashtable features;
     private final boolean validating;
     private final boolean handleXInclude;
@@ -112,14 +104,13 @@ public void setFeature(final String key, final boolean val) throws SAXNotRecogni
         features.put(key, val ? Boolean.TRUE : Boolean.FALSE);
     }
 
-    public SAXParser newSAXParser() throws ParserConfigurationException {
+    public SAXParser newSAXParser() {
         final SAXParser ret;
         try {
             ret = new XercesJAXPSAXParser(this, features, validating, handleXInclude);
         } catch (final SAXException se) {
             // Translate to ParserConfigurationException
             throw new OXFException(se); // so we see a decent stack trace!
-//            throw new ParserConfigurationException(se.getMessage());
         }
         return ret;
     }", "url": "https://github.com/orbeon/orbeon-forms/commit/aba6681660f65af7f1676434da68c10298c30200.patch" } ]
null
GHSA-x92h-wmg2-6hp7
Invalid HTTP method overrides allow possible XSS or other attacks in Symfony
null
[ { "commit_message": "[PATCH] [HttpFoundation] reject invalid method override .../Component/HttpFoundation/Request.php | 43 +++++++++++++------ 1 file changed, 29 insertions(+), 14 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/symfony/symfony/commit/944e60f083c3bffbc6a0b5112db127a10a66a8ec.patch" } ]
null
GHSA-9wc2-3gq5-2f4c
null
[ { "commit_message": "[PATCH] Security: BigUpload: Remove unused method to upload file .../javascript/bigupload/inc/bigUpload.php | 65 ------------------- 1 file changed, 65 deletions(-)", "patch_text_b64": "RnJvbSAzYjQ4N2E1NTA3NmZiMDZmOTY4MDliNzkwYTM1ZGNkZDQyZjhlYzQ5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmdlbCBGZXJuYW5kbyBRdWlyb3ogQ2FtcG9zIDxhbmdlbGZxYy4xOEBnbWFpbC5jb20+CkRhdGU6IFR1ZSwgNSBTZXAgMjAyMyAxMzozOTo1MyAtMDUwMApTdWJqZWN0OiBbUEFUQ0hdIFNlY3VyaXR5OiBCaWdVcGxvYWQ6IFJlbW92ZSB1bnVzZWQgbWV0aG9kIHRvIHVwbG9hZCBmaWxlCgotLS0KIC4uLi9qYXZhc2NyaXB0L2JpZ3VwbG9hZC9pbmMvYmlnVXBsb2FkLnBocCAgICB8IDY1IC0tLS0tLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA2NSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9tYWluL2luYy9saWIvamF2YXNjcmlwdC9iaWd1cGxvYWQvaW5jL2JpZ1VwbG9hZC5waHAgYi9tYWluL2luYy9saWIvamF2YXNjcmlwdC9iaWd1cGxvYWQvaW5jL2JpZ1VwbG9hZC5waHAKaW5kZXggNzAzMTViNGE5MjQuLjEwY2Y0MzIyZTgyIDEwMDY0NAotLS0gYS9tYWluL2luYy9saWIvamF2YXNjcmlwdC9iaWd1cGxvYWQvaW5jL2JpZ1VwbG9hZC5waHAKKysrIGIvbWFpbi9pbmMvbGliL2phdmFzY3JpcHQvYmlndXBsb2FkL2luYy9iaWdVcGxvYWQucGhwCkBAIC01LDE2ICs1LDYgQEAKIAogY2xhc3MgQmlnVXBsb2FkUmVzcG9uc2UKIHsKLSAgICAvKioKLSAgICAgKiBUZW1wb3JhcnkgZGlyZWN0b3J5IGZvciB1cGxvYWRpbmcgZmlsZXMuCi0gICAgICovCi0gICAgY29uc3QgVEVNUF9ESVJFQ1RPUlkgPSAnL3RtcC8nOwotCi0gICAgLyoqCi0gICAgICogRGlyZWN0b3J5IGZpbGVzIHdpbGwgYmUgbW92ZWQgdG8gYWZ0ZXIgdGhlIHVwbG9hZCBpcyBjb21wbGV0ZWQuCi0gICAgICovCi0gICAgY29uc3QgTUFJTl9ESVJFQ1RPUlkgPSAnLi4vZmlsZXMvJzsKLQogICAgIC8qKgogICAgICAqIE1heCBhbGxvd2VkIGZpbGVzaXplLiBUaGlzIGlzIGZvciB1bnN1cHBvcnRlZCBicm93c2VycyBhbmQKICAgICAgKiBhcyBhbiBhZGRpdGlvbmFsIHNlY3VyaXR5IGNoZWNrIGluIGNhc2Ugc29tZW9uZSBieXBhc3NlcyB0aGUganMgZmlsZXNpemUgY2hlY2suCkBAIC0yOCwxMyArMTgsNiBAQCBjbGFzcyBCaWdVcGxvYWRSZXNwb25zZQogICAgICAqLwogICAgIHByaXZhdGUgJHRlbXBEaXJlY3Rvcnk7CiAKLSAgICAvKioKLSAgICAgKiBEaXJlY3RvcnkgZm9yIGNvbXBsZXRlZCB1cGxvYWRzLgotICAgICAqCi0gICAgICogQHZhciBzdHJpbmcKLSAgICAgKi8KLSAgICBwcml2YXRlICRtYWluRGlyZWN0b3J5OwotCiAgICAgLyoqCiAgICAgICogTmFtZSBvZiB0aGUgdGVtcG9yYXJ5IGZpbGUuIFVzZWQgYXMgYSByZWZlcmVuY2UgdG8gbWFrZSBzdXJlIGNodW5rcyBnZXQgd3JpdHRlbiB0byB0aGUgcmlnaHQgZmlsZS4KICAgICAgKgpAQCAtNDksNyArMzIsNiBAQCBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoKQogICAgIHsKICAgICAgICAgJHRlbXBEaXJlY3RvcnkgPSBhcGlfZ2V0X3BhdGgoU1lTX0FSQ0hJVkVfUEFUSCk7CiAgICAgICAgICR0aGlzLT5zZXRUZW1wRGlyZWN0b3J5KCR0ZW1wRGlyZWN0b3J5KTsKLSAgICAgICAgJHRoaXMtPnNldE1haW5EaXJlY3Rvcnkoc2VsZjo6TUFJTl9ESVJFQ1RPUlkpOwogICAgICAgICAkdGhpcy0+bWF4U2l6ZSA9IGdldEluaU1heEZpbGVTaXplSW5CeXRlcygpOwogICAgIH0KIApAQCAtMTA1LDI2ICs4Nyw2IEBAIHB1YmxpYyBmdW5jdGlvbiBnZXRUZW1wRGlyZWN0b3J5KCkKICAgICAgICAgcmV0dXJuICR0aGlzLT50ZW1wRGlyZWN0b3J5OwogICAgIH0KIAotICAgIC8qKgotICAgICAqIFNldCB0aGUgbmFtZSBvZiB0aGUgbWFpbiBkaXJlY3RvcnkuCi0gICAgICoKLSAgICAgKiBAcGFyYW0gc3RyaW5nICR2YWx1ZSBNYWluIGRpcmVjdG9yeQotICAgICAqLwotICAgIHB1YmxpYyBmdW5jdGlvbiBzZXRNYWluRGlyZWN0b3J5KCR2YWx1ZSkKLSAgICB7Ci0gICAgICAgICR0aGlzLT5tYWluRGlyZWN0b3J5ID0gJHZhbHVlOwotICAgIH0KLQotICAgIC8qKgotICAgICAqIFJldHVybiB0aGUgbmFtZSBvZiB0aGUgbWFpbiBkaXJlY3RvcnkuCi0gICAgICoKLSAgICAgKiBAcmV0dXJuIHN0cmluZyBNYWluIGRpcmVjdG9yeQotICAgICAqLwotICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRNYWluRGlyZWN0b3J5KCkKLSAgICB7Ci0gICAgICAgIHJldHVybiAkdGhpcy0+bWFpbkRpcmVjdG9yeTsKLSAgICB9Ci0KICAgICAvKioKICAgICAgKiBGdW5jdGlvbiB0byB1cGxvYWQgdGhlIGluZGl2aWR1YWwgZmlsZSBjaHVua3MuCiAgICAgICoKQEAgLTI4OCwzMCArMjUwLDYgQEAgcHVibGljIGZ1bmN0aW9uIGZpbmlzaFVwbG9hZCgpCiAKICAgICAgICAgcmV0dXJuIGpzb25fZW5jb2RlKFsnZXJyb3JTdGF0dXMnID0+IDBdKTsKICAgICB9Ci0KLSAgICAvKioKLSAgICAgKiBCYXNpYyBwaHAgZmlsZSB1cGxvYWQgZnVuY3Rpb24sIHVzZWQgZm9yIHVuc3VwcG9ydGVkIGJyb3dzZXJzLgotICAgICAqIFRoZSBvdXRwdXQgb24gc3VjY2Vzcy9mYWlsdXJlIGlzIHZlcnkgYmFzaWMsIGFuZCBpdCB3b3VsZCBiZSBiZXN0IHRvIGhhdmUgdGhlc2UgZXJyb3JzIHJldHVybiB0aGUgdXNlciB0byBpbmRleC5odG1sCi0gICAgICogd2l0aCB0aGUgZXJyb3JzIHByaW50ZWQgb24gdGhlIGZvcm0sIGJ1dCB0aGF0IGlzIGJleW9uZCB0aGUgc2NvcGUgb2YgdGhpcyBwcm9qZWN0IGFzIGl0IGlzIHZlcnkgYXBwbGljYXRpb24gc3BlY2lmaWMuCi0gICAgICoKLSAgICAgKiBAcmV0dXJuIHN0cmluZyBTdWNjZXNzIG9yIGZhaWx1cmUgb2YgdXBsb2FkCi0gICAgICovCi0gICAgcHVibGljIGZ1bmN0aW9uIHBvc3RVbnN1cHBvcnRlZCgpCi0gICAgewotICAgICAgICAkbmFtZSA9ICRfRklMRVNbJ2JpZ1VwbG9hZEZpbGUnXVsnbmFtZSddOwotICAgICAgICAkc2l6ZSA9ICRfRklMRVNbJ2JpZ1VwbG9hZEZpbGUnXVsnc2l6ZSddOwotICAgICAgICAkdGVtcE5hbWUgPSAkX0ZJTEVTWydiaWdVcGxvYWRGaWxlJ11bJ3RtcF9uYW1lJ107Ci0KLSAgICAgICAgaWYgKGZpbGVzaXplKCR0ZW1wTmFtZSkgPiAkdGhpcy0+bWF4U2l6ZSkgewotICAgICAgICAgICAgcmV0dXJuIGdldF9sYW5nKCdVcGxGaWxlVG9vQmlnJyk7Ci0gICAgICAgIH0KLQotICAgICAgICBpZiAobW92ZV91cGxvYWRlZF9maWxlKCR0ZW1wTmFtZSwgJHRoaXMtPmdldE1haW5EaXJlY3RvcnkoKS4kbmFtZSkpIHsKLSAgICAgICAgICAgIHJldHVybiBnZXRfbGFuZygnRmlsZVVwbG9hZFN1Y2NlcycpOwotICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgcmV0dXJuIGdldF9sYW5nKCdVcGxVbmFibGVUb1NhdmVGaWxlJyk7Ci0gICAgICAgIH0KLSAgICB9CiB9CiAKICRzZXNzaW9uQmlnVXBsb2FkID0gQ2hhbWlsb1Nlc3Npb246OnJlYWQoJ2JpZ3VwbG9hZCcsIFtdKTsKQEAgLTM1OCw3ICsyOTYsNCBAQCBwdWJsaWMgZnVuY3Rpb24gcG9zdFVuc3VwcG9ydGVkKCkKICAgICAgICAgICAgIENoYW1pbG9TZXNzaW9uOjp3cml0ZSgnYmlndXBsb2FkJywgJHNlc3Npb25CaWdVcGxvYWQpOwogICAgICAgICB9CiAgICAgICAgIGJyZWFrOwotICAgIGNhc2UgJ3Bvc3QtdW5zdXBwb3J0ZWQnOgotICAgICAgICBwcmludCAkYmlnVXBsb2FkLT5wb3N0VW5zdXBwb3J0ZWQoKTsKLSAgICAgICAgYnJlYWs7CiB9", "url": "https://github.com/chamilo/chamilo-lms/commit/3b487a55076fb06f96809b790a35dcdd42f8ec49.patch" } ]
null
GHSA-rcx6-7jp6-pqf2
ember-source Cross-site Scripting vulnerability
null
[ { "commit_message": "[PATCH] [SECURITY CVE-2014-0014] Ensure {{group}} helper escapes properly. This vulnerability has been assigned the CVE identifier CVE-2014-0014. In general, Ember.js escapes or strips any user-supplied content before inserting it in strings that will be sent to innerHTML. However, we have identified a vulnerability that could lead to unescaped content being inserted into the innerHTML string without being sanitized. When using the `{{group}}` helper, user supplied content in the template was not being sanitized. Though the vulnerability exists in Ember.js proper, it is only exposed via the use of an experimental plugin. In applications that use the `{{group}}` helper, a specially-crafted payload could execute arbitrary JavaScript in the context of the current domain (\"XSS\"). This vulnerability was reported to us by Edward Faulkner of CleriCare. Many thanks for working with us on the patches and advisory. .../ember-handlebars/lib/helpers/binding.js | 10 +++++++++- .../tests/helpers/group_test.js | 17 +++++++++++++++++ 2 files changed, 26 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/emberjs/ember.js/commit/12fa46ba1c6efb9ddac7bfdef7f4f6909781c801.patch" } ]
null
GHSA-jcj3-xvr5-gp68
null
[ { "commit_message": "[PATCH] avformat/movenc: Do not pass AVCodecParameters in avpriv_request_sample MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes: out of array read Fixes: ffmpeg_crash_8.avi Found-by: Thuan Pham, Marcel Böhme, Andrew Santosa and Alexandru Razvan Caciulescu with AFLSmart Signed-off-by: Michael Niedermayer <michael@niedermayer.cc> libavformat/movenc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA5NTU1NmUyN2UyYzFkNTZkOWUxOGY1ZGIzNGQ2Zjc1NmYzMDExMTQ4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWNoYWVsIE5pZWRlcm1heWVyIDxtaWNoYWVsQG5pZWRlcm1heWVyLmNjPgpEYXRlOiBXZWQsIDI3IEp1biAyMDE4IDE3OjI3OjUwICswMjAwClN1YmplY3Q6IFtQQVRDSF0gYXZmb3JtYXQvbW92ZW5jOiBEbyBub3QgcGFzcyBBVkNvZGVjUGFyYW1ldGVycyBpbgogYXZwcml2X3JlcXVlc3Rfc2FtcGxlCk1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpGaXhlczogb3V0IG9mIGFycmF5IHJlYWQKRml4ZXM6IGZmbXBlZ19jcmFzaF84LmF2aQoKRm91bmQtYnk6IFRodWFuIFBoYW0sIE1hcmNlbCBCw7ZobWUsIEFuZHJldyBTYW50b3NhIGFuZCBBbGV4YW5kcnUgUmF6dmFuIENhY2l1bGVzY3Ugd2l0aCBBRkxTbWFydApTaWduZWQtb2ZmLWJ5OiBNaWNoYWVsIE5pZWRlcm1heWVyIDxtaWNoYWVsQG5pZWRlcm1heWVyLmNjPgotLS0KIGxpYmF2Zm9ybWF0L21vdmVuYy5jIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvbGliYXZmb3JtYXQvbW92ZW5jLmMgYi9saWJhdmZvcm1hdC9tb3ZlbmMuYwppbmRleCA2ZWFiZjMyZmNlMzE5Li40Y2U1YzIzYWI4MGM1IDEwMDY0NAotLS0gYS9saWJhdmZvcm1hdC9tb3ZlbmMuYworKysgYi9saWJhdmZvcm1hdC9tb3ZlbmMuYwpAQCAtNDI5LDcgKzQyOSw3IEBAIHN0YXRpYyBpbnQgaGFuZGxlX2VhYzMoTU9WTXV4Q29udGV4dCAqbW92LCBBVlBhY2tldCAqcGt0LCBNT1ZUcmFjayAqdHJhY2spCiAKICAgICAgICAgICAgIGlmIChoZHItPnN1YnN0cmVhbWlkID09IGluZm8tPm51bV9pbmRfc3ViICsgMSkgewogICAgICAgICAgICAgICAgIC8vaW5mby0+bnVtX2luZF9zdWIrKzsKLSAgICAgICAgICAgICAgICBhdnByaXZfcmVxdWVzdF9zYW1wbGUodHJhY2stPnBhciwgIk11bHRpcGxlIGluZGVwZW5kZW50IHN1YnN0cmVhbXMiKTsKKyAgICAgICAgICAgICAgICBhdnByaXZfcmVxdWVzdF9zYW1wbGUobW92LT5mYywgIk11bHRpcGxlIGluZGVwZW5kZW50IHN1YnN0cmVhbXMiKTsKICAgICAgICAgICAgICAgICByZXQgPSBBVkVSUk9SX1BBVENIV0VMQ09NRTsKICAgICAgICAgICAgICAgICBnb3RvIGVuZDsKICAgICAgICAgICAgIH0gZWxzZSBpZiAoaGRyLT5zdWJzdHJlYW1pZCA8IGluZm8tPm51bV9pbmRfc3ViIHx8", "url": "https://github.com/FFmpeg/FFmpeg/commit/95556e27e2c1d56d9e18f5db34d6f756f3011148.patch" }, { "commit_message": "[PATCH] avformat/movenc: Do not pass AVCodecParameters in avpriv_request_sample MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes: out of array read Fixes: ffmpeg_crash_8.avi Found-by: Thuan Pham, Marcel Böhme, Andrew Santosa and Alexandru Razvan Caciulescu with AFLSmart Signed-off-by: Michael Niedermayer <michael@niedermayer.cc> (cherry picked from commit 95556e27e2c1d56d9e18f5db34d6f756f3011148) Signed-off-by: Michael Niedermayer <michael@niedermayer.cc> libavformat/movenc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSBlNmQzZmQ5NDJmNzcyZjU0YWI2YTVjYTYxOWNkYWFkZWYyNmI3NzAyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWNoYWVsIE5pZWRlcm1heWVyIDxtaWNoYWVsQG5pZWRlcm1heWVyLmNjPgpEYXRlOiBXZWQsIDI3IEp1biAyMDE4IDE3OjI3OjUwICswMjAwClN1YmplY3Q6IFtQQVRDSF0gYXZmb3JtYXQvbW92ZW5jOiBEbyBub3QgcGFzcyBBVkNvZGVjUGFyYW1ldGVycyBpbgogYXZwcml2X3JlcXVlc3Rfc2FtcGxlCk1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgpGaXhlczogb3V0IG9mIGFycmF5IHJlYWQKRml4ZXM6IGZmbXBlZ19jcmFzaF84LmF2aQoKRm91bmQtYnk6IFRodWFuIFBoYW0sIE1hcmNlbCBCw7ZobWUsIEFuZHJldyBTYW50b3NhIGFuZCBBbGV4YW5kcnUgUmF6dmFuIENhY2l1bGVzY3Ugd2l0aCBBRkxTbWFydApTaWduZWQtb2ZmLWJ5OiBNaWNoYWVsIE5pZWRlcm1heWVyIDxtaWNoYWVsQG5pZWRlcm1heWVyLmNjPgooY2hlcnJ5IHBpY2tlZCBmcm9tIGNvbW1pdCA5NTU1NmUyN2UyYzFkNTZkOWUxOGY1ZGIzNGQ2Zjc1NmYzMDExMTQ4KQpTaWduZWQtb2ZmLWJ5OiBNaWNoYWVsIE5pZWRlcm1heWVyIDxtaWNoYWVsQG5pZWRlcm1heWVyLmNjPgotLS0KIGxpYmF2Zm9ybWF0L21vdmVuYy5jIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvbGliYXZmb3JtYXQvbW92ZW5jLmMgYi9saWJhdmZvcm1hdC9tb3ZlbmMuYwppbmRleCA2MjI4MTkyZjk4OTA2Li41OGM1MGY2NGNiZjg4IDEwMDY0NAotLS0gYS9saWJhdmZvcm1hdC9tb3ZlbmMuYworKysgYi9saWJhdmZvcm1hdC9tb3ZlbmMuYwpAQCAtMzc1LDcgKzM3NSw3IEBAIHN0YXRpYyBpbnQgaGFuZGxlX2VhYzMoTU9WTXV4Q29udGV4dCAqbW92LCBBVlBhY2tldCAqcGt0LCBNT1ZUcmFjayAqdHJhY2spCiAKICAgICAgICAgICAgIGlmIChoZHItPnN1YnN0cmVhbWlkID09IGluZm8tPm51bV9pbmRfc3ViICsgMSkgewogICAgICAgICAgICAgICAgIC8vaW5mby0+bnVtX2luZF9zdWIrKzsKLSAgICAgICAgICAgICAgICBhdnByaXZfcmVxdWVzdF9zYW1wbGUodHJhY2stPnBhciwgIk11bHRpcGxlIGluZGVwZW5kZW50IHN1YnN0cmVhbXMiKTsKKyAgICAgICAgICAgICAgICBhdnByaXZfcmVxdWVzdF9zYW1wbGUobW92LT5mYywgIk11bHRpcGxlIGluZGVwZW5kZW50IHN1YnN0cmVhbXMiKTsKICAgICAgICAgICAgICAgICByZXR1cm4gQVZFUlJPUl9QQVRDSFdFTENPTUU7CiAgICAgICAgICAgICB9IGVsc2UgaWYgKGhkci0+c3Vic3RyZWFtaWQgPCBpbmZvLT5udW1faW5kX3N1YiB8fAogICAgICAgICAgICAgICAgICAgICAgICBoZHItPnN1YnN0cmVhbWlkID09IDAgJiYgaW5mby0+c3Vic3RyZWFtWzBdLmJzaWQpIHs=", "url": "https://github.com/FFmpeg/FFmpeg/commit/e6d3fd942f772f54ab6a5ca619cdaadef26b7702.patch" } ]
null
CVE-2022-2290
Cross-site Scripting (XSS) - Reflected in zadam/trilium
Cross-site Scripting (XSS) - Reflected in GitHub repository zadam/trilium prior to 0.52.4, 0.53.1-beta.
[ { "commit_message": "[PATCH] set correct content type for error messages package-lock.json | 4 ++-- src/routes/api/export.js | 8 ++++++-- src/routes/api/files.js | 4 +++- src/routes/api/image.js | 8 +++++--- src/routes/api/note_revisions.js | 8 ++++++-- src/routes/custom.js | 8 ++++++-- src/routes/routes.js | 12 ++++++++++-- src/services/auth.js | 16 ++++++++++++---- src/share/routes.js | 30 +++++++++++++++++++++--------- 9 files changed, 71 insertions(+), 27 deletions(-)", "patch_text_b64": "From 3faae63b849a1fabc31b823bb7af3a84d32256a7 Mon Sep 17 00:00:00 2001
From: zadam <zadam.apps@gmail.com>
Date: Fri, 1 Jul 2022 00:01:29 +0200
Subject: [PATCH] set correct content type for error messages

---
 package-lock.json                |  4 ++--
 src/routes/api/export.js         |  8 ++++++--
 src/routes/api/files.js          |  4 +++-
 src/routes/api/image.js          |  8 +++++---
 src/routes/api/note_revisions.js |  8 ++++++--
 src/routes/custom.js             |  8 ++++++--
 src/routes/routes.js             | 12 ++++++++++--
 src/services/auth.js             | 16 ++++++++++++----
 src/share/routes.js              | 30 +++++++++++++++++++++---------
 9 files changed, 71 insertions(+), 27 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index a873e3fa7c4..132da101595 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "trilium",
-  "version": "0.52.1-beta",
+  "version": "0.52.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "trilium",
-      "version": "0.52.1-beta",
+      "version": "0.52.3",
       "hasInstallScript": true,
       "license": "AGPL-3.0-only",
       "dependencies": {
diff --git a/src/routes/api/export.js b/src/routes/api/export.js
index fe772e4936f..6acb19952d9 100644
--- a/src/routes/api/export.js
+++ b/src/routes/api/export.js
@@ -15,7 +15,9 @@ function exportBranch(req, res) {
         const message = `Cannot export branch ${branchId} since it does not exist.`;
         log.error(message);
 
-        res.status(500).send(message);
+        res.setHeader("Content-Type", "text/plain")
+            .status(500)
+            .send(message);
         return;
     }
 
@@ -41,7 +43,9 @@ function exportBranch(req, res) {
 
         log.error(message + e.stack);
 
-        res.status(500).send(message);
+        res.setHeader("Content-Type", "text/plain")
+            .status(500)
+            .send(message);
     }
 }
 
diff --git a/src/routes/api/files.js b/src/routes/api/files.js
index 3aa2d51b6bb..d28e81169fc 100644
--- a/src/routes/api/files.js
+++ b/src/routes/api/files.js
@@ -48,7 +48,9 @@ function downloadNoteFile(noteId, res, contentDisposition = true) {
     const note = becca.getNote(noteId);
 
     if (!note) {
-        return res.status(404).send(`Note ${noteId} doesn't exist.`);
+        return res.setHeader("Content-Type", "text/plain")
+            .status(404)
+            .send(`Note ${noteId} doesn't exist.`);
     }
 
     if (note.isProtected && !protectedSessionService.isProtectedSessionAvailable()) {
diff --git a/src/routes/api/image.js b/src/routes/api/image.js
index 7807f1fb926..f54395697b0 100644
--- a/src/routes/api/image.js
+++ b/src/routes/api/image.js
@@ -20,20 +20,22 @@ function returnImage(req, res) {
     }
 
     /**
-     * special "image" type. the canvas is actually type application/json 
+     * special "image" type. the canvas is actually type application/json
      * to avoid bitrot and enable usage as referenced image the svg is included.
      */
     if (image.type === 'canvas') {
         const content = image.getContent();
         try {
             const data = JSON.parse(content);
-            
+
             const svg = data.svg || '<svg />'
             res.set('Content-Type', "image/svg+xml");
             res.set("Cache-Control", "no-cache, no-store, must-revalidate");
             res.send(svg);
         } catch(err) {
-            res.status(500).send("there was an error parsing excalidraw to svg");
+            res.setHeader("Content-Type", "text/plain")
+                .status(500)
+                .send("there was an error parsing excalidraw to svg");
         }
     } else {
         res.set('Content-Type', image.mime);
diff --git a/src/routes/api/note_revisions.js b/src/routes/api/note_revisions.js
index 6052e995077..db1b65794c9 100644
--- a/src/routes/api/note_revisions.js
+++ b/src/routes/api/note_revisions.js
@@ -65,11 +65,15 @@ function downloadNoteRevision(req, res) {
     const noteRevision = becca.getNoteRevision(req.params.noteRevisionId);
 
     if (noteRevision.noteId !== req.params.noteId) {
-        return res.status(400).send(`Note revision ${req.params.noteRevisionId} does not belong to note ${req.params.noteId}`);
+        return res.setHeader("Content-Type", "text/plain")
+            .status(400)
+            .send(`Note revision ${req.params.noteRevisionId} does not belong to note ${req.params.noteId}`);
     }
 
     if (noteRevision.isProtected && !protectedSessionService.isProtectedSessionAvailable()) {
-        return res.status(401).send("Protected session not available");
+        return res.setHeader("Content-Type", "text/plain")
+            .status(401)
+            .send("Protected session not available");
     }
 
     const filename = getRevisionFilename(noteRevision);
diff --git a/src/routes/custom.js b/src/routes/custom.js
index 9b190405384..7a6ee9c4695 100644
--- a/src/routes/custom.js
+++ b/src/routes/custom.js
@@ -49,7 +49,9 @@ function handleRequest(req, res) {
             catch (e) {
                 log.error(`Custom handler ${note.noteId} failed with ${e.message}`);
 
-                res.status(500).send(e.message);
+                res.setHeader("Content-Type", "text/plain")
+                    .status(500)
+                    .send(e.message);
             }
         }
         else if (attr.name === 'customResourceProvider') {
@@ -65,7 +67,9 @@ function handleRequest(req, res) {
     const message = `No handler matched for custom ${path} request.`;
 
     log.info(message);
-    res.status(404).send(message);
+    res.setHeader("Content-Type", "text/plain")
+        .status(404)
+        .send(message);
 }
 
 function register(router) {
diff --git a/src/routes/routes.js b/src/routes/routes.js
index b51f1a5214f..b10ca45e969 100644
--- a/src/routes/routes.js
+++ b/src/routes/routes.js
@@ -120,6 +120,10 @@ function apiResultHandler(req, res, result) {
 
 function send(res, statusCode, response) {
     if (typeof response === 'string') {
+        if (statusCode >= 400) {
+            res.setHeader("Content-Type", "text/plain");
+        }
+
         res.status(statusCode).send(response);
 
         return response.length;
@@ -167,7 +171,9 @@ function route(method, path, middleware, routeHandler, resultHandler, transactio
                         .catch(e => {
                             log.error(`${method} ${path} threw exception: ` + e.stack);
 
-                            res.status(500).send(e.message);
+                            res.setHeader("Content-Type", "text/plain")
+                                .status(500)
+                                .send(e.message);
                         });
                 }
                 else {
@@ -180,7 +186,9 @@ function route(method, path, middleware, routeHandler, resultHandler, transactio
         catch (e) {
             log.error(`${method} ${path} threw exception: ` + e.stack);
 
-            res.status(500).send(e.message);
+            res.setHeader("Content-Type", "text/plain")
+                .status(500)
+                .send(e.message);
         }
     });
 }
diff --git a/src/services/auth.js b/src/services/auth.js
index 3b36fa51cbb..331f1d252e8 100644
--- a/src/services/auth.js
+++ b/src/services/auth.js
@@ -88,17 +88,23 @@ function checkEtapiToken(req, res, next) {
 function reject(req, res, message) {
     log.info(`${req.method} ${req.path} rejected with 401 ${message}`);
 
-    res.status(401).send(message);
+    res.setHeader("Content-Type", "text/plain")
+        .status(401)
+        .send(message);
 }
 
 function checkCredentials(req, res, next) {
     if (!sqlInit.isDbInitialized()) {
-        res.status(400).send('Database is not initialized yet.');
+        res.setHeader("Content-Type", "text/plain")
+            .status(400)
+            .send('Database is not initialized yet.');
         return;
     }
 
     if (!passwordService.isPasswordSet()) {
-        res.status(400).send('Password has not been set yet. Please set a password and repeat the action');
+        res.setHeader("Content-Type", "text/plain")
+            .status(400)
+            .send('Password has not been set yet. Please set a password and repeat the action');
         return;
     }
 
@@ -109,7 +115,9 @@ function checkCredentials(req, res, next) {
     // username is ignored
 
     if (!passwordEncryptionService.verifyPassword(password)) {
-        res.status(401).send('Incorrect password');
+        res.setHeader("Content-Type", "text/plain")
+            .status(401)
+            .send('Incorrect password');
     }
     else {
         next();
diff --git a/src/share/routes.js b/src/share/routes.js
index ce858ad6b09..74ff02e04fd 100644
--- a/src/share/routes.js
+++ b/src/share/routes.js
@@ -39,9 +39,9 @@ function register(router) {
         addNoIndexHeader(note, res);
 
         if (note.hasLabel('shareRaw') || ['image', 'file'].includes(note.type)) {
-            res.setHeader('Content-Type', note.mime);
+            res.setHeader('Content-Type', note.mime)
+                .send(note.getContent());
 
-            res.send(note.getContent());
             return;
         }
 
@@ -83,7 +83,9 @@ function register(router) {
         const note = shaca.getNote(noteId);
 
         if (!note) {
-            return res.status(404).send(`Note '${noteId}' not found`);
+            return res.setHeader("Content-Type", "text/plain")
+                .status(404)
+                .send(`Note '${noteId}' not found`);
         }
 
         addNoIndexHeader(note, res);
@@ -98,7 +100,9 @@ function register(router) {
         const note = shaca.getNote(noteId);
 
         if (!note) {
-            return res.status(404).send(`Note '${noteId}' not found`);
+            return res.setHeader("Content-Type", "text/plain")
+                .status(404)
+                .send(`Note '${noteId}' not found`);
         }
 
         addNoIndexHeader(note, res);
@@ -122,13 +126,17 @@ function register(router) {
         const image = shaca.getNote(req.params.noteId);
 
         if (!image) {
-            return res.status(404).send(`Note '${req.params.noteId}' not found`);
+            return res.setHeader('Content-Type', 'text/plain')
+                .status(404)
+                .send(`Note '${req.params.noteId}' not found`);
         }
         else if (!["image", "canvas"].includes(image.type)) {
-            return res.status(400).send("Requested note is not a shareable image");
+            return res.setHeader('Content-Type', 'text/plain')
+                .status(400)
+                .send("Requested note is not a shareable image");
         } else if (image.type === "canvas") {
             /**
-             * special "image" type. the canvas is actually type application/json 
+             * special "image" type. the canvas is actually type application/json
              * to avoid bitrot and enable usage as referenced image the svg is included.
              */
             const content = image.getContent();
@@ -141,7 +149,9 @@ function register(router) {
                 res.set("Cache-Control", "no-cache, no-store, must-revalidate");
                 res.send(svg);
             } catch(err) {
-                res.status(500).send("there was an error parsing excalidraw to svg");
+                res.setHeader('Content-Type', 'text/plain')
+                    .status(500)
+                    .send("there was an error parsing excalidraw to svg");
             }
         } else {
             // normal image
@@ -159,7 +169,9 @@ function register(router) {
         const note = shaca.getNote(noteId);
 
         if (!note) {
-            return res.status(404).send(`Note '${noteId}' not found`);
+            return res.setHeader('Content-Type', 'text/plain')
+                .status(404)
+                .send(`Note '${noteId}' not found`);
         }
 
         addNoIndexHeader(note, res);", "url": "https://github.com/zadam/trilium/commit/3faae63b849a1fabc31b823bb7af3a84d32256a7.patch" } ]
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
GHSA-qg48-85hg-mqc5
Division by 0 in `DenseCountSparseOutput`
null
[ { "commit_message": "[PATCH] Fix FPE issue with `tf.raw_ops.DenseCountSparseOutput`. PiperOrigin-RevId: 370946862 Change-Id: I3752584ad04aaecb327ff6793a9640ac56acfe7a tensorflow/core/kernels/count_ops.cc | 3 +++ 1 file changed, 3 insertions(+)", "patch_text_b64": "RnJvbSBkYTVmZjJkYWY2MTg1OTFmNjRiMmI2MmQ5ZDk4MDM5NTFiOTQ1ZTlmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IFBhdGFua2FyIDxhbWl0cGF0YW5rYXJAZ29vZ2xlLmNvbT4KRGF0ZTogV2VkLCAyOCBBcHIgMjAyMSAxMToyNDo0NSAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIEZpeCBGUEUgaXNzdWUgd2l0aCBgdGYucmF3X29wcy5EZW5zZUNvdW50U3BhcnNlT3V0cHV0YC4KClBpcGVyT3JpZ2luLVJldklkOiAzNzA5NDY4NjIKQ2hhbmdlLUlkOiBJMzc1MjU4NGFkMDRhYWVjYjMyN2ZmNjc5M2E5NjQwYWM1NmFjZmU3YQotLS0KIHRlbnNvcmZsb3cvY29yZS9rZXJuZWxzL2NvdW50X29wcy5jYyB8IDMgKysrCiAxIGZpbGUgY2hhbmdlZCwgMyBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvY291bnRfb3BzLmNjIGIvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvY291bnRfb3BzLmNjCmluZGV4IGVlYjBiODUzYzdhYWQyLi40MGFhMWZlNDU4YzFlZSAxMDA2NDQKLS0tIGEvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvY291bnRfb3BzLmNjCisrKyBiL3RlbnNvcmZsb3cvY29yZS9rZXJuZWxzL2NvdW50X29wcy5jYwpAQCAtMTIyLDYgKzEyMiw5IEBAIGNsYXNzIERlbnNlQ291bnQgOiBwdWJsaWMgT3BLZXJuZWwgewogCiAgICAgaW50IG51bV9iYXRjaF9lbGVtZW50cyA9IDE7CiAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1fYmF0Y2hfZGltZW5zaW9uczsgKytpKSB7CisgICAgICBPUF9SRVFVSVJFUyhjb250ZXh0LCBkYXRhLnNoYXBlKCkuZGltX3NpemUoaSkgIT0gMCwKKyAgICAgICAgICAgICAgICAgIGVycm9yczo6SW52YWxpZEFyZ3VtZW50KAorICAgICAgICAgICAgICAgICAgICAgICJJbnZhbGlkIGlucHV0OiBTaGFwZXMgZGltZW5zaW9uIGNhbm5vdCBiZSAwLiIpKTsKICAgICAgIG51bV9iYXRjaF9lbGVtZW50cyAqPSBkYXRhLnNoYXBlKCkuZGltX3NpemUoaSk7CiAgICAgfQogICAgIGludCBudW1fdmFsdWVfZWxlbWVudHMgPSBkYXRhLnNoYXBlKCkubnVtX2VsZW1lbnRzKCkgLyBudW1fYmF0Y2hfZWxlbWVudHM7", "url": "https://github.com/tensorflow/tensorflow/commit/da5ff2daf618591f64b2b62d9d9803951b945e9f.patch" } ]
null
GHSA-66xq-fc4p-m6xv
null
[ { "commit_message": "[PATCH] avformat/rtmppkt: Convert ff_amf_get_field_value() to bytestream2 Fixes: out of array accesses Found-by: JunDong Xie of Ant-financial Light-Year Security Lab Signed-off-by: Michael Niedermayer <michael@niedermayer.cc> libavformat/rtmppkt.c | 57 ++++++++++++++++++++++++++++--------------- 1 file changed, 37 insertions(+), 20 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/FFmpeg/FFmpeg/commit/ffcc82219cef0928bed2d558b19ef6ea35634130.patch" } ]
null
CVE-2017-8064
drivers/media/usb/dvb-usb-v2/dvb_usb_core.c in the Linux kernel 4.9.x and 4.10.x before 4.10.12 interacts incorrectly with the CONFIG_VMAP_STACK option, which allows local users to cause a denial of service (system crash or memory corruption) or possibly have unspecified other impact by leveraging use of more than one virtual page for a DMA scatterlist.
[ { "commit_message": "[PATCH] [media] dvb-usb-v2: avoid use-after-free I ran into a stack frame size warning because of the on-stack copy of the USB device structure: drivers/media/usb/dvb-usb-v2/dvb_usb_core.c: In function 'dvb_usbv2_disconnect': drivers/media/usb/dvb-usb-v2/dvb_usb_core.c:1029:1: error: the frame size of 1104 bytes is larger than 1024 bytes [-Werror=frame-larger-than=] Copying a device structure like this is wrong for a number of other reasons too aside from the possible stack overflow. One of them is that the dev_info() call will print the name of the device later, but AFAICT we have only copied a pointer to the name earlier and the actual name has been freed by the time it gets printed. This removes the on-stack copy of the device and instead copies the device name using kstrdup(). I'm ignoring the possible failure here as both printk() and kfree() are able to deal with NULL pointers. Signed-off-by: Arnd Bergmann <arnd@arndb.de> Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com> drivers/media/usb/dvb-usb-v2/dvb_usb_core.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/torvalds/linux/commit/005145378c9ad7575a01b6ce1ba118fb427f583a.patch" } ]
n/a
CVE-2020-15102
Improper access control on dashboard form in PrestaShop
In PrestaShop Dashboard Productions before version 2.1.0, there is improper authorization which enables an attacker to change the configuration. The problem is fixed in 2.1.0.
[ { "commit_message": "[PATCH 1/3] Improve check on values dashproducts.php | 42 +++- views/templates/hook/dashboard_zone_two.tpl | 228 ++++++++++---------- 2 files changed, 157 insertions(+), 113 deletions(-)", "patch_text_b64": "From c86f1757715c600f7b8c5ed88b44670996c5ec73 Mon Sep 17 00:00:00 2001
From: Pierre RAMBAUD <pierre.rambaud86@gmail.com>
Date: Tue, 2 Jun 2020 10:57:14 +0200
Subject: [PATCH 1/3] Improve  check on values

---
 dashproducts.php                            |  42 +++-
 views/templates/hook/dashboard_zone_two.tpl | 228 ++++++++++----------
 2 files changed, 157 insertions(+), 113 deletions(-)

diff --git a/dashproducts.php b/dashproducts.php
index e08c6d3..085de9e 100755
--- a/dashproducts.php
+++ b/dashproducts.php
@@ -72,7 +72,7 @@ public function hookDashboardZoneTwo($params)
                 'DASHPRODUCT_NBR_SHOW_TOP_SEARCH' => Configuration::get('DASHPRODUCT_NBR_SHOW_TOP_SEARCH'),
                 'date_from' => Tools::displayDate($params['date_from']),
                 'date_to' => Tools::displayDate($params['date_to']),
-                'dashproducts_config_form' => $this->renderConfigForm(),
+                'dashproducts_config_form' => $this->getPermission('configure') ? $this->renderConfigForm() : null,
             )
         );
 
@@ -617,4 +617,44 @@ public function hookActionSearch($params)
     {
         Tools::changeFileMTime($this->push_filename);
     }
+
+    /**
+     * Validate dashboard configuration
+     *
+     * @param array $config
+     *
+     * @return array
+     */
+    public function validateDashConfig(array $config)
+    {
+        $errors = [];
+        $possibleValues = [5, 10 , 20, 50];
+        foreach (array_keys($this->getConfigFieldsValues()) as $fieldName) {
+            if (!isset($config[$fieldName]) || !in_array($config[$fieldName], $possibleValues)) {
+                $errors[$fieldName] = $this->trans('The %s field is invalid.', [$fieldName], 'Modules.Dashproducts.Admin');
+            }
+        }
+
+        return $errors;
+    }
+
+    /**
+     * Save dashboard configuration
+     *
+     * @param array $config
+     *
+     * @return bool determines if there are errors or not
+     */
+    public function saveDashConfig(array $config)
+    {
+        if (!$this->getPermission('configure')) {
+            return true;
+        }
+
+        foreach (array_keys($this->getConfigFieldsValues()) as $fieldName) {
+            Configuration::updateValue($fieldName, (int) $config[$fieldName]);
+        }
+
+        return false;
+    }
 }
diff --git a/views/templates/hook/dashboard_zone_two.tpl b/views/templates/hook/dashboard_zone_two.tpl
index 084c6af..ee2b773 100644
--- a/views/templates/hook/dashboard_zone_two.tpl
+++ b/views/templates/hook/dashboard_zone_two.tpl
@@ -1,123 +1,127 @@
 {*
-* 2007-2018 PrestaShop
-*
-* NOTICE OF LICENSE
-*
-* This source file is subject to the Academic Free License (AFL 3.0)
-* that is bundled with this package in the file LICENSE.txt.
-* It is also available through the world-wide-web at this URL:
-* http://opensource.org/licenses/afl-3.0.php
-* If you did not receive a copy of the license and are unable to
-* obtain it through the world-wide-web, please send an email
-* to license@prestashop.com so we can send you a copy immediately.
-*
-* DISCLAIMER
-*
-* Do not edit or add to this file if you wish to upgrade PrestaShop to newer
-* versions in the future. If you wish to customize PrestaShop for your
-* needs please refer to http://www.prestashop.com for more information.
-*
-*  @author PrestaShop SA <contact@prestashop.com>
-*  @copyright  2007-2018 PrestaShop SA
-*  @license    http://opensource.org/licenses/afl-3.0.php  Academic Free License (AFL 3.0)
-*  International Registered Trademark & Property of PrestaShop SA
-*}
+  * 2007-2018 PrestaShop
+  *
+  * NOTICE OF LICENSE
+  *
+  * This source file is subject to the Academic Free License (AFL 3.0)
+  * that is bundled with this package in the file LICENSE.txt.
+  * It is also available through the world-wide-web at this URL:
+  * http://opensource.org/licenses/afl-3.0.php
+  * If you did not receive a copy of the license and are unable to
+  * obtain it through the world-wide-web, please send an email
+  * to license@prestashop.com so we can send you a copy immediately.
+  *
+  * DISCLAIMER
+  *
+  * Do not edit or add to this file if you wish to upgrade PrestaShop to newer
+  * versions in the future. If you wish to customize PrestaShop for your
+  * needs please refer to http://www.prestashop.com for more information.
+  *
+  *  @author PrestaShop SA <contact@prestashop.com>
+  *  @copyright  2007-2018 PrestaShop SA
+  *  @license    http://opensource.org/licenses/afl-3.0.php  Academic Free License (AFL 3.0)
+  *  International Registered Trademark & Property of PrestaShop SA
+  *}
 
 <section id="dashproducts" class="panel widget {if $allow_push} allow_push{/if}">
-	<header class="panel-heading">
-		<i class="icon-bar-chart"></i> {l s='Products and Sales' d='Modules.Dashproducts.Admin'}
-		<span class="panel-heading-action">
-			<a class="list-toolbar-btn" href="#" onclick="toggleDashConfig('dashproducts'); return false;" title="{l s='Configure' d='Admin.Actions'}">
-				<i class="process-icon-configure"></i>
-			</a>
-			<a class="list-toolbar-btn" href="#"  onclick="refreshDashboard('dashproducts'); return false;"  title="{l s='Refresh' d='Admin.Actions'}">
-				<i class="process-icon-refresh"></i>
-			</a>
-		</span>
-	</header>
+  <header class="panel-heading">
+	<i class="icon-bar-chart"></i> {l s='Products and Sales' d='Modules.Dashproducts.Admin'}
+	<span class="panel-heading-action">
+      {if !empty($dashproducts_config_form)}
+	    <a class="list-toolbar-btn" href="#" onclick="toggleDashConfig('dashproducts'); return false;" title="{l s='Configure' d='Admin.Actions'}">
+		  <i class="process-icon-configure"></i>
+	    </a>
+      {/if}
+	  <a class="list-toolbar-btn" href="#"  onclick="refreshDashboard('dashproducts'); return false;"  title="{l s='Refresh' d='Admin.Actions'}">
+		<i class="process-icon-refresh"></i>
+	  </a>
+	</span>
+  </header>
 
+  {if !empty($dashproducts_config_form)}
 	<section id="dashproducts_config" class="dash_config hide">
-		<header><i class="icon-wrench"></i> {l s='Configuration' d='Admin.Global'}</header>
-		{$dashproducts_config_form}
+	  <header><i class="icon-wrench"></i> {l s='Configuration' d='Admin.Global'}</header>
+	  {$dashproducts_config_form}
 	</section>
+  {/if}
 
-	<section>
-		<nav>
-			<ul class="nav nav-pills">
-				<li class="active">
-					<a href="#dash_recent_orders" data-toggle="tab">
-						<i class="icon-fire"></i>
-						<span class="hidden-inline-xs">{l s='Recent Orders' d='Modules.Dashproducts.Admin'}</span>
-					</a>
-				</li>
-				<li>
-					<a href="#dash_best_sellers" data-toggle="tab">
-						<i class="icon-trophy"></i>
-						<span class="hidden-inline-xs">{l s='Best Sellers' d='Modules.Dashproducts.Admin'}</span>
-					</a>
-				</li>
-				<li>
-					<a href="#dash_most_viewed" data-toggle="tab">
-						<i class="icon-eye-open"></i>
-						<span class="hidden-inline-xs">{l s='Most Viewed' d='Modules.Dashproducts.Admin'}</span>
-					</a>
-				</li>
-				<li>
-					<a href="#dash_top_search" data-toggle="tab">
-						<i class="icon-search"></i>
-						<span class="hidden-inline-xs">{l s='Top Searches' d='Modules.Dashproducts.Admin'}</span>
-					</a>
-				</li>
-			</ul>
-		</nav>
+  <section>
+	<nav>
+	  <ul class="nav nav-pills">
+		<li class="active">
+		  <a href="#dash_recent_orders" data-toggle="tab">
+			<i class="icon-fire"></i>
+			<span class="hidden-inline-xs">{l s='Recent Orders' d='Modules.Dashproducts.Admin'}</span>
+		  </a>
+		</li>
+		<li>
+		  <a href="#dash_best_sellers" data-toggle="tab">
+			<i class="icon-trophy"></i>
+			<span class="hidden-inline-xs">{l s='Best Sellers' d='Modules.Dashproducts.Admin'}</span>
+		  </a>
+		</li>
+		<li>
+		  <a href="#dash_most_viewed" data-toggle="tab">
+			<i class="icon-eye-open"></i>
+			<span class="hidden-inline-xs">{l s='Most Viewed' d='Modules.Dashproducts.Admin'}</span>
+		  </a>
+		</li>
+		<li>
+		  <a href="#dash_top_search" data-toggle="tab">
+			<i class="icon-search"></i>
+			<span class="hidden-inline-xs">{l s='Top Searches' d='Modules.Dashproducts.Admin'}</span>
+		  </a>
+		</li>
+	  </ul>
+	</nav>
 
-		<div class="tab-content panel">
-			<div class="tab-pane active" id="dash_recent_orders">
-				<h3>{l s='Last %d orders' sprintf=$DASHPRODUCT_NBR_SHOW_LAST_ORDER|intval d='Modules.Dashproducts.Admin'}</h3>
-				<div class="table-responsive">
-					<table class="table data_table" id="table_recent_orders">
-						<thead></thead>
-						<tbody></tbody>
-					</table>
-				</div>
-			</div>
-			<div class="tab-pane" id="dash_best_sellers">
-				<h3>
-					{l s='Top %d products' sprintf=$DASHPRODUCT_NBR_SHOW_BEST_SELLER|intval d='Modules.Dashproducts.Admin'}
-					<span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
-				</h3>
-				<div class="table-responsive">
-					<table class="table data_table" id="table_best_sellers">
-						<thead></thead>
-						<tbody></tbody>
-					</table>
-				</div>
-			</div>
-			<div class="tab-pane" id="dash_most_viewed">
-				<h3>
-					{l s="Most Viewed" d='Modules.Dashproducts.Admin'}
-					<span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
-				</h3>
-				<div class="table-responsive">
-					<table class="table data_table" id="table_most_viewed">
-						<thead></thead>
-						<tbody></tbody>
-					</table>
-				</div>
-			</div>
-			<div class="tab-pane" id="dash_top_search">
-				<h3>
-					{l s='Top %d most search terms' sprintf=$DASHPRODUCT_NBR_SHOW_TOP_SEARCH|intval d='Modules.Dashproducts.Admin'}
-					<span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
-				</h3>
-				<div class="table-responsive">
-					<table class="table data_table" id="table_top_10_most_search">
-						<thead></thead>
-						<tbody></tbody>
-					</table>
-				</div>
-			</div>
+	<div class="tab-content panel">
+	  <div class="tab-pane active" id="dash_recent_orders">
+		<h3>{l s='Last %d orders' sprintf=$DASHPRODUCT_NBR_SHOW_LAST_ORDER|intval d='Modules.Dashproducts.Admin'}</h3>
+		<div class="table-responsive">
+		  <table class="table data_table" id="table_recent_orders">
+			<thead></thead>
+			<tbody></tbody>
+		  </table>
 		</div>
+	  </div>
+	  <div class="tab-pane" id="dash_best_sellers">
+		<h3>
+		  {l s='Top %d products' sprintf=$DASHPRODUCT_NBR_SHOW_BEST_SELLER|intval d='Modules.Dashproducts.Admin'}
+		  <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
+		</h3>
+		<div class="table-responsive">
+		  <table class="table data_table" id="table_best_sellers">
+			<thead></thead>
+			<tbody></tbody>
+		  </table>
+		</div>
+	  </div>
+	  <div class="tab-pane" id="dash_most_viewed">
+		<h3>
+		  {l s="Most Viewed" d='Modules.Dashproducts.Admin'}
+		  <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
+		</h3>
+		<div class="table-responsive">
+		  <table class="table data_table" id="table_most_viewed">
+			<thead></thead>
+			<tbody></tbody>
+		  </table>
+		</div>
+	  </div>
+	  <div class="tab-pane" id="dash_top_search">
+		<h3>
+		  {l s='Top %d most search terms' sprintf=$DASHPRODUCT_NBR_SHOW_TOP_SEARCH|intval d='Modules.Dashproducts.Admin'}
+		  <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
+		</h3>
+		<div class="table-responsive">
+		  <table class="table data_table" id="table_top_10_most_search">
+			<thead></thead>
+			<tbody></tbody>
+		  </table>
+		</div>
+	  </div>
+	</div>
 
-	</section>
+  </section>
 </section>

From f65969590cd2eff9754abf68bd0fe9f1327f6bce Mon Sep 17 00:00:00 2001
From: Pierre RAMBAUD <pierre.rambaud86@gmail.com>
Date: Tue, 2 Jun 2020 10:58:23 +0200
Subject: [PATCH 2/3] Replace tabs by spaces

---
 views/templates/hook/dashboard_zone_two.tpl | 176 ++++++++++----------
 1 file changed, 88 insertions(+), 88 deletions(-)

diff --git a/views/templates/hook/dashboard_zone_two.tpl b/views/templates/hook/dashboard_zone_two.tpl
index ee2b773..1a497ca 100644
--- a/views/templates/hook/dashboard_zone_two.tpl
+++ b/views/templates/hook/dashboard_zone_two.tpl
@@ -25,103 +25,103 @@
 
 <section id="dashproducts" class="panel widget {if $allow_push} allow_push{/if}">
   <header class="panel-heading">
-	<i class="icon-bar-chart"></i> {l s='Products and Sales' d='Modules.Dashproducts.Admin'}
-	<span class="panel-heading-action">
+    <i class="icon-bar-chart"></i> {l s='Products and Sales' d='Modules.Dashproducts.Admin'}
+    <span class="panel-heading-action">
       {if !empty($dashproducts_config_form)}
-	    <a class="list-toolbar-btn" href="#" onclick="toggleDashConfig('dashproducts'); return false;" title="{l s='Configure' d='Admin.Actions'}">
-		  <i class="process-icon-configure"></i>
-	    </a>
+        <a class="list-toolbar-btn" href="#" onclick="toggleDashConfig('dashproducts'); return false;" title="{l s='Configure' d='Admin.Actions'}">
+          <i class="process-icon-configure"></i>
+        </a>
       {/if}
-	  <a class="list-toolbar-btn" href="#"  onclick="refreshDashboard('dashproducts'); return false;"  title="{l s='Refresh' d='Admin.Actions'}">
-		<i class="process-icon-refresh"></i>
-	  </a>
-	</span>
+      <a class="list-toolbar-btn" href="#"  onclick="refreshDashboard('dashproducts'); return false;"  title="{l s='Refresh' d='Admin.Actions'}">
+        <i class="process-icon-refresh"></i>
+      </a>
+    </span>
   </header>
 
   {if !empty($dashproducts_config_form)}
-	<section id="dashproducts_config" class="dash_config hide">
-	  <header><i class="icon-wrench"></i> {l s='Configuration' d='Admin.Global'}</header>
-	  {$dashproducts_config_form}
-	</section>
+    <section id="dashproducts_config" class="dash_config hide">
+      <header><i class="icon-wrench"></i> {l s='Configuration' d='Admin.Global'}</header>
+      {$dashproducts_config_form}
+    </section>
   {/if}
 
   <section>
-	<nav>
-	  <ul class="nav nav-pills">
-		<li class="active">
-		  <a href="#dash_recent_orders" data-toggle="tab">
-			<i class="icon-fire"></i>
-			<span class="hidden-inline-xs">{l s='Recent Orders' d='Modules.Dashproducts.Admin'}</span>
-		  </a>
-		</li>
-		<li>
-		  <a href="#dash_best_sellers" data-toggle="tab">
-			<i class="icon-trophy"></i>
-			<span class="hidden-inline-xs">{l s='Best Sellers' d='Modules.Dashproducts.Admin'}</span>
-		  </a>
-		</li>
-		<li>
-		  <a href="#dash_most_viewed" data-toggle="tab">
-			<i class="icon-eye-open"></i>
-			<span class="hidden-inline-xs">{l s='Most Viewed' d='Modules.Dashproducts.Admin'}</span>
-		  </a>
-		</li>
-		<li>
-		  <a href="#dash_top_search" data-toggle="tab">
-			<i class="icon-search"></i>
-			<span class="hidden-inline-xs">{l s='Top Searches' d='Modules.Dashproducts.Admin'}</span>
-		  </a>
-		</li>
-	  </ul>
-	</nav>
+    <nav>
+      <ul class="nav nav-pills">
+        <li class="active">
+          <a href="#dash_recent_orders" data-toggle="tab">
+            <i class="icon-fire"></i>
+            <span class="hidden-inline-xs">{l s='Recent Orders' d='Modules.Dashproducts.Admin'}</span>
+          </a>
+        </li>
+        <li>
+          <a href="#dash_best_sellers" data-toggle="tab">
+            <i class="icon-trophy"></i>
+            <span class="hidden-inline-xs">{l s='Best Sellers' d='Modules.Dashproducts.Admin'}</span>
+          </a>
+        </li>
+        <li>
+          <a href="#dash_most_viewed" data-toggle="tab">
+            <i class="icon-eye-open"></i>
+            <span class="hidden-inline-xs">{l s='Most Viewed' d='Modules.Dashproducts.Admin'}</span>
+          </a>
+        </li>
+        <li>
+          <a href="#dash_top_search" data-toggle="tab">
+            <i class="icon-search"></i>
+            <span class="hidden-inline-xs">{l s='Top Searches' d='Modules.Dashproducts.Admin'}</span>
+          </a>
+        </li>
+      </ul>
+    </nav>
 
-	<div class="tab-content panel">
-	  <div class="tab-pane active" id="dash_recent_orders">
-		<h3>{l s='Last %d orders' sprintf=$DASHPRODUCT_NBR_SHOW_LAST_ORDER|intval d='Modules.Dashproducts.Admin'}</h3>
-		<div class="table-responsive">
-		  <table class="table data_table" id="table_recent_orders">
-			<thead></thead>
-			<tbody></tbody>
-		  </table>
-		</div>
-	  </div>
-	  <div class="tab-pane" id="dash_best_sellers">
-		<h3>
-		  {l s='Top %d products' sprintf=$DASHPRODUCT_NBR_SHOW_BEST_SELLER|intval d='Modules.Dashproducts.Admin'}
-		  <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
-		</h3>
-		<div class="table-responsive">
-		  <table class="table data_table" id="table_best_sellers">
-			<thead></thead>
-			<tbody></tbody>
-		  </table>
-		</div>
-	  </div>
-	  <div class="tab-pane" id="dash_most_viewed">
-		<h3>
-		  {l s="Most Viewed" d='Modules.Dashproducts.Admin'}
-		  <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
-		</h3>
-		<div class="table-responsive">
-		  <table class="table data_table" id="table_most_viewed">
-			<thead></thead>
-			<tbody></tbody>
-		  </table>
-		</div>
-	  </div>
-	  <div class="tab-pane" id="dash_top_search">
-		<h3>
-		  {l s='Top %d most search terms' sprintf=$DASHPRODUCT_NBR_SHOW_TOP_SEARCH|intval d='Modules.Dashproducts.Admin'}
-		  <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
-		</h3>
-		<div class="table-responsive">
-		  <table class="table data_table" id="table_top_10_most_search">
-			<thead></thead>
-			<tbody></tbody>
-		  </table>
-		</div>
-	  </div>
-	</div>
+    <div class="tab-content panel">
+      <div class="tab-pane active" id="dash_recent_orders">
+        <h3>{l s='Last %d orders' sprintf=$DASHPRODUCT_NBR_SHOW_LAST_ORDER|intval d='Modules.Dashproducts.Admin'}</h3>
+        <div class="table-responsive">
+          <table class="table data_table" id="table_recent_orders">
+            <thead></thead>
+            <tbody></tbody>
+          </table>
+        </div>
+      </div>
+      <div class="tab-pane" id="dash_best_sellers">
+        <h3>
+          {l s='Top %d products' sprintf=$DASHPRODUCT_NBR_SHOW_BEST_SELLER|intval d='Modules.Dashproducts.Admin'}
+          <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
+        </h3>
+        <div class="table-responsive">
+          <table class="table data_table" id="table_best_sellers">
+            <thead></thead>
+            <tbody></tbody>
+          </table>
+        </div>
+      </div>
+      <div class="tab-pane" id="dash_most_viewed">
+        <h3>
+          {l s="Most Viewed" d='Modules.Dashproducts.Admin'}
+          <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
+        </h3>
+        <div class="table-responsive">
+          <table class="table data_table" id="table_most_viewed">
+            <thead></thead>
+            <tbody></tbody>
+          </table>
+        </div>
+      </div>
+      <div class="tab-pane" id="dash_top_search">
+        <h3>
+          {l s='Top %d most search terms' sprintf=$DASHPRODUCT_NBR_SHOW_TOP_SEARCH|intval d='Modules.Dashproducts.Admin'}
+          <span>{l s="From" d='Modules.Dashproducts.Admin'} {$date_from|escape:'htmlall':'UTF-8'} {l s="to" d='Modules.Dashproducts.Admin'} {$date_to|escape:'htmlall':'UTF-8'}</span>
+        </h3>
+        <div class="table-responsive">
+          <table class="table data_table" id="table_top_10_most_search">
+            <thead></thead>
+            <tbody></tbody>
+          </table>
+        </div>
+      </div>
+    </div>
 
   </section>
 </section>

From 02a081c32aadbf026a225837ccfc1eb25e026c78 Mon Sep 17 00:00:00 2001
From: Pierre RAMBAUD <pierre.rambaud86@gmail.com>
Date: Tue, 2 Jun 2020 12:28:55 +0200
Subject: [PATCH 3/3] Typo

---
 dashproducts.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dashproducts.php b/dashproducts.php
index 085de9e..36dd426 100755
--- a/dashproducts.php
+++ b/dashproducts.php
@@ -628,7 +628,7 @@ public function hookActionSearch($params)
     public function validateDashConfig(array $config)
     {
         $errors = [];
-        $possibleValues = [5, 10 , 20, 50];
+        $possibleValues = [5, 10, 20, 50];
         foreach (array_keys($this->getConfigFieldsValues()) as $fieldName) {
             if (!isset($config[$fieldName]) || !in_array($config[$fieldName], $possibleValues)) {
                 $errors[$fieldName] = $this->trans('The %s field is invalid.', [$fieldName], 'Modules.Dashproducts.Admin');", "url": "https://github.com/PrestaShop/dashproducts/commit/f0799c13628a9b9ca6ca75c085b083d924a8ea7e.patch" } ]
CWE-284: Improper Access Control
CVE-2022-21644
SQL Injection via search in USOC
USOC is an open source CMS with a focus on simplicity. In affected versions USOC allows for SQL injection via usersearch.php. In search terms provided by the user were not sanitized and were used directly to construct a sql statement. The only users permitted to search are site admins. Users are advised to upgrade as soon as possible. There are not workarounds for this issue.
[ { "commit_message": "[PATCH] Update usersearch.php admin/pages/usersearch.php | 195 +++++++++++++++++++++---------------- 1 file changed, 112 insertions(+), 83 deletions(-)", "patch_text_b64": "From 06217c66c8f9b114726b21633eabcd88ac9034aa Mon Sep 17 00:00:00 2001
From: Aaron Junker <vl5ktlnki@relay.firefox.com>
Date: Mon, 3 Jan 2022 17:02:38 +0100
Subject: [PATCH] Update usersearch.php

---
 admin/pages/usersearch.php | 195 +++++++++++++++++++++----------------
 1 file changed, 112 insertions(+), 83 deletions(-)

diff --git a/admin/pages/usersearch.php b/admin/pages/usersearch.php
index ca20cec77..0fb22a928 100644
--- a/admin/pages/usersearch.php
+++ b/admin/pages/usersearch.php
@@ -1,89 +1,118 @@
-<!DOCTYPE html>
-<html lang="<?php echo $U->getSetting("site.lang"); ?>" dir="ltr">
-    <head>
-        <style>
-            tbody > tr > th {
-                font-weight: normal;
-            }
-        </style>
-        <meta charset="utf-8">
-        <title><?php echo $U->getLang("admin") ?> - <?php echo $U->getLang("admin.user.search"); ?></title>
-    </head>
-    <body>
-        <a href="javascript:window.close()"><?php echo $U->getLang("admin.exit"); ?></a>
-        <p><?php echo $U->getLang("admin.user.search.intro"); ?></p>
-        <form>
-            <label for="Name"><?php echo $U->getLang("admin.user.field.username"); ?>:</label><br />
-            <input type="text" name="Name" /><br />
-            <label for="Mail"><?php echo $U->getLang("admin.user.field.mail"); ?>:</label><br />
-            <input type="mail" name="Mail" /><br />
-            <input type="hidden" name="URL" value="usersearch" />
-            <input type="submit" value="<?php echo $U->getLang("admin.user.search.action"); ?>" />
-        </form>
-        <?php
-            if(isset($_GET["Name"])){
-                if($_GET["Name"] !== ""){
-                    $sql = "SELECT * FROM User WHERE Username='".$_GET["Name"]."';";
-                    $db_erg = mysqli_query($U->db_link, $sql);
+<?php
+    if($U->userHasPermission("Backend", "User","Search")){
+?>
+    <!DOCTYPE html>
+    <html lang="<?php echo $U->getSetting("site.lang"); ?>" dir="ltr">
+        <head>
+            <style>
+                tbody > tr > th {
+                    font-weight: normal;
                 }
-            }
-            if(isset($_GET["Mail"])){
-                if($_GET["Mail"] !== ""){
-                    $sql = "SELECT * FROM User WHERE Mail='".$_GET["Mail"]."';";
-                    $db_erg = mysqli_query($U->db_link, $sql);
+            </style>
+            <meta charset="utf-8">
+            <title><?php echo $U->getLang("admin") ?> - <?php echo $U->getLang("admin.user.search"); ?></title>
+        </head>
+        <body>
+            <a href="javascript:window.close()"><?php echo $U->getLang("admin.exit"); ?></a>
+            <p><?php echo $U->getLang("admin.user.search.intro"); ?></p>
+            <form>
+                <label for="Name"><?php echo $U->getLang("admin.user.field.username"); ?>:</label><br />
+                <input type="text" name="Name" /><br />
+                <label for="Mail"><?php echo $U->getLang("admin.user.field.mail"); ?>:</label><br />
+                <input type="mail" name="Mail" /><br />
+                <input type="hidden" name="URL" value="usersearch" />
+                <input type="submit" value="<?php echo $U->getLang("admin.user.search.action"); ?>" />
+            </form>
+            <?php
+                if(isset($_GET["Name"])){
+                    if($_GET["Name"] !== ""){
+                        $sql = "SELECT * FROM User WHERE Username='".mysqli::real_escape_string($_GET["Name"])."';";
+                        $dbRes = mysqli_query($U->db_link, $sql);
+                    }
                 }
-            }
-            if(isset($_GET["Mail"]) || isset($_GET["Name"])){
-                $userhere = False;
-                while($row = mysqli_fetch_array($db_erg, MYSQLI_ASSOC)){
-                    $userhere = True;
-        ?>
-                    <h4><?php echo str_replace("%a",$row["Username"],$U->getLang("admin.user.search.title")); ?></h4>
-                    <table>
-                        <tbody>
-                            <tr>
-                                <th>
-                                    Id:
-                                </th>
-                                <th>
-                                    <?php echo $row["Id"]; ?>
-                                </th>
-                            </tr>
-                            <tr>
-                                <th>
-                                    <?php echo $U->getLang("admin.user.field.mail"); ?>:
-                                </th>
-                                <th>
-                                    <?php echo $row["Mail"]; ?>
-                                </th>
-                            </tr>
-                            <tr>
-                                <th>
-                                    <?php echo $U->getLang("admin.user.field.admin"); ?>
-                                </th>
-                                <th>
-                                    <?php echo $row["Type"]; ?>
-                                </th>
-                            </tr>
-                            <tr>
-                                <th>
-                                    <?php echo $U->getLang("admin.user.field.blocked"); ?>
-                                </th>
-                                <th>
-                                    <?php echo $row["blocked"]; ?>
-                                </th>
-                            </tr>
-                        </tbody>
-                    </table>
-        <?php
+                if(isset($_GET["Mail"])){
+                    if($_GET["Mail"] !== ""){
+                        $sql = "SELECT * FROM User WHERE Mail='".mysqli::real_escape_string($_GET["Mail"])."';";
+                        $dbRes = mysqli_query($U->db_link, $sql);
+                    }
                 }
-                if(!$userhere&&$_GET["Mail"] !== ""){
-                    echo str_replace("%a", $U->getLang("admin.user.field.mail"), str_replace("%b", $_GET["Mail"], $U->getLang("admin.user.notFound.property")));
+                if(isset($_GET["Id"])){
+                    if($_GET["Id"] !== ""){
+                        $sql = "SELECT * FROM User WHERE Id='".mysqli::real_escape_string($_GET["Id"])."';";
+                        $dbRes = mysqli_query($U->db_link, $sql);
+                    }
                 }
-                if(!$userhere&&$_GET["Name"] !== ""){
-                    echo str_replace("%a", $U->getLang("admin.user.field.username"), str_replace("%b", $_GET["Name"], $U->getLang("admin.user.notFound.property")));
+                if(isset($_GET["Mail"]) || isset($_GET["Name"]) || isset($_GET["Id"])){
+                    $userhere = False;
+                    while($row = mysqli_fetch_array($dbRes, MYSQLI_ASSOC)){
+                        $userhere = True;
+            ?>
+                        <h4><?php echo str_replace("%a",$row["Username"],$U->getLang("admin.user.search.title")); ?></h4>
+                        <table>
+                            <tbody>
+                                <tr>
+                                    <th>
+                                        Id:
+                                    </th>
+                                    <th>
+                                        <?php echo $row["Id"]; ?>
+                                    </th>
+                                </tr>
+                                <tr>
+                                    <th>
+                                        <?php echo $U->getLang("admin.user.field.mail"); ?>:
+                                    </th>
+                                    <th>
+                                        <?php echo $row["Mail"]; ?>
+                                    </th>
+                                </tr>
+                                <tr>
+                                    <th>
+                                        <?php echo $U->getLang("admin.user.field.permissionlevel"); ?>
+                                    </th>
+                                    <th>
+                                        <?php echo $U->getPermissionName($row["Type"]); ?>
+                                    </th>
+                                </tr>
+                                <tr>
+                                    <th>
+                                        <?php echo $U->getLang("admin.user.field.blocked"); ?>
+                                    </th>
+                                    <th>
+                                        <?php echo $row["blocked"]==0?$U->getLang("admin.no"):$U->getLang("admin.yes"); ?>
+                                    </th>
+                                </tr>
+                            </tbody>
+                        </table>
+            <?php
+                    }
+                    if(!$userhere&&isset($_GET["Mail"])&&$_GET["Mail"]!==""){
+                        echo str_replace("%a", $U->getLang("admin.user.field.mail"), str_replace("%b", $_GET["Mail"], $U->getLang("admin.user.notFound.property")));
+                    }
+                    if(!$userhere&&isset($_GET["Name"])&&$_GET["Name"]!==""){
+                        echo str_replace("%a", $U->getLang("admin.user.field.username"), str_replace("%b", $_GET["Name"], $U->getLang("admin.user.notFound.property")));
+                    }
+                    if(!$userhere&&isset($_GET["Id"])){
+                        echo str_replace("%a", $U->getLang("admin.user.field.id"), str_replace("%b", $_GET["Id"], $U->getLang("admin.user.notFound.property")));
+                    }
                 }
-            }
-        ?>
+            ?>
+        </body>
+    </html>
+<?php
+  }else{
+?>
+  <!DOCTYPE html>
+  <html lang="<?php echo $U->getSetting("site.lang"); ?>" dir="ltr">
+    <head>
+      <meta charset="utf-8">
+      <title><?php echo $U->getLang("admin") ?> - <?php echo $U->getLang("admin.settings"); ?></title>
+    </head>
+    <body>
+        <a href="javascript:window.close()"><?php echo $U->getLang("admin.exit"); ?></a>
+      <p><?php echo $U->getLang("rights.error"); ?></p>
     </body>
-</html>
\ No newline at end of file
+  </html>
+<?php
+  }
+?>", "url": "https://github.com/Aaron-Junker/USOC/commit/06217c66c8f9b114726b21633eabcd88ac9034aa.patch" } ]
CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
GHSA-8xv4-c7rq-j577
ChakraCore Remote Code Execution Vulnerability
null
[ { "commit_message": "[PATCH] [CVE-2020-1037] Ensure JIT bails out when there is an object marked as temporary during an implicit call, to prevent objects stored on the stack to be used outside of the function. This is done by preventing removal of the Bailout instruction for that case during the DeadStore pass of GlobOpt. lib/Backend/GlobOptBailOut.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA3M2NlZDAyOWU2YTA2ZmNjZTlmZDhjODg2ZGM3M2U1MjkwZjJhZTY5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBdHVsIEthdHRpIDxha2F0dGlAbWljcm9zb2Z0LmNvbT4KRGF0ZTogVGh1LCA5IEFwciAyMDIwIDE5OjI1OjQ4IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gW0NWRS0yMDIwLTEwMzddIEVuc3VyZSBKSVQgYmFpbHMgb3V0IHdoZW4gdGhlcmUgaXMgYW4gb2JqZWN0CiBtYXJrZWQgYXMgdGVtcG9yYXJ5IGR1cmluZyBhbiBpbXBsaWNpdCBjYWxsLCB0byBwcmV2ZW50IG9iamVjdHMgc3RvcmVkIG9uIHRoZQogc3RhY2sgdG8gYmUgdXNlZCBvdXRzaWRlIG9mIHRoZSBmdW5jdGlvbi4gVGhpcyBpcyBkb25lIGJ5IHByZXZlbnRpbmcgcmVtb3ZhbAogb2YgdGhlIEJhaWxvdXQgaW5zdHJ1Y3Rpb24gZm9yIHRoYXQgY2FzZSBkdXJpbmcgdGhlIERlYWRTdG9yZSBwYXNzIG9mCiBHbG9iT3B0LgoKLS0tCiBsaWIvQmFja2VuZC9HbG9iT3B0QmFpbE91dC5jcHAgfCAzICsrLQogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2xpYi9CYWNrZW5kL0dsb2JPcHRCYWlsT3V0LmNwcCBiL2xpYi9CYWNrZW5kL0dsb2JPcHRCYWlsT3V0LmNwcAppbmRleCBmMTY4NTQ1YjNiMi4uMjFiMGM3NzUzYjYgMTAwNjQ0Ci0tLSBhL2xpYi9CYWNrZW5kL0dsb2JPcHRCYWlsT3V0LmNwcAorKysgYi9saWIvQmFja2VuZC9HbG9iT3B0QmFpbE91dC5jcHAKQEAgLTEyMDQsNyArMTIwNCw4IEBAIEdsb2JPcHQ6OklzSW1wbGljaXRDYWxsQmFpbE91dEN1cnJlbnRseU5lZWRlZChJUjo6SW5zdHIgKiBpbnN0ciwgVmFsdWUgY29uc3QgKiBzCiAgICAgICAgICAgICBOZWVkQmFpbE9uSW1wbGljaXRDYWxsRm9yTGl2ZVZhbHVlcyhibG9jaywgaXNGb3J3YXJkUGFzcykgfHwKICAgICAgICAgICAgIE5lZWRCYWlsT25JbXBsaWNpdENhbGxGb3JDU0UoYmxvY2ssIGlzRm9yd2FyZFBhc3MpIHx8CiAgICAgICAgICAgICBOZWVkQmFpbE9uSW1wbGljaXRDYWxsV2l0aEZpZWxkT3B0cyhibG9jay0+bG9vcCwgaGFzTGl2ZUZpZWxkcykgfHwKLSAgICAgICAgICAgIE5lZWRCYWlsT25JbXBsaWNpdENhbGxGb3JBcnJheUNoZWNrSG9pc3QoYmxvY2ssIGlzRm9yd2FyZFBhc3MpCisgICAgICAgICAgICBOZWVkQmFpbE9uSW1wbGljaXRDYWxsRm9yQXJyYXlDaGVja0hvaXN0KGJsb2NrLCBpc0ZvcndhcmRQYXNzKSB8fCAKKyAgICAgICAgICAgIChpbnN0ci0+SGFzQmFpbE91dEluZm8oKSAmJiAoaW5zdHItPkdldEJhaWxPdXRLaW5kKCkgJiBJUjo6QmFpbE91dE1hcmtUZW1wT2JqZWN0KSAhPSAwKQogICAgICAgICApICYmCiAgICAgICAgICghaW5zdHItPkhhc1R5cGVDaGVja0JhaWxPdXQoKSAmJiBNYXlOZWVkQmFpbE9uSW1wbGljaXRDYWxsKGluc3RyLCBzcmMxVmFsLCBzcmMyVmFsKSkpCiAgICAgew==", "url": "https://github.com/chakra-core/ChakraCore/commit/73ced029e6a06fcce9fd8c886dc73e5290f2ae69.patch" } ]
null
CVE-2025-32387
Helm Allows A Specially Crafted JSON Schema To Cause A Stack Overflow
Helm is a package manager for Charts for Kubernetes. A JSON Schema file within a chart can be crafted with a deeply nested chain of references, leading to parser recursion that can exceed the stack size limit and trigger a stack overflow. This issue has been resolved in Helm v3.17.3.
[ { "commit_message": "[PATCH] Unarchiving fix Signed-off-by: Matt Farina <matt@mattfarina.com> pkg/chart/v2/loader/archive.go | 32 +++++++++++++++++++++++++++++++- pkg/chart/v2/loader/directory.go | 4 ++++ 2 files changed, 35 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/helm/helm/commit/d8ca55fc669645c10c0681d49723f4bb8c0b1ce7.patch" } ]
CWE-121: Stack-based Buffer Overflow
CVE-2019-13343
Butor Portal before 1.0.27 is affected by a Path Traversal vulnerability leading to a pre-authentication arbitrary file download. Effectively, a remote anonymous user can download any file on servers running Butor Portal. WhiteLabelingServlet is responsible for this vulnerability. It does not properly sanitize user input on the theme t parameter before reusing it in a path. This path is then used without validation to fetch a file and return its raw content to the user via the /wl?t=../../...&h= substring followed by a filename.
[ { "commit_message": "[PATCH] better check for theme exists! .../portal/web/servlet/WhiteLabelingServlet.java | 13 +++++++++++++ 1 file changed, 13 insertions(+)", "patch_text_b64": "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", "url": "https://bitbucket.org/butor-team/portal/commits/cd7055d33e194fcf530100ee1d8d13aa9cde230b" }, { "commit_message": "<!DOCTYPE html> <html lang=\"en\"> <head> <title>Bitbucket</title> <meta id=\"bb-bootstrap\" data-current-user=\"{&quot;isAuthenticated&quot;: false, &quot;isKbdShortcutsEnabled&quot;: true, &quot;isSshEnabled&quot;: false}\" data-target-workspace-uuid=\"80a8b480-d460-4fc2-9eb7-cded0cb53ef2\" /> <meta name=\"frontbucket-version\" content=\"a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a\"> <meta name=\"frontbucket-environment\" content=\"bifrost_production\"> <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\"> <meta charset=\"utf-8\"> <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"> <meta name=\"bb-env\" content=\"production\" /> <meta id=\"bb-canon-url\" name=\"bb-canon-url\" content=\"https://bitbucket.org\"> <meta name=\"bb-api-canon-url\" content=\"https://api.bitbucket.org\"> <meta name=\"bitbucket-commit-hash\" content=\"481cfd7abfe8\"> <meta name=\"bb-app-node\" content=\"cee8bcc9c94e\"> <meta name=\"bb-dce-env\" content=\"micros\"> <meta name=\"bb-view-name\" content=\"bitbucket.apps.repo2.views.CommitList\"> <meta name=\"ignore-whitespace\" content=\"False\"> <meta name=\"tab-size\" content=\"None\"> <meta name=\"locale\" content=\"en\"> <meta name=\"application-name\" content=\"Bitbucket\"> <meta name=\"apple-mobile-web-app-title\" content=\"Bitbucket\"> <meta name=\"slack-app-id\" content=\"A8W8QLZD1\"> <meta name=\"statuspage-api-host\" content=\"https://bqlf8qjztdtr.statuspage.io\"> <meta name=\"theme-color\" content=\"#0049B0\"> <meta name=\"msapplication-TileColor\" content=\"#0052CC\"> <meta name=\"msapplication-TileImage\" content=\"https://bbc-object-storage--frontbucket.us-east-1.prod.public.atl-paas.net/481cfd7abfe8/img/logos/bitbucket/mstile-150x150.png\"> <link rel=\"apple-touch-icon\" sizes=\"180x180\" type=\"image/png\" href=\"https://bbc-object-storage--frontbucket.us-east-1.prod.public.atl-paas.net/481cfd7abfe8/img/logos/bitbucket/apple-touch-icon.png\"> <link rel=\"icon\" sizes=\"192x192\" type=\"image/png\" href=\"https://bbc-object-storage--frontbucket.us-east-1.prod.public.atl-paas.net/481cfd7abfe8/img/logos/bitbucket/android-chrome-192x192.png\"> <link rel=\"icon\" sizes=\"16x16 24x24 32x32 64x64\" type=\"image/x-icon\" href=\"/favicon.ico?v=2\"> <link rel=\"mask-icon\" href=\"https://bbc-object-storage--frontbucket.us-east-1.prod.public.atl-paas.net/481cfd7abfe8/img/logos/bitbucket/safari-pinned-tab.svg\" color=\"#0052CC\"> <link rel=\"search\" type=\"application/opensearchdescription+xml\" href=\"/opensearch.xml\" title=\"Bitbucket\"> <meta name=\"description\" content=\"\"> <meta name=\"bb-single-page-app\" content=\"true\"> <link rel=\"stylesheet\" href=\"https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net/assets/vendor.a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a.css\"> <link rel=\"stylesheet\" href=\"https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net/assets/all.compiled.a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a.css\"> <link rel=\"preconnect\" href=\"https://ds-cdn.prod-east.frontend.public.atl-paas.net\" /> <link rel=\"preload\" href=\"https://ds-cdn.prod-east.frontend.public.atl-paas.net/assets/fonts/atlassian-sans/v3/AtlassianSans-latin.woff2\" as=\"font\" type=\"font/woff2\" crossorigin /> <link rel=\"preload stylesheet\" href=\"https://ds-cdn.prod-east.frontend.public.atl-paas.net/assets/font-rules/v5/atlassian-fonts.css\" as=\"style\" crossorigin /> <script nonce=\"l+zN+5M44fbtuD5atwVMJw==\"> if (window.performance) { window.performance.okayToSendMetrics = !document.hidden && 'onvisibilitychange' in document; if (window.performance.okayToSendMetrics) { window.addEventListener('visibilitychange', function () { if (document.hidden) { window.performance.okayToSendMetrics = false; } }); } } </script> </head> <body> <div id=\"root\"> <script nonce=\"l+zN+5M44fbtuD5atwVMJw==\"> window.__webpack_public_path__ = \"https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net\"; </script> </div> <link rel=\"preconnect\" href=\"https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net\" /> <script nonce=\"l+zN+5M44fbtuD5atwVMJw==\"> window.__sentry__ = {\"dsn\": \"https://2dcda83904474d8c86928ebbfa1ab294@o55978.ingest.sentry.io/1480772\", \"environment\": \"bifrost_production\", \"tags\": {\"dc_location\": \"Micros-3\", \"micros_deployment_id\": \"r3c6ja1f9hj42o3t\", \"micros_service\": \"bbc-website\", \"micros_envtype\": \"prod\", \"micros_service_version\": \"171991\", \"micros_instance_id\": \"i-0fea6180bb0ca5a6f\", \"micros_zone\": \"us-east-1.prod.atl-paas.net\", \"revision\": \"481cfd7abfe8\"}}; window.__app_data__ = {\"navigationIsOpen\": true, \"tenantId\": \"80a8b480-d460-4fc2-9eb7-cded0cb53ef2\", \"features\": {\"bbc_nav_v4\": false, \"spa-account-settings--settings-index\": true, \"platform-team25-app-icon-tiles\": true, \"bbc-skip-old-feature-client\": true, \"autoreview_repository_settings_page\": true, \"bbc-forge-fct-allow-file-context\": true, \"bbc-forge-fct-allow-workspace-global-extension\": true, \"bbc-forge-fct-allow-workspace-personal-settings\": true}, \"links\": {\"backButtonUrl\": null, \"overviewUrl\": \"/butor-team/workspace/overview/\"}, \"initialContext\": {\"workspace\": {\"type\": \"workspace\", \"uuid\": \"{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}\", \"name\": \"butor team\", \"slug\": \"butor-team\", \"is_private\": false, \"is_privacy_enforced\": false, \"links\": {\"avatar\": {\"href\": \"https://bitbucket.org/workspaces/butor-team/avatar/?ts=1543619326\"}, \"html\": {\"href\": \"https://bitbucket.org/butor-team/\"}, \"self\": {\"href\": \"https://bitbucket.org/!api/2.0/workspaces/butor-team\"}}, \"created_on\": \"2018-11-30T23:08:46.313426+00:00\", \"forking_mode\": \"allow_forks\"}, \"repository\": {\"type\": \"repository\", \"full_name\": \"butor-team/portal\", \"links\": {\"self\": {\"href\": \"https://bitbucket.org/!api/2.0/repositories/butor-team/portal\"}, \"html\": {\"href\": \"https://bitbucket.org/butor-team/portal\"}, \"avatar\": {\"href\": \"https://bytebucket.org/ravatar/%7B664c1c57-5eae-4cc0-b590-24ee5f1ca13a%7D?ts=default\"}}, \"name\": \"portal\", \"slug\": \"portal\", \"is_private\": false, \"uuid\": \"{664c1c57-5eae-4cc0-b590-24ee5f1ca13a}\"}, \"project\": {\"type\": \"project\", \"key\": \"PROJ\", \"uuid\": \"{8518d6a7-0853-46ec-a758-2b50de45f27f}\", \"is_private\": false, \"name\": \"butor stack\", \"description\": \"Project created by Bitbucket for butor public team\", \"links\": {\"self\": {\"href\": \"https://bitbucket.org/!api/2.0/workspaces/butor-team/projects/PROJ\"}, \"html\": {\"href\": \"https://bitbucket.org/butor-team/workspace/projects/PROJ\"}, \"avatar\": {\"href\": \"https://bitbucket.org/butor-team/workspace/projects/PROJ/avatar/32?ts=1487779604\"}}, \"created_on\": \"2015-12-04T00:39:35.206191+00:00\", \"updated_on\": \"2017-02-22T16:06:44.742871+00:00\", \"has_publicly_visible_repos\": true}}, \"frontbucket_version\": \"a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a\", \"frontbucket_environment\": \"bifrost_production\"}; window.__initial_state__ = {\"global\": {\"geoip_country\": null, \"is_mobile_user_agent\": false, \"site_message\": \"\", \"needs_marketing_consent\": false, \"marketing_consent_locale\": null, \"whats_new_feed\": \"https://atlassianblog.wpengine.com/wp-json/wp/v2/posts?tags=11972&context=embed&per_page=6&orderby=date&order=desc\", \"locale\": \"en\", \"path\": \"/butor-team/portal/commits/all\", \"isFocusedTask\": false, \"focusedTaskBackButtonUrl\": null, \"features\": {\"lookup-pr-approvers-from-prs\": true, \"log-asap-errors\": true, \"provisioning-install-pipelines-addon\": true, \"fd-prs-client-cache-fallback\": true, \"block-non-pipelines-custom-events-webhooks\": true, \"read-only-message-migrations\": true, \"provisioning-skip-workspace-creation\": true, \"uninstall-dvcs-addon-only-when-jira-is-removed\": true, \"auth-flow-adg3\": true, \"workspace-member-set-last-accessed\": true, \"use-elasticache-lsn-storage\": true, \"whitelisted_throttle_exemption\": true, \"bbc-pride-logo\": false, \"create-workspace-show-recaptcha\": true, \"spa-account-settings--settings-index\": true, \"platform-team25-app-icon-tiles\": true, \"lazy-diffstat\": false, \"bbc-rovo-data-onboarding-ux\": true, \"pipelines-test-management\": false, \"bbc-merge-queue-enabled\": false, \"bbc-forge-fct-allow-file-context\": true, \"bbc-forge-fct-allow-workspace-global-extension\": true, \"bbc-forge-fct-allow-workspace-personal-settings\": true, \"scope-dismiss-cross-sell-admin-promo-issues\": true, \"scope-dismiss-jira-box\": false, \"bbc_nav_v4\": false, \"use-new-connect-modules-endpoint\": true, \"workspace-ai-enabled\": false, \"workspace-settings-ai-editor-features-enabled\": false, \"workspace-settings-ai-rovo-chat-enabled\": false, \"pr-code-push-webhook\": false, \"custom-merge-checks-activated\": false, \"pr-review-groups\": false}, \"isNavigationOpen\": true, \"flags\": [], \"horizontalNavigationItems\": {\"mainItems\": [{\"id\": \"pullrequests-tab\", \"label\": \"Pull requests\", \"tab_name\": \"pullrequests\", \"anchor\": true, \"weight\": 140, \"is_premium\": null, \"is_beta\": null, \"is_new\": null, \"url\": \"/butor-team/workspace/pull-requests/\", \"target\": \"_self\", \"icon_class\": \"\", \"badge_label\": null, \"matching_url_prefixes\": [], \"analytics_label\": \"pullrequests\", \"analytics_payload\": {}, \"is_client_link\": true, \"is_external_link\": false, \"is_dropdown_item\": false, \"test_id\": null, \"children\": [], \"type\": \"menu_item\", \"icon\": \"\"}, {\"id\": \"repositories-tab\", \"label\": \"Repositories\", \"tab_name\": \"repositories\", \"anchor\": true, \"weight\": 160, \"is_premium\": null, \"is_beta\": null, \"is_new\": null, \"url\": \"/butor-team/workspace/repositories/\", \"target\": \"_self\", \"icon_class\": \"\", \"badge_label\": null, \"matching_url_prefixes\": [], \"analytics_label\": \"repositories\", \"analytics_payload\": {}, \"is_client_link\": true, \"is_external_link\": false, \"is_dropdown_item\": true, \"test_id\": null, \"children\": [], \"type\": \"menu_item\", \"icon\": \"\"}, {\"id\": \"projects-tab\", \"label\": \"Projects\", \"tab_name\": \"projects\", \"anchor\": true, \"weight\": 200, \"is_premium\": null, \"is_beta\": null, \"is_new\": null, \"url\": \"/butor-team/workspace/projects/\", \"target\": \"_self\", \"icon_class\": \"\", \"badge_label\": null, \"matching_url_prefixes\": [], \"analytics_label\": \"projects\", \"analytics_payload\": {}, \"is_client_link\": true, \"is_external_link\": false, \"is_dropdown_item\": true, \"test_id\": null, \"children\": [], \"type\": \"menu_item\", \"icon\": \"\"}], \"secondaryItems\": [], \"settingsItems\": []}, \"targetUser\": {\"display_name\": \"butor team\", \"links\": {\"self\": {\"href\": \"https://bitbucket.org/!api/2.0/workspaces/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D\"}, \"avatar\": {\"href\": \"https://bitbucket.org/account/butor-team/avatar/\"}, \"html\": {\"href\": \"https://bitbucket.org/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D/\"}}, \"created_on\": \"2014-06-02T02:59:56.187081+00:00\", \"is_active\": true, \"type\": \"team\", \"uuid\": \"{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}\", \"has_2fa_enabled\": null, \"properties\": {}, \"username\": \"butor-team\"}, \"targetFeatures\": {\"lookup-pr-approvers-from-prs\": true, \"log-asap-errors\": true, \"provisioning-install-pipelines-addon\": true, \"fd-prs-client-cache-fallback\": true, \"block-non-pipelines-custom-events-webhooks\": true, \"view-source-filtering-upon-timeout\": true, \"read-only-message-migrations\": true, \"provisioning-skip-workspace-creation\": true, \"fd-repository-page-loading-error-guard\": true, \"uninstall-dvcs-addon-only-when-jira-is-removed\": true, \"auth-flow-adg3\": true, \"workspace-member-set-last-accessed\": true, \"use-elasticache-lsn-storage\": true, \"whitelisted_throttle_exemption\": true, \"atlassian-editor\": true}}, \"section\": {\"repository\": {\"cloneProtocol\": \"https\", \"currentRepository\": {\"type\": \"repository\", \"full_name\": \"butor-team/portal\", \"links\": {\"self\": {\"href\": \"https://bitbucket.org/!api/2.0/repositories/butor-team/portal\"}, \"html\": {\"href\": \"https://bitbucket.org/butor-team/portal\"}, \"avatar\": {\"href\": \"https://bytebucket.org/ravatar/%7B664c1c57-5eae-4cc0-b590-24ee5f1ca13a%7D?ts=default\"}, \"clone\": [{\"name\": \"https\", \"href\": \"https://bitbucket.org/butor-team/portal.git\"}, {\"name\": \"ssh\", \"href\": \"git@bitbucket.org:butor-team/portal.git\"}]}, \"name\": \"portal\", \"slug\": \"portal\", \"description\": \"\", \"scm\": \"git\", \"website\": \"\", \"owner\": {\"display_name\": \"butor team\", \"links\": {\"self\": {\"href\": \"https://bitbucket.org/!api/2.0/workspaces/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D\"}, \"avatar\": {\"href\": \"https://bitbucket.org/account/butor-team/avatar/\"}, \"html\": {\"href\": \"https://bitbucket.org/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D/\"}}, \"type\": \"team\", \"uuid\": \"{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}\", \"username\": \"butor-team\"}, \"workspace\": {\"type\": \"workspace\", \"uuid\": \"{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}\", \"name\": \"butor team\", \"slug\": \"butor-team\", \"is_private\": false, \"is_privacy_enforced\": false, \"links\": {\"avatar\": {\"href\": \"https://bitbucket.org/workspaces/butor-team/avatar/?ts=1543619326\"}, \"html\": {\"href\": \"https://bitbucket.org/butor-team/\"}, \"self\": {\"href\": \"https://bitbucket.org/!api/2.0/workspaces/butor-team\"}}, \"created_on\": \"2018-11-30T23:08:46.313426+00:00\", \"forking_mode\": \"allow_forks\"}, \"is_private\": false, \"project\": {\"type\": \"project\", \"owner\": {\"display_name\": \"butor team\", \"links\": {\"self\": {\"href\": \"https://bitbucket.org/!api/2.0/workspaces/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D\"}, \"avatar\": {\"href\": \"https://bitbucket.org/account/butor-team/avatar/\"}, \"html\": {\"href\": \"https://bitbucket.org/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D/\"}}, \"type\": \"team\", \"uuid\": \"{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}\", \"username\": \"butor-team\"}, \"workspace\": {\"type\": \"workspace\", \"uuid\": \"{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}\", \"name\": \"butor team\", \"slug\": \"butor-team\", \"links\": {\"avatar\": {\"href\": \"https://bitbucket.org/workspaces/butor-team/avatar/?ts=1543619326\"}, \"html\": {\"href\": \"https://bitbucket.org/butor-team/\"}, \"self\": {\"href\": \"https://bitbucket.org/!api/2.0/workspaces/butor-team\"}}}, \"key\": \"PROJ\", \"uuid\": \"{8518d6a7-0853-46ec-a758-2b50de45f27f}\", \"is_private\": false, \"name\": \"butor stack\", \"description\": \"Project created by Bitbucket for butor public team\", \"links\": {\"self\": {\"href\": \"https://bitbucket.org/!api/2.0/workspaces/butor-team/projects/PROJ\"}, \"html\": {\"href\": \"https://bitbucket.org/butor-team/workspace/projects/PROJ\"}, \"avatar\": {\"href\": \"https://bitbucket.org/butor-team/workspace/projects/PROJ/avatar/32?ts=1487779604\"}}, \"created_on\": \"2015-12-04T00:39:35.206191+00:00\", \"updated_on\": \"2017-02-22T16:06:44.742871+00:00\", \"has_publicly_visible_repos\": true}, \"fork_policy\": \"allow_forks\", \"updated_on\": \"2019-07-05T12:31:35.636202+00:00\", \"language\": \"\", \"uuid\": \"{664c1c57-5eae-4cc0-b590-24ee5f1ca13a}\", \"mainbranch\": {\"name\": \"master\"}, \"state\": \"available\", \"landing_page\": \"source\"}, \"mirrors\": [], \"sizeLimits\": {\"hard\": 4294967296, \"soft\": 2147483648.0, \"readOnly\": 10737418240.0}, \"override_settings\": {\"default_merge_strategy\": false, \"branching_model\": false}}}, \"commits-list\": {}}; window.__settings__ = {\"ADMINHUB_BASE_URL\": \"https://admin.atlassian.com\", \"API_CANON_URL\": \"https://api.bitbucket.org\", \"CANON_URL\": \"https://bitbucket.org\", \"LOGIN_URL\": \"/account/signin/\", \"SOCIAL_AUTH_ATLASSIANID_LOGIN_PROMPT_URL\": \"https://id.atlassian.com/login\", \"SOCIAL_AUTH_ATLASSIANID_LOGOUT_URL\": \"https://id.atlassian.com/logout\", \"SOCIAL_AUTH_ATLASSIANID_PROFILE_URL\": \"https://id.atlassian.com/manage-profile/\", \"ATLASSIANID_LOGIN_URL\": \"https://id.atlassian.com/login\", \"ATLASSIANID_LOGOUT_URL\": \"https://id.atlassian.com/logout\", \"ATLASSIANID_MANAGE_PROFILE_URL\": \"https://id.atlassian.com/manage-profile/\", \"MARKETPLACE_TERMS_OF_USE_URL\": null, \"CONSENT_HUB_FRONTEND_BASE_URL\": \"https://preferences.atlassian.com\", \"EMOJI_STANDARD_BASE_URL\": \"https://bitbucket.org/gateway/api/emoji/\", \"STATUSPAGE_URL\": \"https://bitbucket.status.atlassian.com/\", \"RECAPTCHA_PUBLIC_KEY\": \"6LcRaMMkAAAAAFB-7L-4-1-mdLIrOMAP4H5asuWK\", \"WAC_CREATE_WORKSPACE_URL\": \"https://www.atlassian.com/try/cloud/signup?bundle=bitbucket\", \"ATLASSIAN_PUBSUB_CONNECT_URL\": \"https://bitbucket.org/gateway/api/bbc-aps/subscriptions\", \"AGG_WEBSOCKET_SUBSCRIPTIONS_PATH\": \"/gateway/api/graphql/subscriptions\"}; window.__webpack_nonce__ = 'l+zN+5M44fbtuD5atwVMJw=='; window.isInitialLoadApdex = true; </script> <script nonce=\"l+zN+5M44fbtuD5atwVMJw==\" src=\"https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net/assets/ajs.a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a.js\"></script> <script nonce=\"l+zN+5M44fbtuD5atwVMJw==\" src=\"https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net/assets/app.a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a.js\"></script> </body> </html>", "patch_text_b64": "<!DOCTYPE html>
<html lang="en">
  <head>
    <title>Bitbucket</title>
    <meta id="bb-bootstrap" data-current-user="{&quot;isAuthenticated&quot;: false, &quot;isKbdShortcutsEnabled&quot;: true, &quot;isSshEnabled&quot;: false}"


    data-target-workspace-uuid="80a8b480-d460-4fc2-9eb7-cded0cb53ef2"
 />
    <meta name="frontbucket-version" content="a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a">
    <meta name="frontbucket-environment" content="bifrost_production">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    


<meta name="bb-env" content="production" />
<meta id="bb-canon-url" name="bb-canon-url" content="https://bitbucket.org">
<meta name="bb-api-canon-url" content="https://api.bitbucket.org">



<meta name="bitbucket-commit-hash" content="481cfd7abfe8">
<meta name="bb-app-node" content="cee8bcc9c94e">
<meta name="bb-dce-env" content="micros">
<meta name="bb-view-name" content="bitbucket.apps.repo2.views.CommitList">
<meta name="ignore-whitespace" content="False">
<meta name="tab-size" content="None">
<meta name="locale" content="en">
<meta name="application-name" content="Bitbucket">
<meta name="apple-mobile-web-app-title" content="Bitbucket">
<meta name="slack-app-id" content="A8W8QLZD1">
<meta name="statuspage-api-host" content="https://bqlf8qjztdtr.statuspage.io">


<meta name="theme-color" content="#0049B0">
<meta name="msapplication-TileColor" content="#0052CC">
<meta name="msapplication-TileImage" content="https://bbc-object-storage--frontbucket.us-east-1.prod.public.atl-paas.net/481cfd7abfe8/img/logos/bitbucket/mstile-150x150.png">
<link rel="apple-touch-icon" sizes="180x180" type="image/png" href="https://bbc-object-storage--frontbucket.us-east-1.prod.public.atl-paas.net/481cfd7abfe8/img/logos/bitbucket/apple-touch-icon.png">
<link rel="icon" sizes="192x192" type="image/png" href="https://bbc-object-storage--frontbucket.us-east-1.prod.public.atl-paas.net/481cfd7abfe8/img/logos/bitbucket/android-chrome-192x192.png">

<link rel="icon" sizes="16x16 24x24 32x32 64x64" type="image/x-icon" href="/favicon.ico?v=2">
<link rel="mask-icon" href="https://bbc-object-storage--frontbucket.us-east-1.prod.public.atl-paas.net/481cfd7abfe8/img/logos/bitbucket/safari-pinned-tab.svg" color="#0052CC">

<link rel="search" type="application/opensearchdescription+xml" href="/opensearch.xml" title="Bitbucket">

    <meta name="description" content="">
    <meta name="bb-single-page-app" content="true">
    
      <link rel="stylesheet" href="https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net/assets/vendor.a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a.css">
    
      <link rel="stylesheet" href="https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net/assets/all.compiled.a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a.css">
    
    
    
    <link
  rel="preconnect"
  href="https://ds-cdn.prod-east.frontend.public.atl-paas.net" />
<link
  rel="preload"
  href="https://ds-cdn.prod-east.frontend.public.atl-paas.net/assets/fonts/atlassian-sans/v3/AtlassianSans-latin.woff2"
  as="font" type="font/woff2" crossorigin />
<link
  rel="preload stylesheet"
  href="https://ds-cdn.prod-east.frontend.public.atl-paas.net/assets/font-rules/v5/atlassian-fonts.css"
  as="style" crossorigin />
    

    <script nonce="l+zN+5M44fbtuD5atwVMJw==">

if (window.performance) {

  
  window.performance.okayToSendMetrics = !document.hidden && 'onvisibilitychange' in document;

  if (window.performance.okayToSendMetrics) {

    
    window.addEventListener('visibilitychange', function () {
      if (document.hidden) {
        window.performance.okayToSendMetrics = false;
      }
    });
  }

  
  
}
</script>
  </head>
  <body>
    <div id="root">
    <script nonce="l+zN+5M44fbtuD5atwVMJw==">
      window.__webpack_public_path__ = "https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net";
    </script>
    
    
    
    </div>
    
    <link rel="preconnect" href="https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net"  />
    <script nonce="l+zN+5M44fbtuD5atwVMJw==">
      
        window.__sentry__ = {"dsn": "https://2dcda83904474d8c86928ebbfa1ab294@o55978.ingest.sentry.io/1480772", "environment": "bifrost_production", "tags": {"dc_location": "Micros-3", "micros_deployment_id": "r3c6ja1f9hj42o3t", "micros_service": "bbc-website", "micros_envtype": "prod", "micros_service_version": "171991", "micros_instance_id": "i-0fea6180bb0ca5a6f", "micros_zone": "us-east-1.prod.atl-paas.net", "revision": "481cfd7abfe8"}};
      
      window.__app_data__ = {"navigationIsOpen": true, "tenantId": "80a8b480-d460-4fc2-9eb7-cded0cb53ef2", "features": {"bbc_nav_v4": false, "spa-account-settings--settings-index": true, "platform-team25-app-icon-tiles": true, "bbc-skip-old-feature-client": true, "autoreview_repository_settings_page": true, "bbc-forge-fct-allow-file-context": true, "bbc-forge-fct-allow-workspace-global-extension": true, "bbc-forge-fct-allow-workspace-personal-settings": true}, "links": {"backButtonUrl": null, "overviewUrl": "/butor-team/workspace/overview/"}, "initialContext": {"workspace": {"type": "workspace", "uuid": "{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}", "name": "butor team", "slug": "butor-team", "is_private": false, "is_privacy_enforced": false, "links": {"avatar": {"href": "https://bitbucket.org/workspaces/butor-team/avatar/?ts=1543619326"}, "html": {"href": "https://bitbucket.org/butor-team/"}, "self": {"href": "https://bitbucket.org/!api/2.0/workspaces/butor-team"}}, "created_on": "2018-11-30T23:08:46.313426+00:00", "forking_mode": "allow_forks"}, "repository": {"type": "repository", "full_name": "butor-team/portal", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/repositories/butor-team/portal"}, "html": {"href": "https://bitbucket.org/butor-team/portal"}, "avatar": {"href": "https://bytebucket.org/ravatar/%7B664c1c57-5eae-4cc0-b590-24ee5f1ca13a%7D?ts=default"}}, "name": "portal", "slug": "portal", "is_private": false, "uuid": "{664c1c57-5eae-4cc0-b590-24ee5f1ca13a}"}, "project": {"type": "project", "key": "PROJ", "uuid": "{8518d6a7-0853-46ec-a758-2b50de45f27f}", "is_private": false, "name": "butor stack", "description": "Project created by Bitbucket for butor public team", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/workspaces/butor-team/projects/PROJ"}, "html": {"href": "https://bitbucket.org/butor-team/workspace/projects/PROJ"}, "avatar": {"href": "https://bitbucket.org/butor-team/workspace/projects/PROJ/avatar/32?ts=1487779604"}}, "created_on": "2015-12-04T00:39:35.206191+00:00", "updated_on": "2017-02-22T16:06:44.742871+00:00", "has_publicly_visible_repos": true}}, "frontbucket_version": "a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a", "frontbucket_environment": "bifrost_production"};
      
        window.__initial_state__ = {"global": {"geoip_country": null, "is_mobile_user_agent": false, "site_message": "", "needs_marketing_consent": false, "marketing_consent_locale": null, "whats_new_feed": "https://atlassianblog.wpengine.com/wp-json/wp/v2/posts?tags=11972&context=embed&per_page=6&orderby=date&order=desc", "locale": "en", "path": "/butor-team/portal/commits/all", "isFocusedTask": false, "focusedTaskBackButtonUrl": null, "features": {"lookup-pr-approvers-from-prs": true, "log-asap-errors": true, "provisioning-install-pipelines-addon": true, "fd-prs-client-cache-fallback": true, "block-non-pipelines-custom-events-webhooks": true, "read-only-message-migrations": true, "provisioning-skip-workspace-creation": true, "uninstall-dvcs-addon-only-when-jira-is-removed": true, "auth-flow-adg3": true, "workspace-member-set-last-accessed": true, "use-elasticache-lsn-storage": true, "whitelisted_throttle_exemption": true, "bbc-pride-logo": false, "create-workspace-show-recaptcha": true, "spa-account-settings--settings-index": true, "platform-team25-app-icon-tiles": true, "lazy-diffstat": false, "bbc-rovo-data-onboarding-ux": true, "pipelines-test-management": false, "bbc-merge-queue-enabled": false, "bbc-forge-fct-allow-file-context": true, "bbc-forge-fct-allow-workspace-global-extension": true, "bbc-forge-fct-allow-workspace-personal-settings": true, "scope-dismiss-cross-sell-admin-promo-issues": true, "scope-dismiss-jira-box": false, "bbc_nav_v4": false, "use-new-connect-modules-endpoint": true, "workspace-ai-enabled": false, "workspace-settings-ai-editor-features-enabled": false, "workspace-settings-ai-rovo-chat-enabled": false, "pr-code-push-webhook": false, "custom-merge-checks-activated": false, "pr-review-groups": false}, "isNavigationOpen": true, "flags": [], "horizontalNavigationItems": {"mainItems": [{"id": "pullrequests-tab", "label": "Pull requests", "tab_name": "pullrequests", "anchor": true, "weight": 140, "is_premium": null, "is_beta": null, "is_new": null, "url": "/butor-team/workspace/pull-requests/", "target": "_self", "icon_class": "", "badge_label": null, "matching_url_prefixes": [], "analytics_label": "pullrequests", "analytics_payload": {}, "is_client_link": true, "is_external_link": false, "is_dropdown_item": false, "test_id": null, "children": [], "type": "menu_item", "icon": ""}, {"id": "repositories-tab", "label": "Repositories", "tab_name": "repositories", "anchor": true, "weight": 160, "is_premium": null, "is_beta": null, "is_new": null, "url": "/butor-team/workspace/repositories/", "target": "_self", "icon_class": "", "badge_label": null, "matching_url_prefixes": [], "analytics_label": "repositories", "analytics_payload": {}, "is_client_link": true, "is_external_link": false, "is_dropdown_item": true, "test_id": null, "children": [], "type": "menu_item", "icon": ""}, {"id": "projects-tab", "label": "Projects", "tab_name": "projects", "anchor": true, "weight": 200, "is_premium": null, "is_beta": null, "is_new": null, "url": "/butor-team/workspace/projects/", "target": "_self", "icon_class": "", "badge_label": null, "matching_url_prefixes": [], "analytics_label": "projects", "analytics_payload": {}, "is_client_link": true, "is_external_link": false, "is_dropdown_item": true, "test_id": null, "children": [], "type": "menu_item", "icon": ""}], "secondaryItems": [], "settingsItems": []}, "targetUser": {"display_name": "butor team", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/workspaces/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D"}, "avatar": {"href": "https://bitbucket.org/account/butor-team/avatar/"}, "html": {"href": "https://bitbucket.org/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D/"}}, "created_on": "2014-06-02T02:59:56.187081+00:00", "is_active": true, "type": "team", "uuid": "{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}", "has_2fa_enabled": null, "properties": {}, "username": "butor-team"}, "targetFeatures": {"lookup-pr-approvers-from-prs": true, "log-asap-errors": true, "provisioning-install-pipelines-addon": true, "fd-prs-client-cache-fallback": true, "block-non-pipelines-custom-events-webhooks": true, "view-source-filtering-upon-timeout": true, "read-only-message-migrations": true, "provisioning-skip-workspace-creation": true, "fd-repository-page-loading-error-guard": true, "uninstall-dvcs-addon-only-when-jira-is-removed": true, "auth-flow-adg3": true, "workspace-member-set-last-accessed": true, "use-elasticache-lsn-storage": true, "whitelisted_throttle_exemption": true, "atlassian-editor": true}}, "section": {"repository": {"cloneProtocol": "https", "currentRepository": {"type": "repository", "full_name": "butor-team/portal", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/repositories/butor-team/portal"}, "html": {"href": "https://bitbucket.org/butor-team/portal"}, "avatar": {"href": "https://bytebucket.org/ravatar/%7B664c1c57-5eae-4cc0-b590-24ee5f1ca13a%7D?ts=default"}, "clone": [{"name": "https", "href": "https://bitbucket.org/butor-team/portal.git"}, {"name": "ssh", "href": "git@bitbucket.org:butor-team/portal.git"}]}, "name": "portal", "slug": "portal", "description": "", "scm": "git", "website": "", "owner": {"display_name": "butor team", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/workspaces/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D"}, "avatar": {"href": "https://bitbucket.org/account/butor-team/avatar/"}, "html": {"href": "https://bitbucket.org/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D/"}}, "type": "team", "uuid": "{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}", "username": "butor-team"}, "workspace": {"type": "workspace", "uuid": "{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}", "name": "butor team", "slug": "butor-team", "is_private": false, "is_privacy_enforced": false, "links": {"avatar": {"href": "https://bitbucket.org/workspaces/butor-team/avatar/?ts=1543619326"}, "html": {"href": "https://bitbucket.org/butor-team/"}, "self": {"href": "https://bitbucket.org/!api/2.0/workspaces/butor-team"}}, "created_on": "2018-11-30T23:08:46.313426+00:00", "forking_mode": "allow_forks"}, "is_private": false, "project": {"type": "project", "owner": {"display_name": "butor team", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/workspaces/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D"}, "avatar": {"href": "https://bitbucket.org/account/butor-team/avatar/"}, "html": {"href": "https://bitbucket.org/%7B80a8b480-d460-4fc2-9eb7-cded0cb53ef2%7D/"}}, "type": "team", "uuid": "{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}", "username": "butor-team"}, "workspace": {"type": "workspace", "uuid": "{80a8b480-d460-4fc2-9eb7-cded0cb53ef2}", "name": "butor team", "slug": "butor-team", "links": {"avatar": {"href": "https://bitbucket.org/workspaces/butor-team/avatar/?ts=1543619326"}, "html": {"href": "https://bitbucket.org/butor-team/"}, "self": {"href": "https://bitbucket.org/!api/2.0/workspaces/butor-team"}}}, "key": "PROJ", "uuid": "{8518d6a7-0853-46ec-a758-2b50de45f27f}", "is_private": false, "name": "butor stack", "description": "Project created by Bitbucket for butor public team", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/workspaces/butor-team/projects/PROJ"}, "html": {"href": "https://bitbucket.org/butor-team/workspace/projects/PROJ"}, "avatar": {"href": "https://bitbucket.org/butor-team/workspace/projects/PROJ/avatar/32?ts=1487779604"}}, "created_on": "2015-12-04T00:39:35.206191+00:00", "updated_on": "2017-02-22T16:06:44.742871+00:00", "has_publicly_visible_repos": true}, "fork_policy": "allow_forks", "updated_on": "2019-07-05T12:31:35.636202+00:00", "language": "", "uuid": "{664c1c57-5eae-4cc0-b590-24ee5f1ca13a}", "mainbranch": {"name": "master"}, "state": "available", "landing_page": "source"}, "mirrors": [], "sizeLimits": {"hard": 4294967296, "soft": 2147483648.0, "readOnly": 10737418240.0}, "override_settings": {"default_merge_strategy": false, "branching_model": false}}}, "commits-list": {}};
      
      window.__settings__ = {"ADMINHUB_BASE_URL": "https://admin.atlassian.com", "API_CANON_URL": "https://api.bitbucket.org", "CANON_URL": "https://bitbucket.org", "LOGIN_URL": "/account/signin/", "SOCIAL_AUTH_ATLASSIANID_LOGIN_PROMPT_URL": "https://id.atlassian.com/login", "SOCIAL_AUTH_ATLASSIANID_LOGOUT_URL": "https://id.atlassian.com/logout", "SOCIAL_AUTH_ATLASSIANID_PROFILE_URL": "https://id.atlassian.com/manage-profile/", "ATLASSIANID_LOGIN_URL": "https://id.atlassian.com/login", "ATLASSIANID_LOGOUT_URL": "https://id.atlassian.com/logout", "ATLASSIANID_MANAGE_PROFILE_URL": "https://id.atlassian.com/manage-profile/", "MARKETPLACE_TERMS_OF_USE_URL": null, "CONSENT_HUB_FRONTEND_BASE_URL": "https://preferences.atlassian.com", "EMOJI_STANDARD_BASE_URL": "https://bitbucket.org/gateway/api/emoji/", "STATUSPAGE_URL": "https://bitbucket.status.atlassian.com/", "RECAPTCHA_PUBLIC_KEY": "6LcRaMMkAAAAAFB-7L-4-1-mdLIrOMAP4H5asuWK", "WAC_CREATE_WORKSPACE_URL": "https://www.atlassian.com/try/cloud/signup?bundle=bitbucket", "ATLASSIAN_PUBSUB_CONNECT_URL": "https://bitbucket.org/gateway/api/bbc-aps/subscriptions", "AGG_WEBSOCKET_SUBSCRIPTIONS_PATH": "/gateway/api/graphql/subscriptions"};
      window.__webpack_nonce__ = 'l+zN+5M44fbtuD5atwVMJw==';
      window.isInitialLoadApdex = true;
      
      
    </script>
    
      <script nonce="l+zN+5M44fbtuD5atwVMJw==" src="https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net/assets/ajs.a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a.js"></script>
    
      <script nonce="l+zN+5M44fbtuD5atwVMJw==" src="https://bbc-frontbucket-static.prod-east.frontend.public.atl-paas.net/assets/app.a7cf3292bda5d2bd4eddcc19ae8c6f40145df64a.js"></script>
    
  </body>
</html>", "url": "https://bitbucket.org/butor-team/portal/commits/all" } ]
n/a
CVE-2024-32979
Reflected Cross-site Scripting potential in all object list views in Nautobot
Nautobot is a Network Source of Truth and Network Automation Platform built as a web application atop the Django Python framework with a PostgreSQL or MySQL database. It was discovered that due to improper handling and escaping of user-provided query parameters, a maliciously crafted Nautobot URL could potentially be used to execute a Reflected Cross-Site Scripting (Reflected XSS) attack against users. All filterable object-list views in Nautobot are vulnerable. This issue has been fixed in Nautobot versions 1.6.20 and 2.2.3. There are no known workarounds for this vulnerability.
[ { "commit_message": "[PATCH] Fix quoting of query parameters in list view (#5646) * Add proper quoting of object-list filters * Add unit test * Change fragment * Fix new bug caught by integration tests * Use location.assign rather than location.replace, close modal on form submit changes/5646.security | 1 + .../core/templates/generic/object_list.html | 6 ++-- nautobot/core/tests/test_views.py | 19 ++++++++++++ nautobot/project-static/js/forms.js | 29 ++++++++++++------- 4 files changed, 41 insertions(+), 14 deletions(-) create mode 100644 changes/5646.security", "patch_text_b64": "From 42440ebd9b381534ad89d62420ebea00d703d64e Mon Sep 17 00:00:00 2001
From: Glenn Matthews <glenn.matthews@networktocode.com>
Date: Tue, 30 Apr 2024 10:29:41 -0400
Subject: [PATCH] Fix quoting of query parameters in list view (#5646)

* Add proper quoting of object-list filters

* Add unit test

* Change fragment

* Fix new bug caught by integration tests

* Use location.assign rather than location.replace, close modal on form submit
---
 changes/5646.security                         |  1 +
 .../core/templates/generic/object_list.html   |  6 ++--
 nautobot/core/tests/test_views.py             | 19 ++++++++++++
 nautobot/project-static/js/forms.js           | 29 ++++++++++++-------
 4 files changed, 41 insertions(+), 14 deletions(-)
 create mode 100644 changes/5646.security

diff --git a/changes/5646.security b/changes/5646.security
new file mode 100644
index 00000000000..dbabdaaf52b
--- /dev/null
+++ b/changes/5646.security
@@ -0,0 +1 @@
+Fixed a reflected-XSS vulnerability ([GHSA-jxgr-gcj5-cqqg](https://github.com/nautobot/nautobot/security/advisories/GHSA-jxgr-gcj5-cqqg)) in object-list view rendering of user-provided query parameters.
diff --git a/nautobot/core/templates/generic/object_list.html b/nautobot/core/templates/generic/object_list.html
index a6ca06fb0e3..8c80498dcc8 100644
--- a/nautobot/core/templates/generic/object_list.html
+++ b/nautobot/core/templates/generic/object_list.html
@@ -74,7 +74,7 @@ <h1>{% block title %}{{ title }}{% endblock %}</h1>
                     class="remove-filter-param"
                     title="Remove all items"
                     data-field-type="parent"
-                    data-field-value={{ field.name }}
+                    data-field-value="{{ field.name }}"
             >×</span>
             <ul class="filter-selection-rendered">
                 {% for value in field.values %}
@@ -85,8 +85,8 @@ <h1>{% block title %}{{ title }}{% endblock %}</h1>
                     <span
                             class="filter-selection-choice-remove remove-filter-param"
                             data-field-type="child"
-                            data-field-parent={{ field.name }}
-                            data-field-value={{ value.name }}
+                            data-field-parent="{{ field.name }}"
+                            data-field-value="{{ value.name }}"
                     >×</span>{{ value.display }}
                 </li>
                 {% endfor %}
diff --git a/nautobot/core/tests/test_views.py b/nautobot/core/tests/test_views.py
index b99e5966b5a..689c0b5a99b 100644
--- a/nautobot/core/tests/test_views.py
+++ b/nautobot/core/tests/test_views.py
@@ -242,6 +242,25 @@ def test_filtering_on_custom_select_filter_field(self):
         self.assertInHTML(locations[0].name, response_content)
         self.assertInHTML(locations[1].name, response_content)
 
+    def test_filtering_crafted_query_params(self):
+        """Test for reflected-XSS vulnerability GHSA-jxgr-gcj5-cqqg."""
+        self.add_permissions("dcim.view_location")
+        query_param = "?location_type=1 onmouseover=alert('hi') foo=bar"
+        url = reverse("dcim:location_list") + query_param
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        response_content = response.content.decode(response.charset)
+        # The important thing here is that the data-field-parent and data-field-value are correctly quoted
+        self.assertInHTML(
+            """
+<span class="filter-selection-choice-remove remove-filter-param"
+      data-field-type="child"
+      data-field-parent="location_type"
+      data-field-value="1 onmouseover=alert(&#x27;hi&#x27;) foo=bar"
+>×</span>""",  # noqa: RUF001 - ambiguous-unicode-character-string
+            response_content,
+        )
+
 
 class ForceScriptNameTestcase(TestCase):
     """Basic test to assert that `settings.FORCE_SCRIPT_NAME` works as intended."""
diff --git a/nautobot/project-static/js/forms.js b/nautobot/project-static/js/forms.js
index 20b9cc745bf..cfe3e1eb146 100644
--- a/nautobot/project-static/js/forms.js
+++ b/nautobot/project-static/js/forms.js
@@ -632,18 +632,19 @@ function initializeDynamicFilterForm(context){
 
     // Remove applied filters
     this_context.find(".remove-filter-param").on("click", function(){
-        let query_params = location.search;
+        let query_params = new URLSearchParams(location.search);
         let type = $(this).attr("data-field-type");
         let field_value = $(this).attr("data-field-value");
-        let query_string = location.search.substr(1).split("&");
 
         if (type === "parent") {
-            query_string = query_string.filter(item => item.search(field_value) < 0);
+            // Remove all instances of this query param
+            query_params.delete(field_value);
         } else {
+            // Remove this specific instance of this query param
             let parent = $(this).attr("data-field-parent");
-            query_string = query_string.filter(item => item.search(parent + "=" + field_value) < 0)
+            query_params.delete(parent, field_value);
         }
-        location.replace("?" + query_string.join("&"))
+        location.assign("?" + query_params);
     })
 
     // On submit of filter form
@@ -657,12 +658,18 @@ function initializeDynamicFilterForm(context){
         q_field_phantom.val(q_field.val())
         dynamic_form.append(q_field_phantom);
 
-        // Get the serialize data from the forms and filter out query_params which values are empty e.g ?sam=&dan=2 becomes dan=2
-        let dynamic_filter_form_query = $("#dynamic-filter-form").serialize().split("&").filter(params => params.split("=")[1]?.length || 0 )
-        let default_filter_form_query = $("#default-filter form").serialize().split("&").filter(params => params.split("=")[1]?.length || 0 )
-        // Union Operation
-        let search_query = [...new Set([...default_filter_form_query, ...dynamic_filter_form_query])].join("&")
-        location.replace("?" + search_query)
+        // Get the serialized data from the forms and:
+        // 1) filter out query_params which values are empty e.g ?sam=&dan=2 becomes dan=2
+        // 2) combine the two forms into a single set of data without duplicate entries
+        let search_query = new URLSearchParams();
+        let dynamic_query = new URLSearchParams(new FormData(document.getElementById("dynamic-filter-form")));
+        dynamic_query.forEach((value, key) => { if (value != "") { search_query.append(key, value); }});
+        let default_query = new URLSearchParams(new FormData(document.getElementById("default-filter").firstElementChild));
+        default_query.forEach((value, key) => {
+            if (value != "" && !search_query.has(key, value)) { search_query.append(key, value); }
+        });
+        $("#FilterForm_modal").modal("hide");
+        location.assign("?" + search_query);
     })
 
     // On submit of filter search form", "url": "https://github.com/nautobot/nautobot/commit/42440ebd9b381534ad89d62420ebea00d703d64e.patch" } ]
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
CVE-2025-65092
ESP32-P4 JPEG Decoder Header Parsing Vulnerability
ESF-IDF is the Espressif Internet of Things (IOT) Development Framework. In versions 5.5.1, 5.4.3, and 5.3.4, when the ESP32-P4 uses its hardware JPEG decoder, the software parser lacks necessary validation checks. A specially crafted (malicious) JPEG image could exploit the parsing routine and trigger an out-of-bounds array access. This issue has been fixed in versions 5.5.2, 5.4.4, and 5.3.5. At time of publication versions 5.5.2, 5.4.4, and 5.3.5 have not been released but are fixed respectively in commits 4b8f585, c79cb4d, and 34e2726.
[ { "commit_message": "[PATCH] fix(jpeg): Add check for jpeg marker parser in order to enhance safety .../esp_driver_jpeg/jpeg_parse_marker.c | 44 ++++++++++++++----- 1 file changed, 33 insertions(+), 11 deletions(-)", "patch_text_b64": "From 34e2726254201988e6e2752b2db4b70d73964d4c Mon Sep 17 00:00:00 2001
From: "C.S.M" <caosenmiao@espressif.com>
Date: Thu, 9 Oct 2025 17:44:15 +0800
Subject: [PATCH] fix(jpeg): Add check for jpeg marker parser in order to
 enhance safety

---
 .../esp_driver_jpeg/jpeg_parse_marker.c       | 44 ++++++++++++++-----
 1 file changed, 33 insertions(+), 11 deletions(-)

diff --git a/components/esp_driver_jpeg/jpeg_parse_marker.c b/components/esp_driver_jpeg/jpeg_parse_marker.c
index cafaabc9e326..5a6db487b776 100644
--- a/components/esp_driver_jpeg/jpeg_parse_marker.c
+++ b/components/esp_driver_jpeg/jpeg_parse_marker.c
@@ -20,6 +20,11 @@ static const char *TAG = "jpeg.decoder";
 
 static uint8_t jpeg_get_char(jpeg_dec_header_info_t *header_info)
 {
+    // Check if there are bytes left to read before decrementing buffer_left
+    if (header_info->buffer_left == 0) {
+        ESP_LOGE(TAG, "Buffer underflow detected in jpeg_get_char: no more bytes left to read");
+        return 0;
+    }
     uint8_t c = header_info->buffer_offset[0];
     header_info->buffer_offset++;
     header_info->header_size++;
@@ -39,20 +44,26 @@ uint32_t jpeg_get_bytes(jpeg_dec_header_info_t *header_info, uint8_t num_bytes)
 
 esp_err_t jpeg_parse_appn_marker(jpeg_dec_header_info_t *header_info)
 {
-    uint32_t skip_num = jpeg_get_bytes(header_info, 2);
-    header_info->buffer_offset += (skip_num - 2);
-    header_info->header_size += (skip_num - 2);
-    header_info->buffer_left -= (skip_num - 2);
+    uint16_t skip_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(skip_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid APPn marker length: %d", skip_num);
+    uint16_t bytes_to_skip = skip_num - 2;
+    ESP_RETURN_ON_FALSE(header_info->buffer_left >= bytes_to_skip, ESP_ERR_INVALID_ARG, TAG, "APPn marker data underflow for buffer_left: %ld", header_info->buffer_left);
+    header_info->buffer_offset += bytes_to_skip;
+    header_info->header_size += bytes_to_skip;
+    header_info->buffer_left -= bytes_to_skip;
 
     return ESP_OK;
 }
 
 esp_err_t jpeg_parse_com_marker(jpeg_dec_header_info_t *header_info)
 {
-    uint32_t skip_num = jpeg_get_bytes(header_info, 2);
-    header_info->buffer_offset += (skip_num - 2);
-    header_info->header_size += (skip_num - 2);
-    header_info->buffer_left -= (skip_num - 2);
+    uint16_t skip_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(skip_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid COM marker length: %d", skip_num);
+    uint32_t bytes_to_skip = skip_num - 2;
+    ESP_RETURN_ON_FALSE(header_info->header_size >= bytes_to_skip, ESP_ERR_INVALID_ARG, TAG, "COM marker data underflow for header_size: %ld", header_info->header_size);
+    header_info->buffer_offset += bytes_to_skip;
+    header_info->header_size += bytes_to_skip;
+    header_info->buffer_left -= bytes_to_skip;
     return ESP_OK;
 }
 
@@ -61,21 +72,25 @@ esp_err_t jpeg_parse_dqt_marker(jpeg_dec_header_info_t *header_info)
     uint32_t n = 0, i = 0, prec = 0;
     uint32_t temp = 0;
 
-    uint32_t length_num = jpeg_get_bytes(header_info, 2);
+    uint16_t length_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(length_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid DQT marker length: %d", length_num);
     length_num -= 2;
 
     while (length_num) {
         n = jpeg_get_bytes(header_info, 1);
         prec = n >> 4;
         n &= 0x0F;
+        ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %d", length_num);
         length_num -= 1;
 
         // read quantization entries, in zig-zag order
         for (i = 0; i < 64; i++) {
             temp = jpeg_get_bytes(header_info, 1);
+            ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %d", length_num);
             length_num -= 1;
             if (prec) {
                 temp = (temp << 8) + jpeg_get_bytes(header_info, 1);
+                ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %d", length_num);
                 length_num -= 1;
             }
             header_info->qt_tbl[n][zigzag_arr[i]] = temp;
@@ -142,7 +157,10 @@ esp_err_t jpeg_parse_sof_marker(jpeg_dec_header_info_t *header_info)
 esp_err_t jpeg_parse_dht_marker(jpeg_dec_header_info_t *header_info)
 {
     // Recording num_left in DHT sector, not including length bytes (2 bytes).
-    uint32_t num_left = jpeg_get_bytes(header_info, 2) - 2;
+    uint16_t raw_length = jpeg_get_bytes(header_info, 2);
+    // Check for integer underflow before subtraction
+    ESP_RETURN_ON_FALSE(raw_length >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid DHT marker length: %d", raw_length);
+    uint16_t num_left = raw_length - 2;
     while (num_left) {
         uint32_t np = 0;
 
@@ -159,6 +177,8 @@ esp_err_t jpeg_parse_dht_marker(jpeg_dec_header_info_t *header_info)
             header_info->huffcode[header_info->huffinfo.type][header_info->huffinfo.id][i] = jpeg_get_bytes(header_info, 1);
         }
 
+        // Check for integer underflow before subtraction
+        ESP_RETURN_ON_FALSE(num_left >= (JPEG_HUFFMAN_BITS_LEN_TABLE_LEN + np + 1), ESP_ERR_INVALID_ARG, TAG, "DHT marker data underflow after parsing huffcode: %d", num_left);
         num_left -= (1 + JPEG_HUFFMAN_BITS_LEN_TABLE_LEN + np);
     }
 
@@ -171,7 +191,7 @@ esp_err_t jpeg_parse_dri_marker(jpeg_dec_header_info_t *header_info)
 {
     uint16_t lr = jpeg_get_bytes(header_info, 2);
     if (lr != 4) {
-        ESP_LOGE(TAG, "DRI marker got but stream length is insufficient, the length you got is %" PRIu16, lr);
+        ESP_LOGE(TAG, "DRI marker got but stream length is insufficient, the length you got is %d", lr);
         return ESP_ERR_INVALID_SIZE;
     }
     header_info->ri = jpeg_get_bytes(header_info, 2);
@@ -181,6 +201,7 @@ esp_err_t jpeg_parse_dri_marker(jpeg_dec_header_info_t *header_info)
 esp_err_t jpeg_parse_sos_marker(jpeg_dec_header_info_t *header_info)
 {
     // Got the SOS marker, but need to recover this and feed to 2DDMA.
+    ESP_RETURN_ON_FALSE(header_info->header_size >= 2, ESP_ERR_INVALID_ARG, TAG, "SOS marker header_size underflow: %ld", header_info->header_size);
     header_info->buffer_offset -= 2;
     header_info->header_size -= 2;
     header_info->buffer_left += 2;
@@ -191,6 +212,7 @@ esp_err_t jpeg_parse_inv_marker(jpeg_dec_header_info_t *header_info)
 {
     // Got invalid 0xFFFF, (followed by a valid marker type)
     // Go one byte back, to skip the first 0xFF
+    ESP_RETURN_ON_FALSE(header_info->header_size >= 1, ESP_ERR_INVALID_ARG, TAG, "INV marker header_size underflow: %ld", header_info->header_size);
     header_info->buffer_offset--;
     header_info->header_size--;
     header_info->buffer_left++;", "url": "https://github.com/espressif/esp-idf/commit/34e2726254201988e6e2752b2db4b70d73964d4c.patch" }, { "commit_message": "[PATCH] fix(jpeg): Add check for jpeg marker parser in order to enhance safety .../include/driver/jpeg_types.h | 2 +- components/esp_driver_jpeg/jpeg_encode.c | 2 +- .../esp_driver_jpeg/jpeg_parse_marker.c | 42 ++++++++++++++----- 3 files changed, 34 insertions(+), 12 deletions(-)", "patch_text_b64": "From 4b8f5859dbe05d15372558f8a950b49f6ee44e42 Mon Sep 17 00:00:00 2001
From: "C.S.M" <caosenmiao@espressif.com>
Date: Thu, 9 Oct 2025 17:44:15 +0800
Subject: [PATCH] fix(jpeg): Add check for jpeg marker parser in order to
 enhance safety

---
 .../include/driver/jpeg_types.h               |  2 +-
 components/esp_driver_jpeg/jpeg_encode.c      |  2 +-
 .../esp_driver_jpeg/jpeg_parse_marker.c       | 42 ++++++++++++++-----
 3 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/components/esp_driver_jpeg/include/driver/jpeg_types.h b/components/esp_driver_jpeg/include/driver/jpeg_types.h
index 6b53292185fa..5959e688f6b8 100644
--- a/components/esp_driver_jpeg/include/driver/jpeg_types.h
+++ b/components/esp_driver_jpeg/include/driver/jpeg_types.h
@@ -59,7 +59,7 @@ typedef enum {
     JPEG_ENCODE_IN_FORMAT_RGB565 = COLOR_TYPE_ID(COLOR_SPACE_RGB, COLOR_PIXEL_RGB565),       /*!< input RGB565 format */
     JPEG_ENCODE_IN_FORMAT_GRAY = COLOR_TYPE_ID(COLOR_SPACE_GRAY, COLOR_PIXEL_GRAY8),         /*!< input GRAY format */
     JPEG_ENCODE_IN_FORMAT_YUV422 = COLOR_TYPE_ID(COLOR_SPACE_YUV, COLOR_PIXEL_YUV422),       /*!< input YUV422 format */
-#if !(CONFIG_ESP_REV_MIN_FULL < 300 && SOC_IS(ESP32P4)) // Invisible for unsupported chips
+#if !(CONFIG_ESP_REV_MIN_FULL < 300 && CONFIG_IDF_TARGET_ESP32P4) // Invisible for unsupported chips
     JPEG_ENCODE_IN_FORMAT_YUV444 = COLOR_TYPE_ID(COLOR_SPACE_YUV, COLOR_PIXEL_YUV444),       /*!< input YUV444 format */
     JPEG_ENCODE_IN_FORMAT_YUV420 = COLOR_TYPE_ID(COLOR_SPACE_YUV, COLOR_PIXEL_YUV420),       /*!< input YUV420 format */
 #endif
diff --git a/components/esp_driver_jpeg/jpeg_encode.c b/components/esp_driver_jpeg/jpeg_encode.c
index c8a573f9f559..8107ea69da34 100644
--- a/components/esp_driver_jpeg/jpeg_encode.c
+++ b/components/esp_driver_jpeg/jpeg_encode.c
@@ -183,7 +183,7 @@ esp_err_t jpeg_encoder_process(jpeg_encoder_handle_t encoder_engine, const jpeg_
         encoder_engine->color_space = JPEG_ENC_SRC_YUV422;
         best_hb_idx = JPEG_ENC_SRC_YUV422_HB;
         break;
-#if !(CONFIG_ESP_REV_MIN_FULL < 300 && SOC_IS(ESP32P4))
+#if !(CONFIG_ESP_REV_MIN_FULL < 300 && CONFIG_IDF_TARGET_ESP32P4)
     case JPEG_ENCODE_IN_FORMAT_YUV444:
         encoder_engine->color_space = JPEG_ENC_SRC_YUV444;
         best_hb_idx = JPEG_ENC_SRC_YUV444_HB;
diff --git a/components/esp_driver_jpeg/jpeg_parse_marker.c b/components/esp_driver_jpeg/jpeg_parse_marker.c
index 9ba19048cfa4..e26bdf218a17 100644
--- a/components/esp_driver_jpeg/jpeg_parse_marker.c
+++ b/components/esp_driver_jpeg/jpeg_parse_marker.c
@@ -20,6 +20,11 @@ static const char *TAG = "jpeg.decoder";
 
 static uint8_t jpeg_get_char(jpeg_dec_header_info_t *header_info)
 {
+    // Check if there are bytes left to read before decrementing buffer_left
+    if (header_info->buffer_left == 0) {
+        ESP_LOGE(TAG, "Buffer underflow detected in jpeg_get_char: no more bytes left to read");
+        return 0;
+    }
     uint8_t c = header_info->buffer_offset[0];
     header_info->buffer_offset++;
     header_info->header_size++;
@@ -39,20 +44,26 @@ uint32_t jpeg_get_bytes(jpeg_dec_header_info_t *header_info, uint8_t num_bytes)
 
 esp_err_t jpeg_parse_appn_marker(jpeg_dec_header_info_t *header_info)
 {
-    uint32_t skip_num = jpeg_get_bytes(header_info, 2);
-    header_info->buffer_offset += (skip_num - 2);
-    header_info->header_size += (skip_num - 2);
-    header_info->buffer_left -= (skip_num - 2);
+    uint16_t skip_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(skip_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid APPn marker length: %"PRIu32, skip_num);
+    uint16_t bytes_to_skip = skip_num - 2;
+    ESP_RETURN_ON_FALSE(header_info->buffer_left >= bytes_to_skip, ESP_ERR_INVALID_ARG, TAG, "APPn marker data underflow for buffer_left: %"PRIu32, header_info->buffer_left);
+    header_info->buffer_offset += bytes_to_skip;
+    header_info->header_size += bytes_to_skip;
+    header_info->buffer_left -= bytes_to_skip;
 
     return ESP_OK;
 }
 
 esp_err_t jpeg_parse_com_marker(jpeg_dec_header_info_t *header_info)
 {
-    uint32_t skip_num = jpeg_get_bytes(header_info, 2);
-    header_info->buffer_offset += (skip_num - 2);
-    header_info->header_size += (skip_num - 2);
-    header_info->buffer_left -= (skip_num - 2);
+    uint16_t skip_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(skip_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid COM marker length: %"PRIu32, skip_num);
+    uint32_t bytes_to_skip = skip_num - 2;
+    ESP_RETURN_ON_FALSE(header_info->header_size >= bytes_to_skip, ESP_ERR_INVALID_ARG, TAG, "COM marker data underflow for header_size: %"PRIu32, header_info->header_size);
+    header_info->buffer_offset += bytes_to_skip;
+    header_info->header_size += bytes_to_skip;
+    header_info->buffer_left -= bytes_to_skip;
     return ESP_OK;
 }
 
@@ -61,21 +72,25 @@ esp_err_t jpeg_parse_dqt_marker(jpeg_dec_header_info_t *header_info)
     uint32_t n = 0, i = 0, prec = 0;
     uint32_t temp = 0;
 
-    uint32_t length_num = jpeg_get_bytes(header_info, 2);
+    uint16_t length_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(length_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid DQT marker length: %"PRIu32, length_num);
     length_num -= 2;
 
     while (length_num) {
         n = jpeg_get_bytes(header_info, 1);
         prec = n >> 4;
         n &= 0x0F;
+        ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %"PRIu32, length_num);
         length_num -= 1;
 
         // read quantization entries, in zig-zag order
         for (i = 0; i < 64; i++) {
             temp = jpeg_get_bytes(header_info, 1);
+            ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %"PRIu32, length_num);
             length_num -= 1;
             if (prec) {
                 temp = (temp << 8) + jpeg_get_bytes(header_info, 1);
+                ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %"PRIu32, length_num);
                 length_num -= 1;
             }
             header_info->qt_tbl[n][zigzag_arr[i]] = temp;
@@ -142,7 +157,10 @@ esp_err_t jpeg_parse_sof_marker(jpeg_dec_header_info_t *header_info)
 esp_err_t jpeg_parse_dht_marker(jpeg_dec_header_info_t *header_info)
 {
     // Recording num_left in DHT sector, not including length bytes (2 bytes).
-    uint32_t num_left = jpeg_get_bytes(header_info, 2) - 2;
+    uint16_t raw_length = jpeg_get_bytes(header_info, 2);
+    // Check for integer underflow before subtraction
+    ESP_RETURN_ON_FALSE(raw_length >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid DHT marker length: %"PRIu32, raw_length);
+    uint16_t num_left = raw_length - 2;
     while (num_left) {
         uint32_t np = 0;
 
@@ -159,6 +177,8 @@ esp_err_t jpeg_parse_dht_marker(jpeg_dec_header_info_t *header_info)
             header_info->huffcode[header_info->huffinfo.type][header_info->huffinfo.id][i] = jpeg_get_bytes(header_info, 1);
         }
 
+        // Check for integer underflow before subtraction
+        ESP_RETURN_ON_FALSE(num_left >= (JPEG_HUFFMAN_BITS_LEN_TABLE_LEN + np + 1), ESP_ERR_INVALID_ARG, TAG, "DHT marker data underflow after parsing huffcode: %"PRIu32, num_left);
         num_left -= (1 + JPEG_HUFFMAN_BITS_LEN_TABLE_LEN + np);
     }
 
@@ -181,6 +201,7 @@ esp_err_t jpeg_parse_dri_marker(jpeg_dec_header_info_t *header_info)
 esp_err_t jpeg_parse_sos_marker(jpeg_dec_header_info_t *header_info)
 {
     // Got the SOS marker, but need to recover this and feed to 2DDMA.
+    ESP_RETURN_ON_FALSE(header_info->header_size >= 2, ESP_ERR_INVALID_ARG, TAG, "SOS marker header_size underflow: %"PRIu32, header_info->header_size);
     header_info->buffer_offset -= 2;
     header_info->header_size -= 2;
     header_info->buffer_left += 2;
@@ -191,6 +212,7 @@ esp_err_t jpeg_parse_inv_marker(jpeg_dec_header_info_t *header_info)
 {
     // Got invalid 0xFFFF, (followed by a valid marker type)
     // Go one byte back, to skip the first 0xFF
+    ESP_RETURN_ON_FALSE(header_info->header_size >= 1, ESP_ERR_INVALID_ARG, TAG, "INV marker header_size underflow: %"PRIu32, header_info->header_size);
     header_info->buffer_offset--;
     header_info->header_size--;
     header_info->buffer_left++;", "url": "https://github.com/espressif/esp-idf/commit/4b8f5859dbe05d15372558f8a950b49f6ee44e42.patch" }, { "commit_message": "[PATCH] fix(jpeg): Add check for jpeg marker parser in order to enhance safety .../esp_driver_jpeg/jpeg_parse_marker.c | 42 ++++++++++++++----- 1 file changed, 32 insertions(+), 10 deletions(-)", "patch_text_b64": "From c38a6691b9845ac6ee0d0f6713783114770cdc17 Mon Sep 17 00:00:00 2001
From: "C.S.M" <caosenmiao@espressif.com>
Date: Thu, 9 Oct 2025 17:44:15 +0800
Subject: [PATCH] fix(jpeg): Add check for jpeg marker parser in order to
 enhance safety

---
 .../esp_driver_jpeg/jpeg_parse_marker.c       | 42 ++++++++++++++-----
 1 file changed, 32 insertions(+), 10 deletions(-)

diff --git a/components/esp_driver_jpeg/jpeg_parse_marker.c b/components/esp_driver_jpeg/jpeg_parse_marker.c
index 9ba19048cfa4..e26bdf218a17 100644
--- a/components/esp_driver_jpeg/jpeg_parse_marker.c
+++ b/components/esp_driver_jpeg/jpeg_parse_marker.c
@@ -20,6 +20,11 @@ static const char *TAG = "jpeg.decoder";
 
 static uint8_t jpeg_get_char(jpeg_dec_header_info_t *header_info)
 {
+    // Check if there are bytes left to read before decrementing buffer_left
+    if (header_info->buffer_left == 0) {
+        ESP_LOGE(TAG, "Buffer underflow detected in jpeg_get_char: no more bytes left to read");
+        return 0;
+    }
     uint8_t c = header_info->buffer_offset[0];
     header_info->buffer_offset++;
     header_info->header_size++;
@@ -39,20 +44,26 @@ uint32_t jpeg_get_bytes(jpeg_dec_header_info_t *header_info, uint8_t num_bytes)
 
 esp_err_t jpeg_parse_appn_marker(jpeg_dec_header_info_t *header_info)
 {
-    uint32_t skip_num = jpeg_get_bytes(header_info, 2);
-    header_info->buffer_offset += (skip_num - 2);
-    header_info->header_size += (skip_num - 2);
-    header_info->buffer_left -= (skip_num - 2);
+    uint16_t skip_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(skip_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid APPn marker length: %"PRIu32, skip_num);
+    uint16_t bytes_to_skip = skip_num - 2;
+    ESP_RETURN_ON_FALSE(header_info->buffer_left >= bytes_to_skip, ESP_ERR_INVALID_ARG, TAG, "APPn marker data underflow for buffer_left: %"PRIu32, header_info->buffer_left);
+    header_info->buffer_offset += bytes_to_skip;
+    header_info->header_size += bytes_to_skip;
+    header_info->buffer_left -= bytes_to_skip;
 
     return ESP_OK;
 }
 
 esp_err_t jpeg_parse_com_marker(jpeg_dec_header_info_t *header_info)
 {
-    uint32_t skip_num = jpeg_get_bytes(header_info, 2);
-    header_info->buffer_offset += (skip_num - 2);
-    header_info->header_size += (skip_num - 2);
-    header_info->buffer_left -= (skip_num - 2);
+    uint16_t skip_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(skip_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid COM marker length: %"PRIu32, skip_num);
+    uint32_t bytes_to_skip = skip_num - 2;
+    ESP_RETURN_ON_FALSE(header_info->header_size >= bytes_to_skip, ESP_ERR_INVALID_ARG, TAG, "COM marker data underflow for header_size: %"PRIu32, header_info->header_size);
+    header_info->buffer_offset += bytes_to_skip;
+    header_info->header_size += bytes_to_skip;
+    header_info->buffer_left -= bytes_to_skip;
     return ESP_OK;
 }
 
@@ -61,21 +72,25 @@ esp_err_t jpeg_parse_dqt_marker(jpeg_dec_header_info_t *header_info)
     uint32_t n = 0, i = 0, prec = 0;
     uint32_t temp = 0;
 
-    uint32_t length_num = jpeg_get_bytes(header_info, 2);
+    uint16_t length_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(length_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid DQT marker length: %"PRIu32, length_num);
     length_num -= 2;
 
     while (length_num) {
         n = jpeg_get_bytes(header_info, 1);
         prec = n >> 4;
         n &= 0x0F;
+        ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %"PRIu32, length_num);
         length_num -= 1;
 
         // read quantization entries, in zig-zag order
         for (i = 0; i < 64; i++) {
             temp = jpeg_get_bytes(header_info, 1);
+            ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %"PRIu32, length_num);
             length_num -= 1;
             if (prec) {
                 temp = (temp << 8) + jpeg_get_bytes(header_info, 1);
+                ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %"PRIu32, length_num);
                 length_num -= 1;
             }
             header_info->qt_tbl[n][zigzag_arr[i]] = temp;
@@ -142,7 +157,10 @@ esp_err_t jpeg_parse_sof_marker(jpeg_dec_header_info_t *header_info)
 esp_err_t jpeg_parse_dht_marker(jpeg_dec_header_info_t *header_info)
 {
     // Recording num_left in DHT sector, not including length bytes (2 bytes).
-    uint32_t num_left = jpeg_get_bytes(header_info, 2) - 2;
+    uint16_t raw_length = jpeg_get_bytes(header_info, 2);
+    // Check for integer underflow before subtraction
+    ESP_RETURN_ON_FALSE(raw_length >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid DHT marker length: %"PRIu32, raw_length);
+    uint16_t num_left = raw_length - 2;
     while (num_left) {
         uint32_t np = 0;
 
@@ -159,6 +177,8 @@ esp_err_t jpeg_parse_dht_marker(jpeg_dec_header_info_t *header_info)
             header_info->huffcode[header_info->huffinfo.type][header_info->huffinfo.id][i] = jpeg_get_bytes(header_info, 1);
         }
 
+        // Check for integer underflow before subtraction
+        ESP_RETURN_ON_FALSE(num_left >= (JPEG_HUFFMAN_BITS_LEN_TABLE_LEN + np + 1), ESP_ERR_INVALID_ARG, TAG, "DHT marker data underflow after parsing huffcode: %"PRIu32, num_left);
         num_left -= (1 + JPEG_HUFFMAN_BITS_LEN_TABLE_LEN + np);
     }
 
@@ -181,6 +201,7 @@ esp_err_t jpeg_parse_dri_marker(jpeg_dec_header_info_t *header_info)
 esp_err_t jpeg_parse_sos_marker(jpeg_dec_header_info_t *header_info)
 {
     // Got the SOS marker, but need to recover this and feed to 2DDMA.
+    ESP_RETURN_ON_FALSE(header_info->header_size >= 2, ESP_ERR_INVALID_ARG, TAG, "SOS marker header_size underflow: %"PRIu32, header_info->header_size);
     header_info->buffer_offset -= 2;
     header_info->header_size -= 2;
     header_info->buffer_left += 2;
@@ -191,6 +212,7 @@ esp_err_t jpeg_parse_inv_marker(jpeg_dec_header_info_t *header_info)
 {
     // Got invalid 0xFFFF, (followed by a valid marker type)
     // Go one byte back, to skip the first 0xFF
+    ESP_RETURN_ON_FALSE(header_info->header_size >= 1, ESP_ERR_INVALID_ARG, TAG, "INV marker header_size underflow: %"PRIu32, header_info->header_size);
     header_info->buffer_offset--;
     header_info->header_size--;
     header_info->buffer_left++;", "url": "https://github.com/espressif/esp-idf/commit/c38a6691b9845ac6ee0d0f6713783114770cdc17.patch" }, { "commit_message": "[PATCH] fix(jpeg): Add check for jpeg marker parser in order to enhance safety .../include/driver/jpeg_types.h | 2 +- components/esp_driver_jpeg/jpeg_encode.c | 2 +- .../esp_driver_jpeg/jpeg_parse_marker.c | 42 ++++++++++++++----- 3 files changed, 34 insertions(+), 12 deletions(-)", "patch_text_b64": "From c79cb4de468854937a0cbf82629fd65d04bffb27 Mon Sep 17 00:00:00 2001
From: "C.S.M" <caosenmiao@espressif.com>
Date: Thu, 9 Oct 2025 17:44:15 +0800
Subject: [PATCH] fix(jpeg): Add check for jpeg marker parser in order to
 enhance safety

---
 .../include/driver/jpeg_types.h               |  2 +-
 components/esp_driver_jpeg/jpeg_encode.c      |  2 +-
 .../esp_driver_jpeg/jpeg_parse_marker.c       | 42 ++++++++++++++-----
 3 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/components/esp_driver_jpeg/include/driver/jpeg_types.h b/components/esp_driver_jpeg/include/driver/jpeg_types.h
index 6b53292185fa..5959e688f6b8 100644
--- a/components/esp_driver_jpeg/include/driver/jpeg_types.h
+++ b/components/esp_driver_jpeg/include/driver/jpeg_types.h
@@ -59,7 +59,7 @@ typedef enum {
     JPEG_ENCODE_IN_FORMAT_RGB565 = COLOR_TYPE_ID(COLOR_SPACE_RGB, COLOR_PIXEL_RGB565),       /*!< input RGB565 format */
     JPEG_ENCODE_IN_FORMAT_GRAY = COLOR_TYPE_ID(COLOR_SPACE_GRAY, COLOR_PIXEL_GRAY8),         /*!< input GRAY format */
     JPEG_ENCODE_IN_FORMAT_YUV422 = COLOR_TYPE_ID(COLOR_SPACE_YUV, COLOR_PIXEL_YUV422),       /*!< input YUV422 format */
-#if !(CONFIG_ESP_REV_MIN_FULL < 300 && SOC_IS(ESP32P4)) // Invisible for unsupported chips
+#if !(CONFIG_ESP_REV_MIN_FULL < 300 && CONFIG_IDF_TARGET_ESP32P4) // Invisible for unsupported chips
     JPEG_ENCODE_IN_FORMAT_YUV444 = COLOR_TYPE_ID(COLOR_SPACE_YUV, COLOR_PIXEL_YUV444),       /*!< input YUV444 format */
     JPEG_ENCODE_IN_FORMAT_YUV420 = COLOR_TYPE_ID(COLOR_SPACE_YUV, COLOR_PIXEL_YUV420),       /*!< input YUV420 format */
 #endif
diff --git a/components/esp_driver_jpeg/jpeg_encode.c b/components/esp_driver_jpeg/jpeg_encode.c
index c8a573f9f559..8107ea69da34 100644
--- a/components/esp_driver_jpeg/jpeg_encode.c
+++ b/components/esp_driver_jpeg/jpeg_encode.c
@@ -183,7 +183,7 @@ esp_err_t jpeg_encoder_process(jpeg_encoder_handle_t encoder_engine, const jpeg_
         encoder_engine->color_space = JPEG_ENC_SRC_YUV422;
         best_hb_idx = JPEG_ENC_SRC_YUV422_HB;
         break;
-#if !(CONFIG_ESP_REV_MIN_FULL < 300 && SOC_IS(ESP32P4))
+#if !(CONFIG_ESP_REV_MIN_FULL < 300 && CONFIG_IDF_TARGET_ESP32P4)
     case JPEG_ENCODE_IN_FORMAT_YUV444:
         encoder_engine->color_space = JPEG_ENC_SRC_YUV444;
         best_hb_idx = JPEG_ENC_SRC_YUV444_HB;
diff --git a/components/esp_driver_jpeg/jpeg_parse_marker.c b/components/esp_driver_jpeg/jpeg_parse_marker.c
index cafaabc9e326..4dcc607cb2b9 100644
--- a/components/esp_driver_jpeg/jpeg_parse_marker.c
+++ b/components/esp_driver_jpeg/jpeg_parse_marker.c
@@ -20,6 +20,11 @@ static const char *TAG = "jpeg.decoder";
 
 static uint8_t jpeg_get_char(jpeg_dec_header_info_t *header_info)
 {
+    // Check if there are bytes left to read before decrementing buffer_left
+    if (header_info->buffer_left == 0) {
+        ESP_LOGE(TAG, "Buffer underflow detected in jpeg_get_char: no more bytes left to read");
+        return 0;
+    }
     uint8_t c = header_info->buffer_offset[0];
     header_info->buffer_offset++;
     header_info->header_size++;
@@ -39,20 +44,26 @@ uint32_t jpeg_get_bytes(jpeg_dec_header_info_t *header_info, uint8_t num_bytes)
 
 esp_err_t jpeg_parse_appn_marker(jpeg_dec_header_info_t *header_info)
 {
-    uint32_t skip_num = jpeg_get_bytes(header_info, 2);
-    header_info->buffer_offset += (skip_num - 2);
-    header_info->header_size += (skip_num - 2);
-    header_info->buffer_left -= (skip_num - 2);
+    uint16_t skip_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(skip_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid APPn marker length: %d", skip_num);
+    uint16_t bytes_to_skip = skip_num - 2;
+    ESP_RETURN_ON_FALSE(header_info->buffer_left >= bytes_to_skip, ESP_ERR_INVALID_ARG, TAG, "APPn marker data underflow for buffer_left");
+    header_info->buffer_offset += bytes_to_skip;
+    header_info->header_size += bytes_to_skip;
+    header_info->buffer_left -= bytes_to_skip;
 
     return ESP_OK;
 }
 
 esp_err_t jpeg_parse_com_marker(jpeg_dec_header_info_t *header_info)
 {
-    uint32_t skip_num = jpeg_get_bytes(header_info, 2);
-    header_info->buffer_offset += (skip_num - 2);
-    header_info->header_size += (skip_num - 2);
-    header_info->buffer_left -= (skip_num - 2);
+    uint16_t skip_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(skip_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid COM marker length: %d", skip_num);
+    uint32_t bytes_to_skip = skip_num - 2;
+    ESP_RETURN_ON_FALSE(header_info->header_size >= bytes_to_skip, ESP_ERR_INVALID_ARG, TAG, "COM marker data underflow for header_size");
+    header_info->buffer_offset += bytes_to_skip;
+    header_info->header_size += bytes_to_skip;
+    header_info->buffer_left -= bytes_to_skip;
     return ESP_OK;
 }
 
@@ -61,21 +72,25 @@ esp_err_t jpeg_parse_dqt_marker(jpeg_dec_header_info_t *header_info)
     uint32_t n = 0, i = 0, prec = 0;
     uint32_t temp = 0;
 
-    uint32_t length_num = jpeg_get_bytes(header_info, 2);
+    uint16_t length_num = jpeg_get_bytes(header_info, 2);
+    ESP_RETURN_ON_FALSE(length_num >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid DQT marker length: %d", length_num);
     length_num -= 2;
 
     while (length_num) {
         n = jpeg_get_bytes(header_info, 1);
         prec = n >> 4;
         n &= 0x0F;
+        ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %d", length_num);
         length_num -= 1;
 
         // read quantization entries, in zig-zag order
         for (i = 0; i < 64; i++) {
             temp = jpeg_get_bytes(header_info, 1);
+            ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %d", length_num);
             length_num -= 1;
             if (prec) {
                 temp = (temp << 8) + jpeg_get_bytes(header_info, 1);
+                ESP_RETURN_ON_FALSE(length_num >= 1, ESP_ERR_INVALID_ARG, TAG, "DQT marker length error: %d", length_num);
                 length_num -= 1;
             }
             header_info->qt_tbl[n][zigzag_arr[i]] = temp;
@@ -142,7 +157,10 @@ esp_err_t jpeg_parse_sof_marker(jpeg_dec_header_info_t *header_info)
 esp_err_t jpeg_parse_dht_marker(jpeg_dec_header_info_t *header_info)
 {
     // Recording num_left in DHT sector, not including length bytes (2 bytes).
-    uint32_t num_left = jpeg_get_bytes(header_info, 2) - 2;
+    uint16_t raw_length = jpeg_get_bytes(header_info, 2);
+    // Check for integer underflow before subtraction
+    ESP_RETURN_ON_FALSE(raw_length >= 2, ESP_ERR_INVALID_ARG, TAG, "Invalid DHT marker length: %d", raw_length);
+    uint16_t num_left = raw_length - 2;
     while (num_left) {
         uint32_t np = 0;
 
@@ -159,6 +177,8 @@ esp_err_t jpeg_parse_dht_marker(jpeg_dec_header_info_t *header_info)
             header_info->huffcode[header_info->huffinfo.type][header_info->huffinfo.id][i] = jpeg_get_bytes(header_info, 1);
         }
 
+        // Check for integer underflow before subtraction
+        ESP_RETURN_ON_FALSE(num_left >= (JPEG_HUFFMAN_BITS_LEN_TABLE_LEN + np + 1), ESP_ERR_INVALID_ARG, TAG, "DHT marker data underflow after parsing huffcode: %d", num_left);
         num_left -= (1 + JPEG_HUFFMAN_BITS_LEN_TABLE_LEN + np);
     }
 
@@ -181,6 +201,7 @@ esp_err_t jpeg_parse_dri_marker(jpeg_dec_header_info_t *header_info)
 esp_err_t jpeg_parse_sos_marker(jpeg_dec_header_info_t *header_info)
 {
     // Got the SOS marker, but need to recover this and feed to 2DDMA.
+    ESP_RETURN_ON_FALSE(header_info->header_size >= 2, ESP_ERR_INVALID_ARG, TAG, "SOS marker header_size underflow");
     header_info->buffer_offset -= 2;
     header_info->header_size -= 2;
     header_info->buffer_left += 2;
@@ -191,6 +212,7 @@ esp_err_t jpeg_parse_inv_marker(jpeg_dec_header_info_t *header_info)
 {
     // Got invalid 0xFFFF, (followed by a valid marker type)
     // Go one byte back, to skip the first 0xFF
+    ESP_RETURN_ON_FALSE(header_info->header_size >= 1, ESP_ERR_INVALID_ARG, TAG, "INV marker header_size underflow");
     header_info->buffer_offset--;
     header_info->header_size--;
     header_info->buffer_left++;", "url": "https://github.com/espressif/esp-idf/commit/c79cb4de468854937a0cbf82629fd65d04bffb27.patch" } ]
CWE-125: Out-of-bounds Read
GHSA-hxcm-v35h-mg2x
Prototype Pollution in querystringify
null
[ { "commit_message": "[PATCH] [security] Prevent overriding of build-in properties by default (#19) [security] Prevent overriding of build-in properties by default .travis.yml | 9 +++------ index.js | 21 ++++++++++++--------- package.json | 8 ++++---- test.js | 8 ++++++++ 4 files changed, 27 insertions(+), 19 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/unshiftio/querystringify/commit/422eb4f6c7c28ee5f100dcc64177d3b68bb2b080.patch" } ]
null
GHSA-5xv5-wxfg-845r
null
[ { "commit_message": "[PATCH] scanner: don't crash on strings containing a NUL byte We crash if the input contains a string containing a NUL byte. Reported by Suhwan Song. https://lists.gnu.org/r/bug-bison/2020-07/msg00051.html * src/flex-scanner.h (STRING_FREE): Avoid accidental use of last_string. * src/scan-gram.l: Don't call STRING_FREE without calling STRING_FINISH first. * tests/input.at (Invalid inputs): Check that case. THANKS | 1 + src/flex-scanner.h | 10 +++++++++- src/scan-gram.l | 3 ++- tests/input.at | 48 ++++++++++++++++++++++++++++++++++++---------- 4 files changed, 50 insertions(+), 12 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/akimd/bison/commit/be95a4fe2951374676efc9454ffee8638faaf68d.patch" } ]
null