code: def _select_properties(
      include_properties: Optional[List[str]] = None,
      ignore_properties: Optional[List[str]] = None,
      include_long_calculation_properties: bool = False,
  ) -> Sequence[TextProperty]:
      """Select properties to calculate based on provided parameters."""
      if (
          include_properties is not None
          and ignore_properties is not None
      ):
          raise ValueError(
              "Cannot use properties and ignore_properties parameters together."
          )
      if include_properties is not None:
          if not is_sequence_not_str(include_properties) and not all(
              isinstance(prop, str) for prop in include_properties
          ):
              raise DeepchecksValueError(
                  "include_properties must be a sequence of strings."
              )
      if ignore_properties is not None:
          if not is_sequence_not_str(ignore_properties) and not all(
              isinstance(prop, str) for prop in ignore_properties
          ):
              raise DeepchecksValueError(
                  "ignore_properties must be a sequence of strings."
              )
  
      include_properties = (
          [prop.lower() for prop in include_properties]
          if include_properties
          else None
      )
      ignore_properties = (
          [prop.lower() for prop in ignore_properties]
          if ignore_properties
          else None
      )
  
      if include_properties is not None:
          properties = [
              prop
              for prop in ALL_PROPERTIES
              if prop["name"].lower() in include_properties
          ]  # pylint: disable=unsupported-membership-test
          if len(properties) < len(include_properties):
              not_found_properties = sorted(
                  set(include_properties)
                  - set(prop["name"].lower() for prop in properties)
              )
              raise DeepchecksValueError(
                  "include_properties contains properties that were not found: "
                  f"{not_found_properties}."
              )
      elif ignore_properties is not None:
          properties = [
              prop
              for prop in DEFAULT_PROPERTIES
              if prop["name"].lower() not in ignore_properties
          ]  # pylint: disable=unsupported-membership-test
          if len(properties) + len(ignore_properties) != len(
              DEFAULT_PROPERTIES
          ):
              default_property_names = [
                  prop["name"].lower() for prop in DEFAULT_PROPERTIES
              ]
              not_found_properties = [
                  prop
                  for prop in list(ignore_properties)
                  if prop not in default_property_names
              ]
              raise DeepchecksValueError(
                  "ignore_properties contains properties that were not found: "
                  f"{not_found_properties}."
              )
      else:
          properties = DEFAULT_PROPERTIES
  
      # include_long_calculation_properties is only applicable when include_properties is None
      if (
          include_properties is None
          and not include_long_calculation_properties
      ):
          return [
              prop
              for prop in properties
              if prop["name"] not in LONG_RUN_PROPERTIES
          ]
  
      return properties
  
imports: import pathlib
  import pickle
  import re
  import string
  import warnings
  from collections import defaultdict
  from importlib.util import find_spec
  from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
  import numpy
  import pandas
  import textblob
  import torch.cuda
  from nltk import corpus
  from nltk import download
  from nltk import sent_tokenize, word_tokenize
  from tqdm import tqdm
  from typing_extensions import TypedDict
  from deepchecks.core.errors import DeepchecksValueError
  from deepchecks.nlp.utils.text import cut_string, hash_text, normalize_text, remove_punctuation
  from deepchecks.nlp.utils.text_properties_models import get_cmudict_dict, get_fasttext_model, get_transformer_pipeline
  from deepchecks.utils.function import run_available_kwargs
  from deepchecks.utils.strings import SPECIAL_CHARACTERS, format_list
  from deepchecks.utils.validation import is_sequence_not_str
label_desc: Use image node_id 31 for calling a global function with example usage: _select_properties(include_properties, ignore_properties, include_long_calculation_properties) and returns: properties, unknown