BELScriptWalker.g:353:1: document_property returns [BELDocumentProperty r] : (pv= 'Authors' | pv= 'ContactInfo' | pv= 'Copyright' | pv= 'Description' | pv= 'Disclaimer' | pv= 'Licenses' | pv= 'Name' | pv= 'Version' );
327145
public final BELScriptWalker.document_property_return document_property() throws RecognitionException {
        BELScriptWalker.document_property_return retval = new BELScriptWalker.document_property_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree pv=null;

        CommonTree pv_tree=null;

        try {
            // BELScriptWalker.g:353:50: (pv= 'Authors' | pv= 'ContactInfo' | pv= 'Copyright' | pv= 'Description' | pv= 'Disclaimer' | pv= 'Licenses' | pv= 'Name' | pv= 'Version' )
            int alt10=8;
            switch ( input.LA(1) ) {
            case 35:
                {
                alt10=1;
                }
                break;
            case 36:
                {
                alt10=2;
                }
                break;
            case 37:
                {
                alt10=3;
                }
                break;
            case 38:
                {
                alt10=4;
                }
                break;
            case 39:
                {
                alt10=5;
                }
                break;
            case 40:
                {
                alt10=6;
                }
                break;
            case 41:
                {
                alt10=7;
                }
                break;
            case 42:
                {
                alt10=8;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }

            switch (alt10) {
                case 1 :
                    // BELScriptWalker.g:354:5: pv= 'Authors'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pv=(CommonTree)match(input,35,FOLLOW_35_in_document_property420); 
                    pv_tree = (CommonTree)adaptor.dupNode(pv);

                    adaptor.addChild(root_0, pv_tree);

                    retval.r = BELDocumentProperty.getDocumentProperty(pv.getText());

                    }
                    break;
                case 2 :
                    // BELScriptWalker.g:355:5: pv= 'ContactInfo'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pv=(CommonTree)match(input,36,FOLLOW_36_in_document_property436); 
                    pv_tree = (CommonTree)adaptor.dupNode(pv);

                    adaptor.addChild(root_0, pv_tree);

                    retval.r = BELDocumentProperty.getDocumentProperty(pv.getText());

                    }
                    break;
                case 3 :
                    // BELScriptWalker.g:356:5: pv= 'Copyright'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pv=(CommonTree)match(input,37,FOLLOW_37_in_document_property448); 
                    pv_tree = (CommonTree)adaptor.dupNode(pv);

                    adaptor.addChild(root_0, pv_tree);

                    retval.r = BELDocumentProperty.getDocumentProperty(pv.getText());

                    }
                    break;
                case 4 :
                    // BELScriptWalker.g:357:5: pv= 'Description'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pv=(CommonTree)match(input,38,FOLLOW_38_in_document_property462); 
                    pv_tree = (CommonTree)adaptor.dupNode(pv);

                    adaptor.addChild(root_0, pv_tree);

                    retval.r = BELDocumentProperty.getDocumentProperty(pv.getText());

                    }
                    break;
                case 5 :
                    // BELScriptWalker.g:358:5: pv= 'Disclaimer'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pv=(CommonTree)match(input,39,FOLLOW_39_in_document_property474); 
                    pv_tree = (CommonTree)adaptor.dupNode(pv);

                    adaptor.addChild(root_0, pv_tree);

                    retval.r = BELDocumentProperty.getDocumentProperty(pv.getText());

                    }
                    break;
                case 6 :
                    // BELScriptWalker.g:359:5: pv= 'Licenses'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pv=(CommonTree)match(input,40,FOLLOW_40_in_document_property487); 
                    pv_tree = (CommonTree)adaptor.dupNode(pv);

                    adaptor.addChild(root_0, pv_tree);

                    retval.r = BELDocumentProperty.getDocumentProperty(pv.getText());

                    }
                    break;
                case 7 :
                    // BELScriptWalker.g:360:5: pv= 'Name'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pv=(CommonTree)match(input,41,FOLLOW_41_in_document_property502); 
                    pv_tree = (CommonTree)adaptor.dupNode(pv);

                    adaptor.addChild(root_0, pv_tree);

                    retval.r = BELDocumentProperty.getDocumentProperty(pv.getText());

                    }
                    break;
                case 8 :
                    // BELScriptWalker.g:361:5: pv= 'Version'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pv=(CommonTree)match(input,42,FOLLOW_42_in_document_property521); 
                    pv_tree = (CommonTree)adaptor.dupNode(pv);

                    adaptor.addChild(root_0, pv_tree);

                    retval.r = BELDocumentProperty.getDocumentProperty(pv.getText());

                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
220360
def get_unicode_property(value, prop=None, is_bytes=False):
    """"""

    if prop is not None:
        prop = unidata.unicode_alias['_'].get(prop, prop)
        try:
            if prop == 'generalcategory':
                return get_gc_property(value, is_bytes)
            elif prop == 'script':
                return get_script_property(value, is_bytes)
            elif prop == 'scriptextensions':
                return get_script_extension_property(value, is_bytes)
            elif prop == 'block':
                return get_block_property(value, is_bytes)
            elif prop == 'binary':
                return get_binary_property(value, is_bytes)
            elif prop == 'bidiclass':
                return get_bidi_property(value, is_bytes)
            elif prop == 'bidipairedbrackettype':
                return get_bidi_paired_bracket_type_property(value, is_bytes)
            elif prop == 'age':
                return get_age_property(value, is_bytes)
            elif prop == 'eastasianwidth':
                return get_east_asian_width_property(value, is_bytes)
            elif PY35 and prop == 'indicpositionalcategory':
                return get_indic_positional_category_property(value, is_bytes)
            elif not PY35 and prop == 'indicmatracategory':
                return get_indic_positional_category_property(value, is_bytes)
            elif prop == 'indicsyllabiccategory':
                return get_indic_syllabic_category_property(value, is_bytes)
            elif prop == 'hangulsyllabletype':
                return get_hangul_syllable_type_property(value, is_bytes)
            elif prop == 'decompositiontype':
                return get_decomposition_type_property(value, is_bytes)
            elif prop == 'canonicalcombiningclass':
                return get_canonical_combining_class_property(value, is_bytes)
            elif prop == 'numerictype':
                return get_numeric_type_property(value, is_bytes)
            elif prop == 'numericvalue':
                return get_numeric_value_property(value, is_bytes)
            elif prop == 'joiningtype':
                return get_joining_type_property(value, is_bytes)
            elif prop == 'joininggroup':
                return get_joining_group_property(value, is_bytes)
            elif prop == 'graphemeclusterbreak':
                return get_grapheme_cluster_break_property(value, is_bytes)
            elif prop == 'linebreak':
                return get_line_break_property(value, is_bytes)
            elif prop == 'sentencebreak':
                return get_sentence_break_property(value, is_bytes)
            elif prop == 'wordbreak':
                return get_word_break_property(value, is_bytes)
            elif prop == 'nfcquickcheck':
                return get_nfc_quick_check_property(value, is_bytes)
            elif prop == 'nfdquickcheck':
                return get_nfd_quick_check_property(value, is_bytes)
            elif prop == 'nfkcquickcheck':
                return get_nfkc_quick_check_property(value, is_bytes)
            elif prop == 'nfkdquickcheck':
                return get_nfkd_quick_check_property(value, is_bytes)
            elif PY37 and prop == 'verticalorientation':
                return get_vertical_orientation_property(value, is_bytes)
            else:
                raise ValueError('Invalid Unicode property!')
        except Exception:
            raise ValueError('Invalid Unicode property!')

    try:
        return get_gc_property(value, is_bytes)
    except Exception:
        pass

    try:
        return get_script_extension_property(value, is_bytes)
    except Exception:
        pass

    try:
        return get_block_property(value, is_bytes)
    except Exception:
        pass

    try:
        return get_binary_property(value, is_bytes)
    except Exception:
        pass

    try:
        return get_is_property(value, is_bytes)
    except Exception:
        pass

    try:
        return get_in_property(value, is_bytes)
    except Exception:
        pass

    raise ValueError('Invalid Unicode property!')
458251
def property name, prop
      return '' if EXCLUDE_PROPERTIES.include?(name.to_s) || prop.nil? || (prop.kind_of?(Array) && prop.empty?)
      
      prop = prop.flatten.map{|p| "'#{p}'"}.join(', ') if prop.respond_to?(:flatten) && name.to_sym != :folders
      prop = @paths.map{|f| "'#{f}'"}.join(',') if name.to_sym == :folders
      
      prop = "'#{prop.exec_rule}'" if prop.instance_of?(Syntaxer::Runner::ExecRule) && !prop.exec_rule.nil?
      prop = "Syntaxer::Runner.#{prop.language}" if prop.instance_of?(Syntaxer::Runner::ExecRule) && prop.exec_rule.nil?
      
      ' '*4 + "#{name.to_s} #{prop}\n"
    end
45035
def define_properties(obj, props):
    """"""
    cls = obj.__class__
    dct = {
        '__doc__': cls.__doc__
    }

    for name, defn in list(props.items()):
        if is_callable(defn):
            defn = property(defn)
        elif not hasattr(defn, '__get__'):
            defn = property(*defn)
        dct[name] = defn

    obj.__class__ = type(cls.__name__, (cls, ), dct)
826528
private HierarchicalProperty getProperty(Node node, QName name) throws PathNotFoundException, RepositoryException
   {
      Property property = node.getProperty(WebDavNamespaceContext.createName(name));
      String propertyValue;
      if (property.getDefinition().isMultiple())
      {
         if (property.getValues().length >= 1)
         {
            propertyValue = property.getValues()[0].getString();
         }
         else
         {
            // this means that we return empty value, because according to WebDAV spec:
            // this is a property whose semantics and syntax are not enforced by the server
            // the server only records the value of a dead property;
            // the client is responsible for maintaining the consistency of the syntax and semantics of a dead property. 
            propertyValue = "";
         }
      }
      else
      {
         propertyValue = property.getString();
      }
      return new HierarchicalProperty(name, propertyValue);
   }
1238830
@InterfaceAudience.Public
    public Map<String, Object> getDocumentProperties() {
        return documentRevision != null ? documentRevision.getProperties() : null;
    }
406239
async def serialize_property(value: 'Input[Any]',
                             deps: List['Resource'],
                             input_transformer: Optional[Callable[[str], str]] = None) -> Any:
    
    if isinstance(value, list):
        props = []
        for elem in value:
            props.append(await serialize_property(elem, deps, input_transformer))

        return props

    if known_types.is_custom_resource(value):
        deps.append(value)
        return await serialize_property(value.id, deps, input_transformer)

    if known_types.is_asset(value):
        # Serializing an asset requires the use of a magical signature key, since otherwise it would look
        # like any old weakly typed object/map when received by the other side of the RPC boundary.
        obj = {
            _special_sig_key: _special_asset_sig
        }

        if hasattr(value, "path"):
            obj["path"] = await serialize_property(value.path, deps, input_transformer)
        elif hasattr(value, "text"):
            obj["text"] = await serialize_property(value.text, deps, input_transformer)
        elif hasattr(value, "uri"):
            obj["uri"] = await serialize_property(value.uri, deps, input_transformer)
        else:
            raise AssertionError(f"unknown asset type: {value}")

        return obj

    if known_types.is_archive(value):
        # Serializing an archive requires the use of a magical signature key, since otherwise it would look
        # like any old weakly typed object/map when received by the other side of the RPC boundary.
        obj = {
            _special_sig_key: _special_archive_sig
        }

        if hasattr(value, "assets"):
            obj["assets"] = await serialize_property(value.assets, deps, input_transformer)
        elif hasattr(value, "path"):
            obj["path"] = await serialize_property(value.path, deps, input_transformer)
        elif hasattr(value, "uri"):
            obj["uri"] = await serialize_property(value.uri, deps, input_transformer)
        else:
            raise AssertionError(f"unknown archive type: {value}")

        return obj

    if inspect.isawaitable(value):
        # Coroutines and Futures are both awaitable. Coroutines need to be scheduled.
        # asyncio.ensure_future returns futures verbatim while converting coroutines into
        # futures by arranging for the execution on the event loop.
        #
        # The returned future can then be awaited to yield a value, which we'll continue
        # serializing.
        future_return = await asyncio.ensure_future(value)
        return await serialize_property(future_return, deps, input_transformer)

    if known_types.is_output(value):
        deps.extend(value.resources())

        # When serializing an Output, we will either serialize it as its resolved value or the "unknown value"
        # sentinel. We will do the former for all outputs created directly by user code (such outputs always
        # resolve isKnown to true) and for any resource outputs that were resolved with known values.
        is_known = await value._is_known
        value = await serialize_property(value.future(), deps, input_transformer)
        return value if is_known else UNKNOWN

    if isinstance(value, dict):
        obj = {}
        for k, v in value.items():
            transformed_key = k
            if input_transformer is not None:
                transformed_key = input_transformer(k)
                log.debug(f"transforming input property: {k} -> {transformed_key}")
            obj[transformed_key] = await serialize_property(v, deps, input_transformer)

        return obj

    return value
792691
def get_property(self):
        """"""

        prop = super(File, self).get_property()

        # scope is the Property instance
        scope = self

        def fdel(self):
            """Set value to utils.undefined on delete"""
            if self._get(scope.name) is not None:
                self._get(scope.name).close()
            self._set(scope.name, undefined)

        new_prop = property(fget=prop.fget, fset=prop.fset,
                            fdel=fdel, doc=scope.sphinx())
        return new_prop
355746
function(property) {
            var memo = {};

            $.getCssPropertyWithVendorPrefix = function(property) {
                if (memo[property] !== undefined) {
                    return memo[property];
                }
                var style = document.createElement('div').style;
                var result = null;
                if (style[property] !== undefined) {
                    result = property;
                } else {
                    var prefixes = ['Webkit', 'Moz', 'MS', 'O',
                        'webkit', 'moz', 'ms', 'o'];
                    var suffix = $.capitalizeFirstLetter(property);
                    for (var i = 0; i < prefixes.length; i++) {
                        var prop = prefixes[i] + suffix;
                        if (style[prop] !== undefined) {
                            result = prop;
                            break;
                        }
                    }
                }
                memo[property] = result;
                return result;
            };
            return $.getCssPropertyWithVendorPrefix(property);
        }
139561
public String getDocid() {
    if (Document_Type.featOkTst && ((Document_Type)jcasType).casFeat_docid == null)
      jcasType.jcas.throwFeatMissing("docid", "de.julielab.jules.types.ace.Document");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Document_Type)jcasType).casFeatCode_docid);}
712072
def propinfo(cls, value, prop, visitor):
        
        if not prop:
            return {"name": value.__name__}

        rv = {"name": prop.name}
        if prop.valuetype:
            if isinstance(prop.valuetype, tuple):
                rv['type'] = [typ.__name__ for typ in prop.valuetype]
            else:
                rv['type'] = prop.valuetype.__name__
        return rv
724435
def get_gc_property(value, is_bytes=False):
    """"""

    obj = unidata.ascii_properties if is_bytes else unidata.unicode_properties

    if value.startswith('^'):
        negate = True
        value = value[1:]
    else:
        negate = False

    value = unidata.unicode_alias['generalcategory'].get(value, value)

    assert 1 <= len(value) <= 2, 'Invalid property!'

    if not negate:
        p1, p2 = (value[0], value[1]) if len(value) > 1 else (value[0], None)
        value = ''.join(
            [v for k, v in obj.get(p1, {}).items() if not k.startswith('^')]
        ) if p2 is None else obj.get(p1, {}).get(p2, '')
    else:
        p1, p2 = (value[0], value[1]) if len(value) > 1 else (value[0], '')
        value = obj.get(p1, {}).get('^' + p2, '')
    assert value, 'Invalid property!'
    return value
1356857
public static String convertDocumentToFormattedString(final Document doc, final XMLFormatProperties xmlFormatProperties) {
        return convertDocumentToFormattedString(doc, xmlFormatProperties, true);
    }
652928
function getSortingPropertyName(property) {
  if (property.type === 'ExperimentalSpreadProperty') {
    return `...${property.argument.name}`;
  }

  if (property.key.type === 'Literal') {
    return property.key.value;
  }

  if (property.key.type === 'Identifier') {
    return `${property.key.name}`;
  }
}
962370
def doc(self):
        """"""
        return self._pv.doc or inspect.getdoc(
            getattr(type(self._target), self._pv.property, None)) or ''
393491
def getProperty(self, orgresource, dummy = 56184):
        

        url = nurls['getProperty']

        data = {'userid': self.user_id,
                'useridx': self.useridx,
                'dummy': dummy,
                'orgresource': orgresource,
                }

        r = self.session.post(url = url, data = data)
        j = json.loads(r.text)

        if self.resultManager(r.text):
            f = FileInfo()
            result = j['resultvalue']

            f.resourcetype = result['resourcetype']
            f.resourceno = result['resourceno']

            return f

        else:
            return False
18549
function checkMetaDocsDescription(context, exportsNode) {
    if (exportsNode.type !== "ObjectExpression") {

        // if the exported node is not the correct format, "internal-no-invalid-meta" will already report this.
        return;
    }

    const metaProperty = getPropertyFromObject("meta", exportsNode);
    const metaDocs = metaProperty && getPropertyFromObject("docs", metaProperty.value);
    const metaDocsDescription = metaDocs && getPropertyFromObject("description", metaDocs.value);

    if (!metaDocsDescription) {

        // if there is no `meta.docs.description` property, "internal-no-invalid-meta" will already report this.
        return;
    }

    const description = metaDocsDescription.value.value;

    if (typeof description !== "string") {
        context.report({
            node: metaDocsDescription.value,
            message: "`meta.docs.description` should be a string."
        });
        return;
    }

    if (description === "") {
        context.report({
            node: metaDocsDescription.value,
            message: "`meta.docs.description` should not be empty."
        });
        return;
    }

    if (description.indexOf(" ") === 0) {
        context.report({
            node: metaDocsDescription.value,
            message: "`meta.docs.description` should not start with whitespace."
        });
        return;
    }

    const firstWord = description.split(" ")[0];

    if (ALLOWED_FIRST_WORDS.indexOf(firstWord) === -1) {
        context.report({
            node: metaDocsDescription.value,
            message: "`meta.docs.description` should start with one of the following words: {{ allowedWords }}. Started with \"{{ firstWord }}\" instead.",
            data: {
                allowedWords: ALLOWED_FIRST_WORDS.join(", "),
                firstWord
            }
        });
    }
}