semvec/pypi-packages huggingface dataset:
plinq 0.3
LINQ implementation for Python
License: MIT
Keywords: linq python

README
======

Plinq is a library for python, implementing the Language Integrated Query (LINQ) from the C# language.
Of course it is not a full port of the feature, it is only working with in memory iterable objects, including:

-  lists
-  sets
-  dictionaries
-  files
-  xml elements
-  generators
-  and every class which implements the iterable/iterator protocol (
   \_\_iter\_\_ and \_\_next\_\_)

Plinq tries to mimic the Enumerable<T> interface from C# as much as possible.

-  It has the same method names, wherever possible, and the same
   parameters too

Plinq operators are lazy, meaning calling one, will not start the actual work.
It will only happen, when the iteration over the returned object is started.

Plinq operators returning a new Linq object, so operator calls can be chained into a fluent API like call.

How do I get set up?
~~~~~~~~~~~~~~~~~~~~

-  Summary of set up

   -  There are several ways to set up plinq:

      -  The simplest way is to invoke pip install plinq

      -  You can also check out the repository, and add the path to it to your python path

      - Combining the two above steps, you can check out the repository, create a distribution package
        by executing the setup.py file, and then install that package with pip

   -  After these steps you can simply import plinq and start using the library

-  Configuration

   -  No additional configuration is needed

-  Dependencies

   -  plinq has no external dependencies. The only requirement is to have at least Python 3.5.2

-  How to run tests

   -  After you have checked out the repository,
      you can run the python unit tests by invoking the following command from the root directory of the repository:

      -  python -m unittest discover test/

Who do I talk to?
~~~~~~~~~~~~~~~~~

-  Repo owner and admin

   -  Heszele Rudolf heszele@gmail.com

Example usage
~~~~~~~~~~~~~

::

    import plinq
    linq = plinq.from_iterable([1, 2, 3, 4, 5]).where(lambda item, index: item % 2 == 0).select(lambda item, index: item ** 2)
    for item in linq:
        print(item)

This will result in the following output:

::

    4
    16

Version History
~~~~~~~~~~~~~~~
-  0.1: Never released externally
-  0.2: Initial release on pypi. Includes almost all the linq operators, except then_by and then_by_descending
-  0.3: Added then_by and then_by_descending linq operarors, and max_item and min_item operators.
DogYears 1.0.0
Convert human years to dog years and vice versa.
License: MIT

DogYears
========

Convert human years to dog years and vice versa.

Install
-------

.. code:: bash

    pip install dogyear

Usage
-----

.. code:: python

    import dogyear

    x = dogyear.get_dog_years(<age_in_human_years>, <size_in_pounds>)
    y = dogyear.get_human_years(<age_in_dog_years>, <size_in_pounds>)

References
----------

-  `How To Calculate Dog
   Years <https://flexpet.com/how-to-calculate-dog-years/>`__
-  `numpy.inter <https://docs.scipy.org/doc/numpy/reference/generated/numpy.interp.html>`__

Author
------

-  `Ronie Martinez <mailto:ronmarti18@gmail.com>`__
TheCannon 0.7.0
Data-driven stellar parameters and abundances from spectra
License: MIT

TheCannon
=========

This is the code associated with *The Cannon*, a data-driven method for 
determining stellar labels (physical parameters and chemical abundances) from
stellar spectra in the context of large spectroscopic surveys. It closely 
follows the method outlined in Ness et al. 2015, although some minor changes 
have been made. A description of these changes is outlined in Ho et al. 2016 (arXiv:1602.00303).

.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.221367.svg
   :target: https://doi.org/10.5281/zenodo.221367

Documentation for The Cannon can be found here_. 

.. _here: https://annayqho.github.io/TheCannon/

Authors
-------

* **Anna Ho** (MPIA)
* **Melissa Ness** (MPIA)
* **David W. Hogg** (SCDA NYU MPIA)
* **Hans-Walter Rix** (MPIA)

License and Citation
--------------------

Copyright 2015 the authors. TheCannon is open-source software released under 
the MIT License. See the file ``LICENSE`` for details.

A condition on using this code for any academic purpose is citation of
Ness et al. 2015 (arXiv:1501.07604) and Ho et al. 2016 (arXiv:1602.00303). 

Projects
--------

* Label Transfer from APOGEE to LAMOST: Precise Stellar Parameters for 450,000 LAMOST Giants
* Masses and Ages for 230,000 LAMOST Giants, via Their Carbon and Nitrogen Abundances
Lector 0.0.3
An API for Amazon Kindle Data
License: MIT

# Lector
An API for your Kindle data.

Python bindings are provided but any language that can run the javascript
found in `api.py` from within a Kindle Cloud Reader session may easily access
this data.

### Dependecies
**PhantomJS**:

* OS X (Homebrew)
    * ```brew install phantomjs```
* Ubuntu (at least 14.04)
    * Guide provided and maintained by @julionc
      [here](https://gist.github.com/julionc/7476620)

### Usage
```python
import lector

api = lector.KindleCloudReaderAPI('my_amazon_username', 'my_amazon_password')
my_library = api.get_library_metadata()
book = my_library[0]
book_progress = api.get_book_progress(book.asin)
_, current_page, last_page = book_progress.page_nums

print 'Currently reading %s (Page %d of %d)' % (book.title, current_page, last_page)
```
julesTk 0.3.3
MVC Framework for TKinter
License: MIT
Keywords: tkinter mvc

========
Jules-tk
========

A small MVC Framework for Tkinter.

The model is Thread-safe, but since Tk is not thread safe, the view and controllers are not thread-safe.
In threaded applications; use different threads to update the model and run a polling (using view.after) to update
the view.

Design structure
================

MVC: Model-View-Controller, is a well-known and wide practiced design paradigm for designing Graphical User Interfaces (GUI's).

Jules-tk provides the MVC structure, similar to what web-frameworks as django do. There is one entry-point to the application
(app.py) which will load controllers. The controllers will then initialize the models it needs and the view it works with.

The Controller
--------------

Controller serve as the logic hub of the application and bridge from view and model.

The View
--------

* Frame: Non-interacting Frame widget.
* View: interacting, requires a controller.
* ViewSet: combine multiple views into one window.

The Model
---------

Models store and manipulate data contained by the application. They also serve as a gateway in multi-threaded
applications: Meaning, multiple threads can share information via the Model. One could - for example - use threads to
 manipulate the Model, while the View and Controller are updated in the MainThread using the Model.


Observer and Observable
=======================

The observer-observable paradigm enables objects to notify other objects upon an important change.
Models are by default observable, but Controllers need to inherit the Observer class.
See the `click_me` example for a demonstration of this paradigm.

Be aware that this paradigm is not easy to implement in multi-threaded applications. In those cases it may be better
to use a polling mechanism in the MainThread to periodically update the View.

Application flow
================

1. app.py, calls a controller
2. controller loads model
3. controller loads view
4. app.py enters mainloop
5. app.py exits mainloop
6. app.py asks controllers to stop
7. controller asks view to stop

While in the main loop

1. view receives to user input
2. view calls controller
3. controller handles input - acts on model
5. controller handles update - acts on view

Plotting
========

Basic plotting is implemented using matplotlib with the `plot.Plot` Widget.
See the `random_plot` example for a demonstration.
aio-nasa-tle-loader 1.0.0
Small async wrapper for `nasa-tle-loader` package
License: MIT

SpaceTrackApi client
____________________

Small async wrapper for `nasa-tle-loader` package


Requirements
------------

- aiohttp >= 2.0.7
- nasa-tle-loader >= 1.0.0


Installing
__________

::

    pip install aio-nasa-tle-loader


Getting started
---------------

To retrieve something from Space-Track:

.. code-block:: python

  # -*- coding: utf-8 -*-

  import asyncio
  import json

  from aio_nasa_tle_loader import AsyncNasaTLELoader


  async def main(loop):
      async with AsyncNasaTLELoader(loop=loop) as loader:
          # Getting list `nasa_tle_loader.TLE`(namedtuple like) objects
          tle_list = await loader()

          # Print result as JSON
          print(json.dumps([tle.as_dict() for tle in tle_list[:3]], indent=2))


  if __name__ == '__main__':
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main(loop))


Result::

  [
    {
      "EPOCH": "2017-05-17 13:16:58",
      "EPOCH_MICROSECONDS": "124064",
      "NORAD_CAT_ID": "25544",
      "TLE_LINE0": "ISS",
      "TLE_LINE1": "1 25544U 98067A   17137.55345051  .00016717  00000-0  10270-3 0  9004",
      "TLE_LINE2": "2 25544  51.6389 191.0057 0005051 169.7469 190.3787 15.54030000 16987"
    },
    {
      "EPOCH": "2017-05-17 22:32:35",
      "EPOCH_MICROSECONDS": "151072",
      "NORAD_CAT_ID": "25544",
      "TLE_LINE0": "ISS",
      "TLE_LINE1": "1 25544U 98067A   17137.93929573  .00016717  00000-0  10270-3 0  9014",
      "TLE_LINE2": "2 25544  51.6398 189.0848 0005258 166.2909 193.8387 15.53887043 17040"
    },
    {
      "EPOCH": "2017-05-18 01:37:47",
      "EPOCH_MICROSECONDS": "963136",
      "NORAD_CAT_ID": "25544",
      "TLE_LINE0": "ISS",
      "TLE_LINE1": "1 25544U 98067A   17138.06791624  .00016717  00000-0  10270-3 0  9024",
      "TLE_LINE2": "2 25544  51.6394 188.4430 0005111 170.0057 190.1198 15.53888284 17061"
    }
  ]


Source code
-----------

The latest developer version is available in a github repository:
https://github.com/nkoshell/aio-nasa-tle-loader
nasa-tle-loader 1.0.0
Small TLE loader from NASA
License: MIT

SpaceTrackApi client
____________________

Small TLE loader from NASA.


Requirements
------------

- requests >= 2.14.2


Installing
__________

::

    pip install nasa-tle-loader


Getting started
---------------

To retrieve something from Space-Track:

.. code-block:: python

  # -*- coding: utf-8 -*-
  from __future__ import unicode_literals, print_function

  import json

  from nasa_tle_loader import NasaTLELoader


  def main():
      # Loader initializing
      loader = NasaTLELoader()

      # Getting list `nasa_tle_loader.TLE`(namedtuple like) objects
      tle_list = loader()

      # Print result as JSON
      print(json.dumps([tle.as_dict() for tle in tle_list[:3]], indent=2))


  if __name__ == '__main__':
      main()

Result::

  [
    {
      "EPOCH": "2017-05-17 13:16:58",
      "EPOCH_MICROSECONDS": "124064",
      "NORAD_CAT_ID": "25544",
      "TLE_LINE0": "ISS",
      "TLE_LINE1": "1 25544U 98067A   17137.55345051  .00016717  00000-0  10270-3 0  9004",
      "TLE_LINE2": "2 25544  51.6389 191.0057 0005051 169.7469 190.3787 15.54030000 16987"
    },
    {
      "EPOCH": "2017-05-17 22:32:35",
      "EPOCH_MICROSECONDS": "151072",
      "NORAD_CAT_ID": "25544",
      "TLE_LINE0": "ISS",
      "TLE_LINE1": "1 25544U 98067A   17137.93929573  .00016717  00000-0  10270-3 0  9014",
      "TLE_LINE2": "2 25544  51.6398 189.0848 0005258 166.2909 193.8387 15.53887043 17040"
    },
    {
      "EPOCH": "2017-05-18 01:37:47",
      "EPOCH_MICROSECONDS": "963136",
      "NORAD_CAT_ID": "25544",
      "TLE_LINE0": "ISS",
      "TLE_LINE1": "1 25544U 98067A   17138.06791624  .00016717  00000-0  10270-3 0  9024",
      "TLE_LINE2": "2 25544  51.6394 188.4430 0005111 170.0057 190.1198 15.53888284 17061"
    }
  ]

Source code
-----------

The latest developer version is available in a github repository:
https://github.com/nkoshell/nasa-tle-loader