text: import mimetypes
  from typing import Optional
  
  from great_expectations.core.expectation_configuration import ExpectationConfiguration
  from great_expectations.execution_engine import PandasExecutionEngine
  from great_expectations.expectations.expectation import ColumnMapExpectation
  from great_expectations.expectations.metrics import (
      ColumnMapMetricProvider,
      column_condition_partial,
  )
  
  
  # This method infers the MIME type of a file based on its filename, path, or URL
  def is_valid_mime(url: str) -> bool:
      mime_type, _ = mimetypes.guess_type(url)
      return mime_type is not None
  
  
  # This class defines a Metric to support your Expectation.
  # For most ColumnMapExpectations, the main business logic for calculation will live in this class.
  class ColumnValuesToBeValidMIME(ColumnMapMetricProvider):
  
      # This is the id string that will be used to reference your metric.
      condition_metric_name = "column_values.valid_mime"
  
      # This method implements the core logic for the PandasExecutionEngine
      @column_condition_partial(engine=PandasExecutionEngine)
      def _pandas(cls, column, **kwargs):
          return column.apply(lambda x: is_valid_mime(x))
  
      # This method defines the business logic for evaluating your metric when using a SqlAlchemyExecutionEngine
      # @column_condition_partial(engine=SqlAlchemyExecutionEngine)
      # def _sqlalchemy(cls, column, _dialect, **kwargs):
      #     raise NotImplementedError
  
      # This method defines the business logic for evaluating your metric when using a SparkDFExecutionEngine
      # @column_condition_partial(engine=SparkDFExecutionEngine)
      # def _spark(cls, column, **kwargs):
      #     raise NotImplementedError
  
  
  # This class defines the Expectation itself
  class ExpectColumnValuesToBeValidMIME(ColumnMapExpectation):
      """This Expectation validates data as conforming to the valid MIME type format."""
  
      # These examples will be shown in the public gallery.
      # They will also be executed as unit tests for your Expectation.
      examples = [
          {
              "data": {
                  "well_formed_mime": [
                      "https://docs.python.org/3/library/platform.html",
                      "Deep Learning.pdf",
                      "docs.zip",
                      "secret_data.csv",
                      "sitemap.xml",
                      "Videos/awesome_presentation.mp4",
                  ],
                  "malformed_mime": [
                      "https://docs.python.org/3/library/platform",
                      "Deep Learning.",
                      "zip.docs",
                      "secret_data.undefined",
                      "Videos/awesome_presentation.mp8",
                      "This is not a mime type resource.",
                  ],
              },
              "tests": [
                  {
                      "title": "basic_positive_test",
                      "exact_match_out": False,
                      "include_in_gallery": True,
                      "in": {"column": "well_formed_mime"},
                      "out": {"success": True},
                  },
                  {
                      "title": "basic_negative_test",
                      "exact_match_out": False,
                      "include_in_gallery": True,
                      "in": {"column": "malformed_mime"},
                      "out": {"success": False},
                  },
              ],
          }
      ]
  
      # This is the id string of the Metric used by this Expectation.
      # For most Expectations, it will be the same as the `condition_metric_name` defined in your Metric class above.
      map_metric = "column_values.valid_mime"
  
      # This is a list of parameter names that can affect whether the Expectation evaluates to True or False
      success_keys = ("mostly",)
  
      # This dictionary contains default values for any parameters that should have default values
      default_kwarg_values = {}
  
      def validate_configuration(
          self, configuration: Optional[ExpectationConfiguration]
      ) -> None:
          """
          Validates that a configuration has been set, and sets a configuration if it has yet to be set. Ensures that
          necessary configuration arguments have been provided for the validation of the expectation.
          Args:
              configuration (OPTIONAL[ExpectationConfiguration]): \
                  An optional Expectation Configuration entry that will be used to configure the expectation
          Returns:
              None. Raises InvalidExpectationConfigurationError if the config is not validated successfully
          """
  
          super().validate_configuration(configuration)
          if configuration is None:
              configuration = self.configuration
  
          # # Check other things in configuration.kwargs and raise Exceptions if needed
          # try:
          #     assert (
          #         ...
          #     ), "message"
          #     assert (
          #         ...
          #     ), "message"
          # except AssertionError as e:
          #     raise InvalidExpectationConfigurationError(str(e))
  
      # This object contains metadata for display in the public Gallery
      library_metadata = {
          "maturity": "experimental",
          "tags": ["experimental", "hackathon", "typed-entities"],
          "contributors": [
              "@voidforall",
          ],
      }
  
  
  if __name__ == "__main__":
      ExpectColumnValuesToBeValidMIME().print_diagnostic_checklist()
  