[Please add a description.]
425175
function toExpression(node) {
  if (t.isExpressionStatement(node)) {
    node = node.expression;
  }

  if (t.isClass(node)) {
    node.type = "ClassExpression";
  } else if (t.isFunction(node)) {
    node.type = "FunctionExpression";
  }

  if (t.isExpression(node)) {
    return node;
  } else {
    throw new Error("cannot turn " + node.type + " to an expression");
  }
}
1072919
def summary(self, summary):
        """"""
        if summary is not None:
            if summary == 'Clear':
                click.secho("""

   ________                    \  |  /
  / ____/ /__  ____ ______       .-.
 / /   / / _ \/ __ `/ ___/    ‒ (   ) ‒
/ /___/ /  __/ /_/ / /           `-᾿
\____/_/\___/\__,_/_/          /  |  \\

                """, fg=self.colors.YELLOW)
                click.echo()

            elif summary == 'Partly Cloudy':
                click.secho("""

    ____             __  __         ________                __
   / __ \____ ______/ /_/ /_  __   / ____/ /___  __  ______/ /_  __    \  |  /
  / /_/ / __ `/ ___/ __/ / / / /  / /   / / __ \/ / / / __  / / / /      .-.
 / ____/ /_/ / /  / /_/ / /_/ /  / /___/ / /_/ / /_/ / /_/ / /_/ /    ‒ (  .-.
/_/    \__,_/_/   \__/_/\__, /   \____/_/\____/\__,_/\__,_/\__, /        `(   ).
                       /____/                             /____/       / (___(__)

                """, fg=self.colors.WHITE)

            elif summary == 'Flurries':
                click.secho("""

    ________                _                  .--.
   / ____/ /_  ____________(_)__  _____     .-(    ).
  / /_  / / / / / ___/ ___/ / _ \/ ___/    (___.__)__)
 / __/ / / /_/ / /  / /  / /  __(__  )      *      *
/_/   /_/\__,_/_/  /_/  /_/\___/____/          *

                """, fg=self.colors.BLUE)
                click.echo()

            elif summary == 'Overcast' or summary == 'Mostly Cloudy':
                click.secho("""

   ____                                  __
  / __ \_   _____  ______________ ______/ /_       .--.
 / / / / | / / _ \/ ___/ ___/ __ `/ ___/ __/     .(    ).-.
/ /_/ /| |/ /  __/ /  / /__/ /_/ (__  ) /_      (___.__(   ).
\____/ |___/\___/_/   \___/\__,_/____/\__/            (___(__)

                """, fg=self.colors.WHITE)
                click.echo()

            elif summary == 'Snow':
                click.secho("""

   _____                            .--.
  / ___/____  ____ _      __     .-(    ).
  \__ \/ __ \/ __ \ | /| / /    (___.__)__)
 ___/ / / / / /_/ / |/ |/ /      *   *   *
/____/_/ /_/\____/|__/|__/         *   *

                """, fg=self.colors.BLUE)
                click.echo()

            elif summary == 'Light Snow':
                click.secho("""

    __    _       __    __    _____
   / /   (_)___ _/ /_  / /_  / ___/____  ____ _      __       .--.
  / /   / / __ `/ __ \/ __/  \__ \/ __ \/ __ \ | /| / /    .-(    ).
 / /___/ / /_/ / / / / /_   ___/ / / / / /_/ / |/ |/ /    (___.__)__)
/_____/_/\__, /_/ /_/\__/  /____/_/ /_/\____/|__/|__/       *  *  *
        /____/
                """, fg=self.colors.BLUE)
                click.echo()

            elif summary == 'Light Rain' or summary == 'Drizzle':
                click.secho("""

    __    _       __    __     ____        _
   / /   (_)___ _/ /_  / /_   / __ \____ _(_)___       .--.
  / /   / / __ `/ __ \/ __/  / /_/ / __ `/ / __ \   .-(    ).
 / /___/ / /_/ / / / / /_   / _, _/ /_/ / / / / /  (___.__)__)
/_____/_/\__, /_/ /_/\__/  /_/ |_|\__,_/_/_/ /_/     /  /  /
        /____/

                """, fg=self.colors.BLUE)

            elif summary == 'Rain':
                click.secho("""

    ____        _
   / __ \____ _(_)___       .--.
  / /_/ / __ `/ / __ \   .-(    ).
 / _, _/ /_/ / / / / /  (___.__)__)
/_/ |_|\__,_/_/_/ /_/     /  /  /

                """, fg=self.colors.BLUE)

            else:
                click.secho("{:=^62}".format(str(summary)), fg=self.colors.GREEN)
506917
def set_description(self, description):
        """"""
        self.head.description.attr(content=description)
        return self
613823
def describe(self, context=None, printout=True):
        
        if context is None:
            frame = inspect.currentframe().f_back
            context = dict(frame.f_globals, **frame.f_locals)
            del frame
        if self.full_table_name not in self.connection.dependencies:
            self.connection.dependencies.load()
        parents = self.parents()
        in_key = True
        definition = ('# ' + self.heading.table_info['comment'] + '\n'
                      if self.heading.table_info['comment'] else '')
        attributes_thus_far = set()
        attributes_declared = set()
        indexes = self.heading.indexes.copy()
        for attr in self.heading.attributes.values():
            if in_key and not attr.in_key:
                definition += '---\n'
                in_key = False
            attributes_thus_far.add(attr.name)
            do_include = True
            for parent_name, fk_props in list(parents.items()):  # need list() to force a copy
                if attr.name in fk_props['attr_map']:
                    do_include = False
                    if attributes_thus_far.issuperset(fk_props['attr_map']):
                        parents.pop(parent_name)
                        # foreign key properties
                        try:
                            index_props = indexes.pop(tuple(fk_props['attr_map']))
                        except KeyError:
                            index_props = ''
                        else:
                            index_props = [k for k, v in index_props.items() if v]
                            index_props = ' [{}]'.format(', '.join(index_props)) if index_props else ''

                        if not parent_name.isdigit():
                            # simple foreign key
                            definition += '->{props} {class_name}\n'.format(
                                props=index_props,
                                class_name=lookup_class_name(parent_name, context) or parent_name)
                        else:
                            # projected foreign key
                            parent_name = list(self.connection.dependencies.in_edges(parent_name))[0][0]
                            lst = [(attr, ref) for attr, ref in fk_props['attr_map'].items() if ref != attr]
                            definition += '->{props} {class_name}.proj({proj_list})\n'.format(
                                attr_list=', '.join(r[0] for r in lst),
                                props=index_props,
                                class_name=lookup_class_name(parent_name, context) or parent_name,
                                proj_list=','.join('{}="{}"'.format(a,b) for a, b in lst))
                            attributes_declared.update(fk_props['attr_map'])
            if do_include:
                attributes_declared.add(attr.name)
                name = attr.name.lstrip('_')  # for external
                definition += '%-20s : %-28s %s\n' % (
                    name if attr.default is None else '%s=%s' % (name, attr.default),
                    '%s%s' % (attr.type, ' auto_increment' if attr.autoincrement else ''),
                    '# ' + attr.comment if attr.comment else '')
        # add remaining indexes
        for k, v in indexes.items():
            definition += '{unique}INDEX ({attrs})\n'.format(
                unique='UNIQUE ' if v['unique'] else '',
                attrs=', '.join(k))
        if printout:
            print(definition)
        return definition
955827
def description(self):
    ""
    if self.lastx is None: return
    if type(self.lastx) not in (sqparse2.SelectX,sqparse2.UpdateX,sqparse2.InsertX): return
    if type(self.lastx) in (sqparse2.UpdateX,sqparse2.InsertX) and self.lastx.ret is None: return
    # at this point we know this is an operation that returns rows
    if type(self.lastx) in (sqparse2.UpdateX,sqparse2.InsertX):
      raise NotImplementedError('todo: Cursor.description for non-select')
    else: # select case
      return [description_from_colx(self.connection,self.lastx,colx) for colx in self.lastx.cols.children]
17077
def description(self):
        """"""
        result = ""
        if isinstance(self._element, ValueElement):
            if self._element.kind is not None:
                result = "{}({}) | {}".format(self._element.dtype, self._element.kind,
                                          self._element.summary)
            else:
                result = "{} | {}".format(self._element.dtype,
                                          self._element.summary)
        elif isinstance(self._element, Executable):
            result = "({})".format(self._element.parameters_as_string())
        elif isinstance(self._element, str):
            result = "Intrinsic Fortran Symbol"
        elif isinstance(self._element, TypeExecutable):
            result = self._type_description()

        #Clean off any line breaks from the XML and excessive whitespace.
        cleaned = re.sub("\s+", " ", result.replace("\n", " "))
        return cleaned
660045
function describe(ctx) {
  try {
    return ctx.operation.spec.method + ' ' +
      ctx.operation.resource.spec.path + ' ';
  } catch (err) {
    return '';
  }
}
834655
def applet_describe(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/describe' % object_id, input_params, always_retry=always_retry, **kwargs)
338269
def add_item(self, item):
        
        item.parent = self
        #self.phrases[phrase.description] = phrase
        self.items.append(item)
1147872
def description(self, request, tag):
        
        if self.parameter.description is not None:
            tag[self.parameter.description]
        return tag
380770
def add_image_description(self, dict):
        """"""
        if self._ef is not None:
            self._ef['0th'][piexif.ImageIFD.ImageDescription] = json.dumps(
                dict)
233235
def describe(self):
        
        result = {}
        #Because we created an Instance object, we already know that this object
        #is not one of the regular built-in types (except, perhaps, for list,
        #dict and set objects that can have their tracking turned on).

        #For objects that are instantiated by the user in __main__, we will
        #already have a paper trail that shows exactly how it was done; but for
        #these, we have to rely on human-specified descriptions.
        from acorn.logging.descriptors import describe
        return describe(self.obj)
341261
function (description, errdesc) {

        //TODO: errdesc is a bit vague
        var desc = {
            description : description
        };
        if (errdesc) {
            if (errdesc.line) { // Integers
                desc.line = errdesc.line;
                desc.column = errdesc.column;
            }
            if (errdesc.code) { // String
                desc.code = errdesc.code;
            }
            if (errdesc.suberrors) { // Array of String
                desc.suberrors = errdesc.suberrors;
            }
        }
        this.errors.push(desc);
    }
484386
function Description(def) {
  if(typeof def === 'string') {
    this.parse(def);
  }else if(def
    && typeof def === 'object'
    && typeof def.txt === 'string'
    && typeof def.md === 'string') {
    this.md = def.md;
    this.txt = def.txt;
  }else{
    throw new Error('invalid value for description');
  }
}
291602
def setDescription(self, desc='No description'):
        """"""
        try:
            self._put_named_file('description', desc)
        except Exception, e:
            raise RepoError(e)
533364
function(location, line, description, enabled) {
        this.location = location;
        this.line = line;
        this.description = description;
        this.enabled = enabled;
    }
771986
public void addDescription(String desc) {
		XmpArray array = new XmpArray(XmpArray.ALTERNATIVE);
		array.add(desc);
		setProperty(DESCRIPTION, array);
	}