semvec/pypi-packages huggingface dataset:
trackopy 2.0.2
Python wrapper for the Trackobot API
License: MIT
Keywords: trackobot hearthstone

trackopy
========

Overview
--------

``trackopy`` is a Python 3 wrapper library for the `Track-o-bot`_ API.
It requires the ``requests`` module and Python 3. No, it does not
support Python 2.

Installation
------------

``pip install trackopy``

Usage
-----

The library relies on the ``Trackobot`` class. All methods are
documented and easy to use.

::

    import trackopy
    # from trackopy import *
    # from trackopy import Trackobot
    # All of the above are valid

    # You can create new users if you do not already have an account
    # The returned data will look like {'username': 'foo-bar-1234', 'password': 'abcdefgh'}
    user = trackopy.Trackobot.create_user()

    trackobot = trackopy.Trackobot(user['username'], user['password'])

    # Generate a profile link
    url = trackobot.one_time_auth()

    # Get your stats by arena, class, or deck
    stats = trackobot.stats(stats_type='decks')
    stats = trackobot.stats(stats_type='classes')
    stats = trackobot.stats(stats_type='arena')

    # Get supported deck archetypes
    decks = trackobot.decks()

    # Reset your account
    trackobot.reset()

    # Get game history
    history = trackobot.history()
    arena_history = trackobot.arena_history()

In addition to the above, you can upload games, modify game metadata,
delete games, or toggle automatic deck tracking. To learn more about the
available functionality, please `read the docs`_.

Please ensure you are using your Trackobot **password**, not your
Trackobot API key. You can get your password from the Trackobot desktop
app by exporting your user data to a file. Your password will be the
second string in the file with spaces between each character. Remove the
spaces and you should have a password of length 8.

CLI
===

Starting with v2.0, there is an included CLI utility for interacting with trackobot.com.
It serves as an example of how to use the library as well as a convenient way of getting data quickly.
Some people may only need simple functionality from this library, and this utility provides that.
It implements all available commands in ``trackopy``.
It is installed with the library and can be run with the ``tb`` command.
See all arguments and functionality with ``tb --help``.

License
-------

This project is licensed under the MIT license. You can read more in the
LICENSE file.

.. _Track-o-bot: https://trackobot.com
.. _read the docs: https://trackopy.readthedocs.io/en/latest/
haste-client 1.0.3
CLI client for Haste server (hastebin.com) written in Python.
License: MIT

CLI Haste client
================

|version|

A simple client for `Haste
server <https://github.com/jirutka/haste-server>`__ written in Python.

Installation
------------

Use pip or easy\_install:

::

    pip install haste-client

Gentoo users can use
`haste-client <https://github.com/cvut/gentoo-overlay/tree/master/www-apps/haste-client>`__
ebuild from `CVUT Overlay <https://github.com/cvut/gentoo-overlay>`__.

Haste client needs Python 2.6+ or 3.x (it was tested on 2.7, 3.3 and
3.4) and following modules:

-  `requests <https://github.com/kennethreitz/requests>`__
-  `docopt <https://github.com/docopt/docopt>`__ >= 0.3.0

Usage
-----

Text can be passed to ``haste`` via stdin or a file. TTY is also
supported.

::

    haste FILE
    cat FILE | haste

URL of the created entry is then printed to STDOUT.

Configuration
-------------

Haste client reads configuration variables from ``~/.hastec`` and
``/etc/hastec.conf`` (in this order, first wins). When no such file or
the particular variable exists, then default values are used:

::

    server_url = http://hastebin.com
    timeout = 3

License
-------

This project is licensed under `MIT
license <http://opensource.org/licenses/MIT>`__.

.. |version| image:: https://img.shields.io/pypi/v/haste-client.svg?style=flat
   :target: https://pypi.python.org/pypi/haste-client
the-cannon 0.2.6
A data-driven approach to stellar spectroscopy
License: MIT
Keywords: The Cannon

# The Cannon

[![Build Status](https://img.shields.io/travis/andycasey/AnniesLasso/refactor.svg)](https://travis-ci.org/andycasey/AnniesLasso)
[![Coverage Status](https://img.shields.io/coveralls/andycasey/AnniesLasso/refactor.svg)](https://coveralls.io/github/andycasey/AnniesLasso?branch=refactor)
[![Scrutinizer](https://img.shields.io/scrutinizer/g/andycasey/AnniesLasso.svg?b=refactor)](https://scrutinizer-ci.com/g/andycasey/AnniesLasso/?branch=refactor)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/andycasey/AnniesLasso/blob/refactor/LICENSE)


[See the documentation.](#)

## Authors
- **Andy Casey** (Cambridge) (Monash)
- **David W. Hogg** (NYU) (MPIA) (SCDA)
- **Melissa K. Ness** (MPIA)
- **Hans-Walter Rix** (MPIA)
- **Anna Y. Q. Ho** (Caltech)
- **Gerry Gilmore** (Cambridge)


## License
**Copyright 2017 the authors**.
The code in this repository is released under the open-source **MIT License**.
See the file `LICENSE` for more details.


## Installation

To install:

``
pip install https://github.com/andycasey/AnniesLasso/archive/refactor.zip
``


## Getting Started

Let us assume that you have rest-frame continuum-normalized spectra for a set of
stars for which the stellar parameters and chemical abundances (which we will
collectively call *labels*) are known with high fidelity.  The labels for those
stars (and the locations of the spectrum fluxes and inverse variances) are
assumed to be stored in a table.  In this example all stars are assumed to be 
sampled on the same wavelength (dispersion) scale.


Here we will create and train a 3-label (effective temperature, surface gravity,
metallicity) quadratic (e.g., `Teff^2`) model:


````python
import numpy as np
from astropy.table import Table

import AnniesLasso as tc

# Load the table containing the training set labels, and the spectra.
training_set = Table.read("training_set_labels.fits")

# Here we will assume that the flux and inverse variance arrays are stored in
# different ASCII files. The end goal is just to produce flux and inverse
# variance arrays of shape (N_stars, N_pixels).
normalized_flux = np.array([np.loadtxt(star["flux_filename"]) for star in training_set])
normalized_ivar = np.array([np.loadtxt(star["ivar_filename"]) for star in training_set])

# Providing the dispersion to the model is optional, but handy later on.
dispersion = np.loadtxt("common_wavelengths.txt")

# Create the model that will run in parallel using all available cores.
model = tc.CannonModel(training_set, normalized_flux, normalized_ivar,
    dispersion=dispersion, threads=-1)

# Specify the complexity of the model:
model.vectorizer = tc.vectorizer.NormalizedPolynomialVectorizer(labelled_set,
    tc.vectorizer.polynomial.terminator(("TEFF", "LOGG", "FEH"), 2))

# Train the model!
model.train()
````

You can follow this example further in the complete [Getting Started](#) tutorial.