Described.typ = noy_wrap_typ(Described, Described.typ)
978759
def wrap_setup(self, class_name, typ, with_async=False):
        """"""
        equivalence = self.equivalence[typ]
        return [
              (NEWLINE, '\n')
            , (NAME, class_name)
            , (OP, '.')
            , (NAME, equivalence)
            , (OP, '=')
            , (NAME, "%snoy_wrap_%s" % ('async_' if with_async else '', equivalence))
            , (OP, "(")
            , (NAME, class_name)
            , (OP, ',')
            , (NAME, class_name)
            , (OP, '.')
            , (NAME, equivalence)
            , (OP, ")")
            ]
48978
function wrap(set) {
    return function (fn, time /* , ...args */) {
      var boundArgs = arguments.length > 2;
      var args = boundArgs ? slice.call(arguments, 2) : false;
      return set(boundArgs ? function () {
        // eslint-disable-next-line no-new-func
        (typeof fn == 'function' ? fn : Function(fn)).apply(this, args);
      } : fn, time);
    };
  }
1119649
function wrapGetOrSet(inherits, key, descriptor, gs, publicStatic) {
    if (hOP.call(descriptor, gs) && trustSuper(descriptor[gs])) {
      descriptor[gs] = wrap(
        gOPD(inherits, key),
        gs,
        descriptor[gs],
        publicStatic
      );
    }
  }
802181
def wrap_with type, content, options = {} #:nodoc:
      type_tag, type_html_options = apply_html type, options
      if type_tag
        @template.content_tag type_tag, content, type_html_options
      else
        content
      end
    end
855874
def wrap(error, method, path, params, request, response)

      class << error; attr_accessor :_details; end
      error._details = ErrorDetails.new(method, path, params, request, response)

      error
    end
980377
def description(text):
    

    def decorator(func):
        adaptor = ScriptAdaptor._get_adaptor(func)
        adaptor.description = text
        return func
    return decorator
143230
def complete_wrap(self, func, *args, **kwargs):
        
        # Workaround readline's one-time-read of terminal width.
        termcols = shutil.get_terminal_size()[0]
        readline.parse_and_bind('set completion-display-width %d' % termcols)
        try:
            return func(*args, **kwargs)
        except:
            traceback.print_exc()
            raise
1101109
def enum(description, **kwargs) -> typing.Type:
    
    kwargs['description'] = description
    return type('Enum', (Enum,), kwargs)
476010
function typof (v) {
  var s = Object.prototype.toString.call(v);
  return s.substring(8, s.length - 1).toLowerCase()
}
291602
def setDescription(self, desc='No description'):
        """"""
        try:
            self._put_named_file('description', desc)
        except Exception, e:
            raise RepoError(e)
1150819
def wrap(cls, meth):
        '''
        
        '''

        async def inner(*args, **kwargs):
            sock = await meth(*args, **kwargs)
            return cls(sock)

        return inner
145583
def with_wrapper(self, wrapper=None, name=None):
        
        name = name or '{}_custom_wrapper'.format(self.name)
        return self.__class__(self.data, name=name, wrapper=wrapper)
610123
def wrapped_attributes(list = {}, for_definition = false)
      return unless (bracket = accept :brackets)

      accept_newline
      attributes_assignments list, true, for_definition
      accept_newline

      accept_stripped bracket.to_sym, :*

      list
    end
1072522
def ensure_tuple(arg, len_=None):
    
    if not is_tuple(arg, len_=len_):
        len_part = "" if len_ is None else " of length %s" % len_
        raise TypeError(
            "expected tuple%s, got %s" % (len_part, _describe_type(arg)))
    return arg
901973
def p_description(self, p):
        ''
        p[0] = Description(definitions=p[1], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
111526
def _wrap(cls, func):
        

        if isinstance(func, cls):
            return func
        return functools.update_wrapper(cls(func), func)
1033128
function wrap(num, min, max) {
        return num - floor((num - min) / (max - min)) * (max - min)
    }