text: import sys
  import os, tempfile
  import errno
  from os import listdir
  from os.path import isfile, join
  import json
  import yaml
  
  def main():
      argv = sys.argv
  
      myfunctions = []
      for arg in argv[1:]:
          if is_path_exists_or_creatable(arg) and arg.endswith(".yml"):
              functionsdata = parse_yml_file(arg)
              myfunctions = myfunctions + functionsdata
          else:
              print("Argument " + arg + " is no a valid .yml file")
              return 1
  
      create_my_functions_file(myfunctions)
      return 0
  
  def parse_yml_file(filename) -> {}:
      functionsdata = []
  
      with open(filename, "r") as stream:
          try:
              function = yaml.load(stream)
              for key in function['functions']:
                  data = {}
                  data['name'] = key
                  data['address'] = "function/" + key
  
                  try:
                      data['cloudOnly'] = function['functions'][key]['extras']['cloudOnly']
                  except Exception as e:
                      data['cloudOnly'] = False
  
                  try:
                      data['localOnly'] = function['functions'][key]['extras']['localOnly']
                  except Exception as e:
                      data['localOnly'] = False
  
                  # print(data)
                  functionsdata.append(data)
          except yaml.YAMLError as exc:
              print(exc)
  
      return functionsdata
  
  def create_my_functions_file(myfunctions: []):
      directory = '.config'
      if not os.path.exists(directory):
          os.makedirs(directory)
      with open(directory +'/' + 'my_functions.json', 'w') as outfile:
          json.dump(myfunctions, outfile, indent=4)
  
  # Sadly, Python fails to provide the following magic number for us.
  ERROR_INVALID_NAME = 123
  
  '''
  Windows-specific error code indicating an invalid pathname.
  
  See Also
  ----------
  https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382%28v=vs.85%29.aspx
      Official listing of all such codes.
  '''
  
  def is_pathname_valid(pathname: str) -> bool:
      '''
      `True` if the passed pathname is a valid pathname for the current OS;
      `False` otherwise.
      '''
      # If this pathname is either not a string or is but is empty, this pathname
      # is invalid.
      try:
          if not isinstance(pathname, str) or not pathname:
              return False
  
          # Strip this pathname's Windows-specific drive specifier (e.g., `C:\`)
          # if any. Since Windows prohibits path components from containing `:`
          # characters, failing to strip this `:`-suffixed prefix would
          # erroneously invalidate all valid absolute Windows pathnames.
          _, pathname = os.path.splitdrive(pathname)
  
          # Directory guaranteed to exist. If the current OS is Windows, this is
          # the drive to which Windows was installed (e.g., the "%HOMEDRIVE%"
          # environment variable); else, the typical root directory.
          root_dirname = os.environ.get('HOMEDRIVE', 'C:') \
              if sys.platform == 'win32' else os.path.sep
          assert os.path.isdir(root_dirname)   # ...Murphy and her ironclad Law
  
          # Append a path separator to this directory if needed.
          root_dirname = root_dirname.rstrip(os.path.sep) + os.path.sep
  
          # Test whether each path component split from this pathname is valid or
          # not, ignoring non-existent and non-readable path components.
          for pathname_part in pathname.split(os.path.sep):
              try:
                  os.lstat(root_dirname + pathname_part)
              # If an OS-specific exception is raised, its error code
              # indicates whether this pathname is valid or not. Unless this
              # is the case, this exception implies an ignorable kernel or
              # filesystem complaint (e.g., path not found or inaccessible).
              #
              # Only the following exceptions indicate invalid pathnames:
              #
              # * Instances of the Windows-specific "WindowsError" class
              #   defining the "winerror" attribute whose value is
              #   "ERROR_INVALID_NAME". Under Windows, "winerror" is more
              #   fine-grained and hence useful than the generic "errno"
              #   attribute. When a too-long pathname is passed, for example,
              #   "errno" is "ENOENT" (i.e., no such file or directory) rather
              #   than "ENAMETOOLONG" (i.e., file name too long).
              # * Instances of the cross-platform "OSError" class defining the
              #   generic "errno" attribute whose value is either:
              #   * Under most POSIX-compatible OSes, "ENAMETOOLONG".
              #   * Under some edge-case OSes (e.g., SunOS, *BSD), "ERANGE".
              except OSError as exc:
                  if hasattr(exc, 'winerror'):
                      if exc.winerror == ERROR_INVALID_NAME:
                          return False
                  elif exc.errno in {errno.ENAMETOOLONG, errno.ERANGE}:
                      return False
      # If a "TypeError" exception was raised, it almost certainly has the
      # error message "embedded NUL character" indicating an invalid pathname.
      except TypeError as exc:
          return False
      # If no exception was raised, all path components and hence this
      # pathname itself are valid. (Praise be to the curmudgeonly python.)
      else:
          return True
      # If any other exception was raised, this is an unrelated fatal issue
      # (e.g., a bug). Permit this exception to unwind the call stack.
      #
      # Did we mention this should be shipped with Python already?
  
  def is_path_creatable(pathname: str) -> bool:
      '''
      `True` if the current user has sufficient permissions to create the passed
      pathname; `False` otherwise.
      '''
      # Parent directory of the passed path. If empty, we substitute the current
      # working directory (CWD) instead.
      dirname = os.path.dirname(pathname) or os.getcwd()
      return os.access(dirname, os.W_OK)
  
  def is_path_exists_or_creatable(pathname: str) -> bool:
      '''
      `True` if the passed pathname is a valid pathname for the current OS _and_
      either currently exists or is hypothetically creatable; `False` otherwise.
  
      This function is guaranteed to _never_ raise exceptions.
      '''
      try:
          # To prevent "os" module calls from raising undesirable exceptions on
          # invalid pathnames, is_pathname_valid() is explicitly called first.
          return is_pathname_valid(pathname) and (
              os.path.exists(pathname) or is_path_creatable(pathname))
      # Report failure on non-fatal filesystem complaints (e.g., connection
      # timeouts, permissions issues) implying this path to be inaccessible. All
      # other exceptions are unrelated fatal issues and should not be caught here.
      except OSError:
          return false
  
  if __name__ == "__main__":
      main()
  