semvec/pypi-packages huggingface dataset:
pyvidia 1.0.1
Nvidia driver version detector for Linux
License: MIT
Keywords: nvidia linux driver

pyvidia
=======
Pyvidia is a script to detect the required driver series (and latest driver
version) for an NVIDIA graphics card in a Linux environment.

The script scrapes device and driver data from `nvidia.com`, so its device and
driver information are always up-to-date.

Inspired by the `nvidia-detect` utility in ELRepo:
http://elrepo.org/tiki/nvidia-detect

#Usage
Pyvidia can either be executed as a standalone script, or imported as a module
in other scripts.

##Script
When executing as a script, the default behavior is to return the required
driver series for the detected NVIDIA device. In the case of current drivers,
the long lived branch is preferred by default over the short lived branch.

The following command line options are also available:
```
--series                Output the required driver series for the detected
                        NVIDIA device [Default]

--latest                Output the latest version number of the driver for the
                        detected NVIDIA device

--longlived             Denotes that the long lived version of the current
                        drivers should be preferred [Default]

--shortlived            Denotes that the short lived version of the current
                        drivers should be preferred.

--deviceid DEVICEID     Provide a device PCI ID to be used instead of auto-
                        detecting one

--url                   Output the download URL for the required driver

-v, --verbose           More detailed output
```

##Import
When imported into another script, there are several available functions:

```
get_required_driver_series(device_id)
    Returns the required driver series for the given or detected NVIDIA device.

    Keyward Args:
    device_id - The device PCI ID to check against the supported devices lists
```

```
get_latest_driver_version(device_id)
    Returns the latest driver version of the required driver series for the
    given or detected NVIDIA device.

    Keyward Args:
    device_id - The device PCI ID to check against the supported devices lists
```

```
get_nvidia_device()
    Returns the device info (name and ID) for the detected NVIDIA device,
    or none if one is not present.
```

```
get_all_supported_devices()
    Returns a dictionary keyed by driver series number, containing the latest
    driver version number and a list of supported devices for that series.
```

```
get_driver_url(device_id)
    Returns the download URL of the required driver for the given or detected
    device.

    Keyward Args:
    device_id - The device PCI ID to check against the supported devices lists
```

#Requirements
The required modules for this script can be installed via pip:
```
pip install -r requirements.txt
```

#Compatibility
Pyvidia should be compatible with both Python 2 (2.7) and Python 3
neuralpy 1.3.0
neuralpy - The most intuitive Neural Network Model
License: MIT
Keywords: neuralpy neural networks

neuralpy 1.3.0
--------------

**Within this package is the most intuitive fully-connected multilayer neural network model. Data science shouldn't have a high barrier to entry. neuralpy handles the math and overhead while you focus on the data.**

neuralpy is a neural network model written in python based on Michael Nielsen's neural networks and deep learning book.

- Visit the `neuralpy website <http://jon--lee.github.io/neuralpy/>`_
- Get detailed examples and explanations in the `Official Documentation <http://pythonhosted.org/neuralpy/>`_
- Contribute on `Github <https://github.com/jon--lee/neuralpy>`_

Getting Started (quick start)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++
The following demonstrates how to download and install **neuralpy** and how to create and train a simple neural network.
Run the following command to download and install::

	$ pip install neuralpy

Create a neural network in your project by specifying the number of nodes in each layer. Random weights and biases will automatically be generated::
	
	import neuralpy
	net = neuralpy.Network([2, 3, 1])

The network feeds input vectors as python lists forward and returns the output vector as a list::

	x = [1, 1]
	output = net.forward(x)
	print output
        # ex: [0.11471727263613461]

Train the neural network by first generating training data in the form of a list of tuples. Each tuple has two components and each component is a list representing the input and output respectively. This training set represents the simple OR function
and it can be generated for you to save typing::

	training_data = neuralpy.load_or()
        # [
        #   ([1, 1], [1]),
        #   ([1, 0], [1]),
        #   ...
        # ]

Then we must specify the remaining hyperparameters. Let's say we want to limit it to 100 epochs and give it a learning rate of 1::

	epochs = 100
	learning_rate = 1

Then run the *train* method with the parameters. We're telling the network to conform to training data::

	net.train(training_data, epochs, learning_rate)

Now feed forward the input from earlier and the output should be closer to 1.0, which is what we trained the network to do::

	output = net.forward(x)
	print output		# ex: [0.9542129706170075]

There is more information about advanced options such as monitoring the cost in the official documentation.

Since, this is a multilayer feedforward neural network, it is a universal approximator (Hornik, Stinchcombe and White, 1989). Neural Networks can be used for a wide range of applications from image processing to time series prediction.

- *"You abandoned me. You left me to die."*
- *"Well, I wouldn't have done it if I'd known you were going to hassle me about it."*
synolopy 0.1.2
Synology Python API
License: MIT

Synolopy
========

Synology is a Python library aimed to help using Synology device’s APIs.

Features
--------

Common Gateway Interface builder
''''''''''''''''''''''''''''''''

Since Synology APIs are build using the same pattern, this library also
uses and provides tools to instanciate a pythonic consumer for any
CGI-based API.

Installation
------------

Easy way
''''''''

.. code:: sh

    pip install synolopy

“Hard” way
''''''''''

.. code:: sh

    git clone git@github.com:thavel/synolopy.git synolopy
    cd ./synolopy
    pip install .

Disk Station Manager API
------------------------

Disk Station Manager is the name of the system on any Synology NAS
devices.

Quick start
'''''''''''

To start using the NAS API, you need to import the library:

.. code:: python

    from synolopy import NasApi

    nas = NasApi('http://192.168.0.99:5000/webapi/', 'admin', 'my_super_strong_password')

Basically, any API request follows this pattern: >
nas.\ *application*.\ *service*.request(\ *method*, *[params]*)

For further information about methods and parameters, you need to read
the official documentation of the related application (cf. docs linked
above).
headlessvim 0.0.5
programmable Vim, no need of +clientserver!
License: MIT
Keywords: vim test

headlessvim
===========

.. image:: https://img.shields.io/travis/manicmaniac/headlessvim/master.svg
    :target: https://travis-ci.org/manicmaniac/headlessvim
    :alt: Travis CI

.. image:: https://img.shields.io/coveralls/manicmaniac/headlessvim/master.svg
    :target: https://coveralls.io/github/manicmaniac/headlessvim?branch=master
    :alt: Coveralls

.. image:: https://img.shields.io/codeclimate/github/manicmaniac/headlessvim.svg
    :target: https://codeclimate.com/github/manicmaniac/headlessvim
    :alt: Code Climate

.. image:: https://img.shields.io/pypi/v/headlessvim.svg
    :target: https://pypi.python.org/pypi/headlessvim
    :alt: PyPI Version

.. image:: https://img.shields.io/pypi/pyversions/headlessvim.svg
    :target: https://pypi.python.org/pypi/headlessvim
    :alt: Python Versions

Introduction
------------

``headlessvim`` makes Vim programmable to support developping Vim plugins.

The most distinctive characteristic is,
``headlessvim`` NEVER needs ``+clientserver`` feature.

Install
-------

Using ``pip`` (recommended)

.. code:: sh

    pip install headlessvim

The good old ``setup.py``

.. code:: sh

    python setup.py install

Usage
-----

A simple example is here:

.. code:: python

    >>> import headlessvim
    >>> with headlessvim.open() as vim:
    ...    vim.echo('"spam"') # make sure to quote bare words
    ...
    'spam'
    >>> import os
    >>> env = dict(os.environ, LANG='C')
    >>> with headlessvim.open(executable='/usr/bin/vim', args='-N -u /etc/vim/vimrc', env=env):
    ...    vim.send_keys('iham\033')
    ...    vim.display_lines()[0].strip()
    ...
    'ham'

Integrating to ``unittest``:

.. code:: python

    import unittest
    import headlessvim

    class TestVimPlugin(unittest.TestCase):
        def setUp(self):
            self.vim = headlessvim.open()

        def tearDown(self):
            self.vim.close()

        def testSomeFeature(self):
            res = self.vim.echo('"ham egg"')
            self.assertEqual(res, 'ham egg')

Documentation
-------------

See `the online document <http://pythonhosted.org/headlessvim/>`_ for more information.

Testing
-------

Execute:

.. code:: sh

    python setup.py test


License
-------

The MIT License.

See `LICENSE.txt <LICENSE.txt>`_ for more information.