This file is indexed.

/usr/lib/python2.7/dist-packages/PyLD-0.6.2.egg-info is in python-pyld 0.6.8-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
Metadata-Version: 1.1
Name: PyLD
Version: 0.6.2
Summary: Python implementation of the JSON-LD API
Home-page: http://github.com/digitalbazaar/pyld
Author: Digital Bazaar
Author-email: support@digitalbazaar.com
License: BSD 3-Clause license
Description: PyLD
        ====
        
        .. image:: https://travis-ci.org/digitalbazaar/pyld.png?branch=master
           :target: https://travis-ci.org/digitalbazaar/pyld
           :alt: Build Status
        
        Introduction
        ------------
        
        This library is an implementation of the JSON-LD_ specification in Python_.
        
        JSON, as specified in RFC7159_, is a simple language for representing
        objects on the Web. Linked Data is a way of describing content across
        different documents or Web sites. Web resources are described using
        IRIs, and typically are dereferencable entities that may be used to find
        more information, creating a "Web of Knowledge". JSON-LD_ is intended
        to be a simple publishing method for expressing not only Linked Data in
        JSON, but for adding semantics to existing JSON.
        
        JSON-LD is designed as a light-weight syntax that can be used to express
        Linked Data. It is primarily intended to be a way to express Linked Data
        in JavaScript and other Web-based programming environments. It is also
        useful when building interoperable Web Services and when storing Linked
        Data in JSON-based document storage engines. It is practical and
        designed to be as simple as possible, utilizing the large number of JSON
        parsers and existing code that is in use today. It is designed to be
        able to express key-value pairs, RDF data, RDFa_ data,
        Microformats_ data, and Microdata_. That is, it supports every
        major Web-based structured data model in use today.
        
        The syntax does not require many applications to change their JSON, but
        easily add meaning by adding context in a way that is either in-band or
        out-of-band. The syntax is designed to not disturb already deployed
        systems running on JSON, but provide a smooth migration path from JSON
        to JSON with added semantics. Finally, the format is intended to be fast
        to parse, fast to generate, stream-based and document-based processing
        compatible, and require a very small memory footprint in order to operate.
        
        Requirements
        ------------
        
        - Python_ (2.7 or later)
        
        Installation
        ------------
        
        PyLD can be installed with pip_:
        
        .. code-block:: bash
        
            pip install PyLD
        
        Quick Examples
        --------------
        
        .. code-block:: Python
        
            from pyld import jsonld
            import json
        
            doc = {
                "http://schema.org/name": "Manu Sporny",
                "http://schema.org/url": {"@id": "http://manu.sporny.org/"},
                "http://schema.org/image": {"@id": "http://manu.sporny.org/images/manu.png"}
            }
        
            context = {
                "name": "http://schema.org/name",
                "homepage": {"@id": "http://schema.org/url", "@type": "@id"},
                "image": {"@id": "http://schema.org/image", "@type": "@id"}
            }
        
            # compact a document according to a particular context
            # see: http://json-ld.org/spec/latest/json-ld/#compacted-document-form
            compacted = jsonld.compact(doc, context)
        
            print(json.dumps(compacted, indent=2))
            # Output:
            # {
            #   "@context": {...},
            #   "image": "http://manu.sporny.org/images/manu.png",
            #   "homepage": "http://manu.sporny.org/",
            #   "name": "Manu Sporny"
            # }
        
            # compact using URLs
            jsonld.compact('http://example.org/doc', 'http://example.org/context')
        
            # expand a document, removing its context
            # see: http://json-ld.org/spec/latest/json-ld/#expanded-document-form
            expanded = jsonld.expand(compacted)
        
            print(json.dumps(expanded, indent=2))
            # Output:
            # [{
            #   "http://schema.org/image": [{"@id": "http://manu.sporny.org/images/manu.png"}],
            #   "http://schema.org/name": [{"@value": "Manu Sporny"}],
            #   "http://schema.org/url": [{"@id": "http://manu.sporny.org/"}]
            # }]
        
            # expand using URLs
            jsonld.expand('http://example.org/doc')
        
            # flatten a document
            # see: http://json-ld.org/spec/latest/json-ld/#flattened-document-form
            flattened = jsonld.flatten(doc)
            # all deep-level trees flattened to the top-level
        
            # frame a document
            # see: http://json-ld.org/spec/latest/json-ld-framing/#introduction
            framed = jsonld.frame(doc, frame)
            # document transformed into a particular tree structure per the given frame
        
            # normalize a document
            normalized = jsonld.normalize(doc, {'format': 'application/nquads'})
            # normalized is a string that is a canonical representation of the document
            # that can be used for hashing
        
        Commercial Support
        ------------------
        
        Commercial support for this library is available upon request from
        `Digital Bazaar`_: support@digitalbazaar.com.
        
        Source
        ------
        
        The source code for the Python implementation of the JSON-LD API
        is available at:
        
        http://github.com/digitalbazaar/pyld
        
        Tests
        -----
        
        This library includes a sample testing utility which may be used to verify
        that changes to the processor maintain the correct output.
        
        To run the sample tests you will need to get the test suite files by cloning
        the ``json-ld.org`` repository hosted on GitHub:
        
        https://github.com/json-ld/json-ld.org
        
        Then run the test application using the directory containing the tests:
        
        .. code-block:: bash
        
            python tests/runtests.py -d {PATH_TO_JSON_LD_ORG/test-suite}
        
        .. _Digital Bazaar: http://digitalbazaar.com/
        .. _JSON-LD: http://json-ld.org/
        .. _Microdata: http://www.w3.org/TR/microdata/
        .. _Microformats: http://microformats.org/
        .. _Python: http://www.python.org/
        .. _RDFa: http://www.w3.org/TR/rdfa-core/
        .. _RFC7159: http://tools.ietf.org/html/rfc7159
        .. _pip: http://www.pip-installer.org/
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Topic :: Internet
Classifier: Topic :: Software Development :: Libraries