This file is indexed.

/usr/lib/python2.7/dist-packages/pygeoif-0.6.egg-info/PKG-INFO is in python-pygeoif 0.6-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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
Metadata-Version: 1.1
Name: pygeoif
Version: 0.6
Summary: A basic implementation of the __geo_interface__
Home-page: https://github.com/cleder/pygeoif/
Author: Christian Ledermann
Author-email: christian.ledermann@gmail.com
License: LGPL
Description: Introduction
        ============
        
        PyGeoIf provides a GeoJSON-like protocol for geo-spatial (GIS) vector data.
        
        see https://gist.github.com/2217756
        
        Other Python programs and packages that you may have heard of already
        implement this protocol:
        
        * ArcPy http://help.arcgis.com/en/arcgisdesktop/
        * descartes https://bitbucket.org/sgillies/descartes/
        * geojson http://pypi.python.org/pypi/geojson/
        * PySAL http://pysal.geodacenter.org/
        * Shapely https://github.com/Toblerity/Shapely
        * pyshp https://pypi.python.org/pypi/pyshp
        
        So when you want to write your own geospatial library with support
        for this protocol you may use pygeoif as a starting point and build
        your functionality on top of it
        
        You may think of pygeoif as a 'shapely ultralight' which lets you
        construct geometries and perform **very** basic operations like
        reading and writing geometries from/to WKT, constructing line strings
        out of points, polygons from linear rings, multi polygons from
        polygons, etc. It was inspired by shapely and implements the
        geometries in a way that when you are familiar with shapely
        you feel right at home with pygeoif
        
        It was written to provide clean and python only geometries for
        fastkml_
        
        .. _fastkml: http://pypi.python.org/pypi/fastkml/
        
        PyGeoIf is continually tested with *Travis CI*
        
        .. image:: https://api.travis-ci.org/cleder/pygeoif.png
            :target: https://travis-ci.org/cleder/pygeoif
        
        .. image:: https://coveralls.io/repos/cleder/pygeoif/badge.png?branch=master
            :target: https://coveralls.io/r/cleder/pygeoif?branch=master
        
        
        
        
        Example
        ========
        
        
            >>> from pygeoif import geometry
            >>> p = geometry.Point(1,1)
            >>> p.__geo_interface__
            {'type': 'Point', 'coordinates': (1.0, 1.0)}
            >>> print p
            POINT (1.0 1.0)
            >>> p1 = geometry.Point(0,0)
            >>> l = geometry.LineString([p,p1])
            >>> l.bounds
            (0.0, 0.0, 1.0, 1.0)
            >>> dir(l)
            ['__class__', '__delattr__', '__dict__', '__doc__', '__format__',
            '__geo_interface__', '__getattribute__', '__hash__', '__init__',
            '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
            '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
            '__weakref__', '_coordinates', '_geoms', '_type', 'bounds', 'coords',
            'geom_type', 'geoms', 'to_wkt']
            >>> print l
            LINESTRING (1.0 1.0, 0.0 0.0)
        
        
        You find more examples in the
        `test_main.py <https://github.com/cleder/pygeoif/blob/master/pygeoif/test_main.py>`_
        file which cover every aspect of pygeoif or in fastkml_.
        
        Classes
        ========
        
        All classes implement the attribute:
        
        * __geo_interface__: as dicussed above
        
        All geometry classes implement the attributes:
        
        * geom_type: Returns a string specifying the Geometry Type of the object
        * bounds: Returns a (minx, miny, maxx, maxy) tuple (float values) that bounds the object.
        * wkt: Returns the 'Well Known Text' representation of the object
        
        
        and the method:
        
        * to_wkt which also prints the object
        
        GeoObject
        ----------
        Base class for Geometry, Feature, and FeatureCollection
        
        Geometry
        --------
        Base class for geometry objects. 
        Inherits from Geoobject.
        
        
        Point
        -----
        A zero dimensional geometry
        
        A point has zero length and zero area.
        
        Attributes
        ~~~~~~~~~~~
        x, y, z : float
            Coordinate values
        
        Example
        ~~~~~~~~
        
              >>> p = Point(1.0, -1.0)
              >>> print p
              POINT (1.0000000000000000 -1.0000000000000000)
              >>> p.y
              -1.0
              >>> p.x
              1.0
        
        
        
        LineString
        -----------
        
        A one-dimensional figure comprising one or more line segments
        
        A LineString has non-zero length and zero area. It may approximate a curve
        and need not be straight. Unlike a LinearRing, a LineString is not closed.
        
        Attributes
        ~~~~~~~~~~~
        geoms : sequence
            A sequence of Points
        
        
        
        LinearRing
        -----------
        
        A closed one-dimensional geometry comprising one or more line segments
        
        A LinearRing that crosses itself or touches itself at a single point is
        invalid and operations on it may fail.
        
        A Linear Ring is self closing
        
        
        
        Polygon
        --------
        
        A two-dimensional figure bounded by a linear ring
        
        A polygon has a non-zero area. It may have one or more negative-space
        "holes" which are also bounded by linear rings. If any rings cross each
        other, the geometry is invalid and operations on it may fail.
        
        Attributes
        ~~~~~~~~~~~
        
        exterior : LinearRing
            The ring which bounds the positive space of the polygon.
        interiors : sequence
            A sequence of rings which bound all existing holes.
        
        
        MultiPoint
        ----------
        A collection of one or more points
        
        Attributes
        ~~~~~~~~~~~
        
        geoms : sequence
            A sequence of Points
        
        MultiLineString
        ----------------
        A collection of one or more line strings
        
        A MultiLineString has non-zero length and zero area.
        
        Attributes
        ~~~~~~~~~~~
        
        geoms : sequence
            A sequence of LineStrings
        
        MultiPolygon
        -------------
        
        A collection of one or more polygons
        
        Attributes
        ~~~~~~~~~~~~~
        geoms : sequence
            A sequence of `Polygon` instances
        
        
        GeometryCollection
        -------------------
        A heterogenous collection of geometries (Points, LineStrings, LinearRings
        and Polygons)
        
        Attributes
        ~~~~~~~~~~~
        geoms : sequence
            A sequence of geometry instances
        
        Please note:
        GEOMETRYCOLLECTION isn't supported by the Shapefile format.
        And this sub-class isn't generally supported by ordinary GIS sw (viewers and so on).
        So it's very rarely used in the real GIS professional world.
        
        Example
        ~~~~~~~~
        
            >>> from pygeoif import geometry
            >>> p = geometry.Point(1.0, -1.0)
            >>> p2 = geometry.Point(1.0, -1.0)
            >>> geoms = [p, p2]
            >>> c = geometry.GeometryCollection(geoms)
            >>> c.__geo_interface__
            {'type': 'GeometryCollection', 'geometries': [{'type': 'Point', 'coordinates': (1.0, -1.0)},/
            {'type': 'Point', 'coordinates': (1.0, -1.0)}]}
            >>> [geom for geom in geoms]
            [Point(1.0, -1.0), Point(1.0, -1.0)]
        
        Feature
        -------
        Aggregates a geometry instance with associated user-defined properties.
        
        Attributes
        ~~~~~~~~~~~
        geometry : object
            A geometry instance
        properties : dict
            A dictionary linking field keys with values associated with with geometry instance
        
        Example
        ~~~~~~~~
        
              >>> p = Point(1.0, -1.0)
              >>> props = {'Name': 'Sample Point', 'Other': 'Other Data'}
              >>> a = Feature(p, props)
              >>> a.properties
              {'Name': 'Sample Point', 'Other': 'Other Data'}
              >>> a.properties['Name']
              'Sample Point'
        
        FeatureCollection
        -----------------
        A heterogenous collection of Features
        
        Attributes
        ~~~~~~~~~~~
        features: sequence
            A sequence of feature instances
        
        Example
        ~~~~~~~~
        
            >>> from pygeoif import geometry
            >>> p = geometry.Point(1.0, -1.0)
            >>> props = {'Name': 'Sample Point', 'Other': 'Other Data'}
            >>> a = geometry.Feature(p, props)
            >>> p2 = geometry.Point(1.0, -1.0)
            >>> props2 = {'Name': 'Sample Point2', 'Other': 'Other Data2'}
            >>> b = geometry.Feature(p2, props2)
            >>> features = [a, b]
            >>> c = geometry.FeatureCollection(features)
            >>> c.__geo_interface__
            {'type': 'FeatureCollection', 'features': [{'geometry': {'type': 'Point', 'coordinates': (1.0, -1.0)},/
             'type': 'Feature', 'properties': {'Other': 'Other Data', 'Name': 'Sample Point'}},/
             {'geometry': {'type': 'Point', 'coordinates': (1.0, -1.0)}, 'type': 'Feature',/
             'properties': {'Other': 'Other Data2', 'Name': 'Sample Point2'}}]}
            >>> [feature for feature in c]
            [<Feature Instance Point geometry 2 properties>, <Feature Instance Point geometry 2 properties>]
        
        Functions
        =========
        
        as_shape
        --------
        
        Create a pygeoif feature from an object that provides the __geo_interface__
        
        
            >>> from shapely.geometry import Point
            >>> from pygeoif import geometry
            >>> geometry.as_shape(Point(0,0))
            <pygeoif.geometry.Point object at 0x...>
        
        
        from_wkt
        ---------
        
        Create a geometry from its WKT representation
        
        
            >>> p = geometry.from_wkt('POINT (0 1)')
            >>> print p
            POINT (0.0 1.0)
        
        
        signed_area
        ------------
        
        Return the signed area enclosed by a ring using the linear time
        algorithm at http://www.cgafaq.info/wiki/Polygon_Area. A value >= 0
        indicates a counter-clockwise oriented ring.
        
        orient
        -------
        
        Returns a copy of the polygon with exterior in counter-clockwise and
        interiors in clockwise orientation for sign=1.0 and the other way round
        for sign=-1.0
        
        
        mapping
        -------
        
        Returns the __geo_interface__ dictionary
        
        
        Development
        ===========
        
        Installation
        ------------
        
        You can install PyGeoIf from pypi using pip::
        
            pip install pygeoif
        
        Testing
        -------
        
        In order to provide a Travis-CI like testing of the PyGeoIf package during
        development, you can use tox (``pip install tox``) to evaluate the tests on
        all supported Python interpreters which you have installed on your system.
        
        You can run the tests with ``tox --skip-missin-interpreters`` and are looking
        for output similar to the following::
        
            ______________________________________________________ summary ______________________________________________________
            SKIPPED:  py26: InterpreterNotFound: python2.6
              py27: commands succeeded
            SKIPPED:  py32: InterpreterNotFound: python3.2
            SKIPPED:  py33: InterpreterNotFound: python3.3
              py34: commands succeeded
            SKIPPED:  pypy: InterpreterNotFound: pypy
            SKIPPED:  pypy3: InterpreterNotFound: pypy3
              congratulations :)
        
        You are primarily looking for the ``congratulations :)`` line at the bottom,
        signifying that the code is working as expected on all configurations
        available.
        
        Changelog
        =========
        
        0.6 (2015/08/04)
        -----------------
        
        - Add id to feature [jzmiller1]
        
        0.5 (2015/07/13)
        -----------------
        
        - Add __iter__ method to FeatureCollection and GeometryCollection [jzmiller1].
        - add pypy and pypy3 and python 3.4 to travis.
        - Add tox configuration for performing local testing [Ian Lee].
        - Add Travis continuous deployment.
        
        0.4 (2013/10/25)
        -----------------
        
        - after a year in production promote it to `Development Status :: 5 - Production/Stable`
        - MultiPolygons return tuples as the __geo_interface__
        
        0.3.1 (2012/11/15)
        ------------------
        
        - specify minor python versions tested with Travis CI
        - fix for signed area
        
        
        0.3 (2012/11/14)
        -------------------
        
        - add GeometryCollection
        - len(Multi*) and len(GeometryCollection) returns the number of contained Geometries
        - add orient function to get clockwise or counterclockwise oriented poygons
        - add signed_area function
        - add _set_orientation method to lineStrings, Polygons and MultiPolygons
        
        
        0.2.1 (2012/08/02)
        -------------------
        
        - as_shape also accepts an object that is neither a dictionary nor has a __geo_interface__ but can be converted into a __geo_interface__ compliant dictionary
        
        
        0.2 (2012/08/01)
        -----------------
        
        - change license to LGPL
        - add wkt as a property
        - as_shape also accepts a __geo_interface__ compliant dictionary
        - test with python3
        
        
        0.1 (2012/07/27)
        -----------------
        
        - initial release
        
Keywords: GIS Spatial WKT
Platform: UNKNOWN
Classifier: Topic :: Scientific/Engineering :: GIS
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
Classifier: Development Status :: 5 - Production/Stable
Classifier: Operating System :: OS Independent