code: def _sanitize_url(url, max_length):
      """Sanitize and shorten url to fit in max_length.
  
      Function is stable: same input MUST ALWAYS give same result, accros changes
      in code as well. Different URLs might give same result.
      As much as possible, the extension should be kept.
  
      Heuristics are applied to only keep useful info from url.
  
      1- Drop generic [sub]domains.
        'www.cs.toronto.edu/...' -> 'cs.toronto.edu/...'
        'storage.googleapis.com/foo/...' -> 'foo/...'
        'drive.google.com/bar/...' -> 'bar/...'
        'github.com/baz/...' -> 'baz/...'
  
      2- Remove leading '0's from url components:
        'foo/train-00004-of-00010.tfrecords' -> 'foo/train-4-of-10.tfrecords'
  
      3- Truncate each component of url until total size fits or each component is
         left with 4 chars (or total size is <= limit):
         'MoveUnitToBorder_64x64_png/train-4-of-10.tfrecords'
         (here truncate components to 4 chars per component max)
          -> 'Move_64x6_png/trai-4-of-10.tfrecords'
  
      4- Truncate result, keeping prefix: 'abc_def_ghi_jkl' -> 'abc_def'
  
      Args:
        url: string, url to sanitize and shorten.
        max_length: int, max length of result.
  
      Returns:
        (string, string): sanitized and shorted url, file extension.
      """
      url = urllib.parse.urlparse(url)
      netloc = url.netloc
      for prefix in _NETLOC_COMMON_PREFIXES:
          if netloc.startswith(prefix):
              netloc = netloc[len(prefix) :]
      for suffix in _NETLOC_COMMON_SUFFIXES:
          if netloc.endswith(suffix):
              netloc = netloc[: -len(suffix)]
      url = "%s%s%s%s" % (netloc, url.path, url.params, url.query)
      # Get the extension:
      for ext in _KNOWN_EXTENSIONS:
          if url.endswith(ext):
              extension = ext
              url = url[: -len(extension)]
              break
      else:
          url, extension = os.path.splitext(url)
      max_length -= len(extension)
      # Replace non authorized chars (including '/') by '_':
      url = re.sub(r"[^a-zA-Z0-9\.\-_]+", "_", url)
      # Remove parts with no info:
      for common_part in _URL_COMMON_PARTS:
          url = url.replace(common_part, "_")
      url = url.strip("_")
      # Remove leading zeros in groups of numbers:
      url = re.sub("(?<![0-9])0+(?=[0-9])", "", url)
      # Decrease max size of URL components:
      c_size = max(len(c) for c in re.split(r"[\.\-_]", url))
      while c_size > 4 and len(url) > max_length:
          c_size -= 1
          url = re.sub(
              r"[^\.\-_]{4,}",
              lambda match: match.group(0)[:c_size],
              url,
          )
      return url[:max_length], extension
  
imports: import base64
  import codecs
  import enum
  import hashlib
  import itertools
  import json
  import os
  import re
  from typing import Any, Optional
  from etils import epath
  from six.moves import urllib
  from tensorflow_datasets.core import utils
  from tensorflow_datasets.core.download import checksums
  from tensorflow_datasets.core.utils.lazy_imports_utils import tensorflow
label_desc: Use image node_id 3 for calling a global function with example usage: _sanitize_url(url, max_length) and returns: url,  extension