This file is indexed.

/usr/lib/python2.7/dist-packages/cobra-0.5.9.egg-info/PKG-INFO is in python-cobra 0.5.9-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
Metadata-Version: 1.1
Name: cobra
Version: 0.5.9
Summary: COBRApy is a package for constraints-based modeling of biological networks
Home-page: https://opencobra.github.io/cobrapy
Author: Daniel Robert Hyduke <danielhyduke@gmail.com>, Ali Ebrahim <aebrahim@ucsd.edu>
Author-email: aebrahim@ucsd.edu
License: LGPL/GPL v2+
Download-URL: https://pypi.python.org/pypi/cobra
Description: cobrapy - constraint-based reconstruction and analysis in python
        ================================================================
        
        |Build Status| |Coverage Status| |Build status| |PyPI| |Gitter|
        
        What is cobrapy?
        ~~~~~~~~~~~~~~~~
        
        COBRA methods are widely used for genome-scale modeling of metabolic
        networks in both prokaryotes and eukaryotes. **cobrapy** is a
        constraint-based modeling package that is designed to accommodate the
        biological complexity of the next generation of COBRA models and
        provides access to commonly used COBRA methods, such as flux balance
        analysis, flux variability analysis, and gene deletion analyses.
        
        Our aim with cobrapy is to provide useful, efficient infrastructure
        for:
        
        - creating and managing metabolic models
        - accessing popular solvers
        - analyzing models with methods such as FVA, FBA, pFBA, MOMA etc. 
        - inspecting models and drawing conclusions on gene essentiality,
          testing consequences of knock-outs etc.
        
        Our goal with cobrapy is for it to be useful on its own, and for it to
        be the natural choice of infrastructure for developers that want to
        build new COBRA related python packages for e.g. visualization,
        strain-design and data driven analysis. By re-using the same classes
        and design principles, we can make new methods both easier to
        implement and easier to use, thereby bringing the power of COBRA to
        more researchers.
        
        The documentation is browseable online at
        `readthedocs <https://cobrapy.readthedocs.org/en/stable/>`_ and can
        also be
        `downloaded <https://readthedocs.org/projects/cobrapy/downloads/>`_.
        
        Please use the `Google
        Group <http://groups.google.com/group/cobra-pie>`_ for help.
        Alternatively, you can use
        `gitter.im <https://gitter.im/opencobra/cobrapy>`_ for quick questions
        and discussions about cobrapy (faster response times).
        
        More information about opencobra is available at the
        `website <http://opencobra.github.io/>`_.
        
        If you use cobrapy in a scientific publication, please cite
        `doi:10.1186/1752-0509-7-74 <http://dx.doi.org/doi:10.1186/1752-0509-7-74>`_
        
        Installation
        ~~~~~~~~~~~~
        
        Use pip to install cobrapy from
        `PyPI <https://pypi.python.org/pypi/cameo>`_ (we recommend doing this
        inside a `virtual
        environment <http://docs.python-guide.org/en/latest/dev/virtualenvs/>`_)::
        
            pip install cobra
        
        In case you downloaded the source code, run::
        
            pip install -e .
        
        In the ``cobrapy`` directory. For further information, please follow
        the `detailed installation instructions <INSTALL.rst>`_.
        
        Contributing
        ~~~~~~~~~~~~
        
        Contributions are always welcome! Please read the `contributions
        guideline <CONTRIBUTING.rst>`_ to get started.
        
        License
        -------
        
        The cobrapy source is released under both the GPL and LGPL licenses. You
        may choose which license you choose to use the software under. However,
        please note that binary packages which include GLPK (such as the binary
        wheels distributed at https://pypi.python.org/pypi/cobra) will be bound
        by its license as well.
        
        This program is free software: you can redistribute it and/or modify it
        under the terms of the GNU General Public License or the Lesser GNU
        General Public License as published by the Free Software Foundation,
        either version 2 of the License, or (at your option) any later version.
        
        This program is distributed in the hope that it will be useful, but
        WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
        Public License for more details.
        
        .. |Build Status| image:: https://travis-ci.org/opencobra/cobrapy.svg?branch=master
           :target: https://travis-ci.org/opencobra/cobrapy
        .. |Coverage Status| image:: https://codecov.io/github/opencobra/cobrapy/coverage.svg?branch=master
           :target: https://codecov.io/github/opencobra/cobrapy
        .. |Build status| image:: https://ci.appveyor.com/api/projects/status/2o549lhjyukke8nd/branch/master?svg=true
           :target: https://ci.appveyor.com/project/hredestig/cobrapy/branch/master
        .. |PyPI| image:: https://img.shields.io/pypi/v/cobra.svg
           :target: https://pypi.python.org/pypi/cobra
        .. |Gitter| image:: https://badges.gitter.im/opencobra/cobrapy.svg
           :target: https://gitter.im/opencobra/cobrapy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge
        
        
        
        Installation of cobrapy
        =======================
        
        For installation help, please use the `Google
        Group <http://groups.google.com/group/cobra-pie>`_. For usage
        instructions, please see the
        `documentation <https://cobrapy.readthedocs.org/en/latest/>`_.
        
        All releases require Python 2.7+ or 3.4+ to be installed before
        proceeding. Mac OS X (10.7+) and Ubuntu ship with Python. Windows users
        without python can download and install python from the `python
        website <https://www.python.org/ftp/python/2.7.9/python-2.7.9.amd64.msi>`_.
        Please note that though Anaconda and other python distributions may work
        with cobrapy, they are not explicitly supported (yet!).
        
        Stable version installation
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        cobrapy can be installed with any recent installation of pip.
        Instructions for several operating systems are below:
        
        Mac OS X or Linux
        -----------------
        
        1. `install
           pip <http://pip.readthedocs.org/en/latest/installing.html>`_.
        2. In a terminal, run ``sudo pip install cobra``
        
        We highly recommend updating ``pip`` beforehand (``pip install pip --upgrade``).
        
        Microsoft Windows
        -----------------
        
        The preferred installation method on Windows is also to use pip. The
        latest Windows installers for Python 2.7 and 3.4 include pip, so if you
        use those you will already have pip.
        
        1. In a terminal, run ``C:\Python27\Scripts\pip.exe install cobra`` (you
           may need to adjust the path accordingly).
        
        To install without pip, you will need to download and use the
        appropriate installer for your version of python from the `python
        package index <https://pypi.python.org/pypi/cobra/>`_.
        
        Installation for development
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        Get the `detailed contribution instructions <CONTRIBUTING.rst>`_ for contributing to cobrapy.
        
        Installation of optional dependencies
        =====================================
        
        Optional dependencies
        ~~~~~~~~~~~~~~~~~~~~~
        
        On windows, these can downloaded from [this site]
        (http://www.lfd.uci.edu/~gohlke/pythonlibs/). On Mac/Linux, they can be
        installed using pip, or from the OS package manager (e.g brew, apt,
        yum).
        
        1. `libsbml <http://sbml.org>`_ >= 5.10 to read/write SBML level 2
           files
        
           -  `Windows libsbml installer <http://www.lfd.uci.edu/~gohlke/pythonlibs/#libsbml>`_
           -  Use ``sudo pip install python-libsbml`` on Mac/Linux
        
        2. `lxml <http://lxml.de/>`_ to speed up read/write of SBML level 3 files.
        3. `numpy <http://numpy.org>`_ >= 1.6.1 for double deletions
        
           -  `Windows numpy installer <http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy>`_
        4. `scipy <http://scipy.org>`_ >= 0.11 for ArrayBasedModel and saving to \*.mat files.
        
           -  `Windows scipy installer <http://www.lfd.uci.edu/~gohlke/pythonlibs/#scipy>`_
        5. `pytest <http://docs.pytest.org/en/latest/>`_ and `pytest-benchmark
           <http://pytest-benchmark.readthedocs.io/en/latest/>`_ are required
           for testing
        
        You can install all packages directly by
        
        .. code:: shell
        
            pip install "cobra[all]"
        
        Other solvers
        ~~~~~~~~~~~~~
        
        cobrapy comes with bindings to the GNU Linear Programming Kit ([glpk]
        (http://www.gnu.org/software/glpk/)) using its own bindings called
        "cglpk" in cobrapy. In addition, cobrapy currently supports these linear
        programming solvers:
        
        -  ILOG/CPLEX (available with
           `Academic <https://www.ibm.com/developerworks/university/academicinitiative/>`_
           and
           `Commercial <http://www.ibm.com/software/integration/optimization/cplex-optimizer/>`_
           licenses).
        -  `gurobi <http://gurobi.com>`_
        -  `QSopt\_ex
           esolver <http://www.dii.uchile.cl/~daespino/ESolver_doc/main.html>`_
        -  `MOSEK <http://www.mosek.com/>`_
        -  `coin-or clp and cbc <http://coin-or.org/>`_ through
           `cylp <https://github.com/coin-or/CyLP>`_.
        
        ILOG/CPLEX, MOSEK, and Gurobi are commercial software packages that
        currently provide free licenses for academics and support both linear
        and quadratic programming. GLPK and clp are open source linear
        programming solvers; however, they may not be as robust as the
        commercial solvers for mixed-integer and quadratic programming.
        QSopt\_ex esolver is also open source, and can solve linear programs
        using rational operations, giving exact solutions.
        
        Testing your installation
        =========================
        
        While it is not a hard requirement for using cobrapy, you need pytest and
        pytest-benchmark to run its tests. First do
        
        .. code:: shell
        
            pip install pytest pytest-benchmark
        
        or to install cobrapy directly with the test dependencies
        
        .. code:: shell
        
           pip install "cobra[test]"
        
        Then start python and type the following into the Python shell
        
        .. code:: python
        
            from cobra.test import test_all
            test_all()
        
        You should see some skipped tests and expected failures, and the
        function should return ``True``.
        
Keywords: metabolism biology linear programming optimization flux balance analysis fba
Platform: GNU/Linux
Platform: Mac OS X >= 10.7
Platform: Microsoft Windows >= 7
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)
Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Cython
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Scientific/Engineering :: Bio-Informatics