pyrolite 0.0.14__zip

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite/util/spatial.py

@@ -0,0 +1,91 @@
+import numpy as np
+import itertools
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logger = logging.getLogger()
+
+
+def piecewise(segment_ranges: list, segments=2, output_fmt=np.float):
+    """
+    Generator to provide values of quantizable paramaters which define a grid,
+    here used to split up queries from databases to reduce load.
+    """
+    outf = np.vectorize(output_fmt)
+    if type(segments) == np.int:
+        segments = list(np.ones(len(segment_ranges), dtype=np.int) * segments)
+    else:
+        pass
+    seg_width = [
+        (x2 - x1) / segments[ix]  # can have negative steps
+        for ix, (x1, x2) in enumerate(segment_ranges)
+    ]
+    separators = [
+        np.linspace(x1, x2, segments[ix] + 1)[:-1]
+        for ix, (x1, x2) in enumerate(segment_ranges)
+    ]
+    pieces = list(itertools.product(*separators))
+    for ix, i in enumerate(pieces):
+        i = np.array(i)
+        out = np.vstack((i, i + np.array(seg_width)))
+
+        yield outf(out)
+
+
+def spatiotemporal_split(
+    segments=4,
+    nan_lims=[np.nan, np.nan],
+    # usebounds=False,
+    # order=['minx', 'miny', 'maxx', 'maxy'],
+    **kwargs
+):
+    """
+    Creates spatiotemporal grid using piecewise function and arbitrary
+    ranges for individial kw-parameters (e.g. age=(0., 450.)), and
+    sequentially returns individial grid cell attributes.
+    """
+    part = 0
+    for item in piecewise(kwargs.values(), segments=segments):
+        x1s, x2s = item
+        part += 1
+        params = {}
+        for vix, var in enumerate(kwargs.keys()):
+            vx1, vx2 = x1s[vix], x2s[vix]
+            params[var] = (vx1, vx2)
+
+        items = dict(
+            south=params.get("lat", nan_lims)[0],
+            north=params.get("lat", nan_lims)[1],
+            west=params.get("long", nan_lims)[0],
+            east=params.get("long", nan_lims)[1],
+        )
+        if "age" in params:
+            items.update(
+                dict(
+                    minage=params.get("age", nan_lims)[0],
+                    maxage=params.get("age", nan_lims)[1],
+                )
+            )
+
+        items = {k: v for (k, v) in items.items() if not np.isnan(v)}
+        # if usebounds:
+        #    bounds = NSEW_2_bounds(items, order=order)
+        #    yield bounds
+        # else:
+        yield items
+
+
+def NSEW_2_bounds(cardinal, order=["minx", "miny", "maxx", "maxy"]):
+    """
+    Translates cardinal points to xy points in the form of bounds.
+    Useful for converting to the format required for WFS from REST
+    style queries.
+    """
+    tnsltr = {
+        xy: c
+        for xy, c in zip(
+            ["minx", "miny", "maxx", "maxy"], ["west", "south", "east", "north"]
+        )
+    }
+    bnds = [cardinal.get(tnsltr[o]) for o in order]
+    return bnds

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite/util/text.py

@@ -0,0 +1,207 @@
+import re
+import textwrap
+import numpy as np
+import logging
+
+try:
+    from sortedcollections import SortedSet as set
+except:
+    pass
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logger = logging.getLogger()
+
+
+def to_width(multiline_string, width=79, **kwargs):
+    """Uses builtin textwapr for text wrapping to a specific width."""
+    return textwrap.fill(multiline_string, width, **kwargs)
+
+
+def normalise_whitespace(strg):
+    """Substitutes extra tabs, newlines etc. for a single space."""
+    return re.sub("\s+", " ", strg).strip()
+
+
+def remove_prefix(z, prefix):
+    """Remove a specific prefix from the start of a string."""
+    if z.startswith(prefix):
+        return re.sub("^{}".format(prefix), "", z)
+    else:
+        return z
+
+
+def quoted_string(s):
+    # if " " in s or '-' in s or '_' in s:
+    s = '''"{}"'''.format(s)
+    return s
+
+
+def titlecase(
+    s,
+    exceptions=["and", "in", "a"],
+    abbrv=["ID", "IGSN", "CIA", "CIW", "PIA", "SAR", "SiTiIndex", "WIP"],
+    capitalize_first=True,
+    split_on="[\s_-]+",
+    delim="",
+):
+    """
+    Formats strings in CamelCase, with exceptions for simple articles
+    and omitted abbreviations which retain their capitalization.
+    TODO: Option for retaining original CamelCase.
+    """
+    # Check if abbrv in string, in which case it'll need to be split first?
+    words = re.split(split_on, s)
+    out = []
+    first = words[0]
+    if capitalize_first and not (first in abbrv):
+        first = first.capitalize()
+
+    out.append(first)
+    for word in words[1:]:
+        if word in exceptions + abbrv:
+            pass
+        elif word.upper() in abbrv:
+            word = word.upper()
+        else:
+            word = word.capitalize()
+        out.append(word)
+    return delim.join(out)
+
+
+def string_variations(
+    names,
+    preprocess=["lower", "strip"],
+    swaps=[(" ", "_"), (" ", "_"), ("-", " "), ("_", " "), ("-", ""), ("_", "")],
+):
+    """
+    Returns equilvaent string variations based on an input set of strings.
+
+    Parameters
+    ----------
+    names: {list, str}
+        String or list of strings to generate name variations of.
+    preprocess: list
+        List of preprocessing string functions to apply before generating
+        variations.
+    swaps: list
+        List of tuples for str.replace(out, in).
+
+    Returns
+    --------
+    set
+        Set (or SortedSet, if sortedcontainers installed) of unique string
+        variations.
+    """
+    vars = set()
+    # convert input to list if singular
+    if isinstance(names, str):
+        names = [names]
+
+    swapout = [s[0] for s in swaps]
+    for n in names:
+        n = str(n)
+        for p in preprocess:
+            n = getattr(n, p)()
+        vars.add(n)
+        if any([s in n for s in swapout]):
+            vars = vars.union([n.replace(*s) for s in swaps])
+    return vars
+
+
+def parse_entry(
+    entry,
+    regex=r"(\s)*?(?P<value>[\.\w]+)(\s)*?",
+    delimiter=",",
+    values_only=True,
+    first_only=True,
+    errors=None,
+    replace_nan="None",
+):
+    """
+    Parses an arbitrary string data entry to return
+    values based on a regular expression containing
+    named fields including 'value' (and any others).
+    If the entry is of non-string type, this will
+    return the value (e.g. int, float, NaN, None).
+
+    Parameters
+    -----------------------
+    entry: str
+        String entry which to search for the regex pattern.
+    regex: str
+        Regular expression to compile and use to search the
+        entry for a value.
+    delimiter: str, ','
+        Optional delimiter to split the string in case of multiple
+        inclusion.
+    values_only: bool, True
+        Option to return only values (single or list), or to instead
+        return the dictionary corresponding to the matches.
+    first_only: bool, True
+        Option to return only the first match, or else all matches.
+
+    Not yet implemented:
+
+    errors: int|float|np.nan|None, None
+        Error value to denote 'no match'.
+    """
+
+    if isinstance(entry, str):
+        pattern = re.compile(regex)
+        matches = []
+        if not delimiter or (delimiter is None):
+            subparts = [entry]
+        else:
+            subparts = entry.split(delimiter)
+
+        for _l in subparts:
+            _m = pattern.match(_l)
+            if _m:
+                _d = dict(value=_m.group("value"))
+                # Add other groups
+                _d.update(
+                    {
+                        k: _m.group(k)
+                        for (k, ind) in pattern.groupindex.items()
+                        if not k == "value"
+                    }
+                )
+
+            else:
+                _d = dict(value=replace_nan)
+                # Add other groups
+                _d.update(
+                    {
+                        k: replace_nan
+                        for (k, ind) in pattern.groupindex.items()
+                        if not k == "value"
+                    }
+                )
+            matches.append(_d)
+
+        if values_only:
+            matches = [m["value"] for m in matches]
+
+        if first_only:
+            return matches[0]
+
+        return matches
+    else:
+        if entry is None:
+            entry = replace_nan
+        elif isinstance(entry, float):
+            if np.isnan(entry):
+                entry = replace_nan
+        if first_only:
+            return entry
+        else:
+            return [entry]
+
+
+def split_records(data, delimiter="\r\n"):
+    """
+    Splits records in a csv where quotation marks are used.
+    Splits on a delimiter followed by an even number of quotation marks.
+    """
+    # https://stackoverflow.com/a/2787979
+    return re.split(delimiter + """(?=(?:[^'"]|'[^']*'|"[^"]*")*$)""", data)

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite/util/time.py

@@ -0,0 +1,224 @@
+import pandas as pd
+import numpy as np
+from .general import pyrolite_datafolder
+from .pd import to_frame, to_numeric
+from .text import titlecase, string_variations
+from .general import iscollection
+from collections import ChainMap, defaultdict
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logger = logging.getLogger()
+
+
+__DATA__ = pyrolite_datafolder(subfolder="timescale") / "geotimescale_spans.csv"
+
+
+def listify(df, axis=1):
+    """
+    Consdense text information across columns into a single list.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        Dataframe (or slice of dataframe) to condense along axis.
+    axis: {1, 0}
+        Axis to condense along.
+    """
+    return df.copy(deep=True).apply(list, axis=axis)
+
+
+def age_name(
+    agenamelist, prefixes=["Lower", "Middle", "Upper"], suffixes=["Stage", "Series"]
+):
+    """
+    Condenses an agename list to a specific agename, given a subset of
+    ambiguous_names.
+
+    Parameters
+    ----------
+    agenamelist: list
+        List of name components (i.e. [Eon, Era, Period, Epoch])
+    prefixes: list
+        Name components which occur prior to the higher order classification
+        (e.g. Upper Triassic).
+    suffixes: list
+        Name components which occur after the higher order classification
+        (e.g. Cambrian Series 2).
+    """
+    ambiguous_names = prefixes + suffixes
+    ambig_vars = [s.lower().strip() for s in ambiguous_names]
+    nameguess = agenamelist[-1]
+    # Process e.g. Stage 1 => Stage
+    nn_nameguess = "".join([i for i in nameguess if not i.isdigit()]).strip()
+
+    # check if the name guess corresponds to any of the ambiguous names
+    hit = [
+        ambiguous_names[ix]
+        for ix, vars in enumerate(ambig_vars)
+        if nn_nameguess.lower().strip() in vars
+    ][0:1]
+
+    if hit:
+        indexstart = len(agenamelist) - 1
+        outname = [agenamelist[indexstart]]
+        out_index_previous = 0
+        ambiguous_name = True
+        while ambiguous_name:
+            hitphrase = hit[0]
+            indexstart -= 1
+            nextup = agenamelist[indexstart]
+            if hitphrase in prefixes:
+                # insert the higher order component after the previous one
+                outname.insert(out_index_previous + 1, nextup)
+                out_index_previous += 1
+            else:
+                # insert the higher order component before the previous one
+                outname.insert(out_index_previous - 1, nextup)
+                out_index_previous -= 1
+
+            _nn_nextupguess = "".join([i for i in nextup if not i.isdigit()]).strip()
+            hit = [
+                ambiguous_names[ix]
+                for ix, vars in enumerate(ambig_vars)
+                if _nn_nextupguess.lower().strip() in vars
+            ][0:1]
+            if not hit:
+                ambiguous_name = False
+        return " ".join(outname)
+    else:
+        return nameguess
+
+
+def timescale_reference_frame(filename=__DATA__, info_cols=["Start", "End", "Aliases"]):
+    """
+    Rearrange the text-based timescale dataframe. Utility function for
+    timescale class.
+
+    Parameters
+    ----------
+    filename: {str, pathlib.Path}
+        File from which to generate the timescale information.
+    info_cols: list
+        List of columns beyond hierarchial group labels (e.g. Eon, Era..).
+
+    Returns
+    -------
+    pd.DataFrame
+        Dataframe containing timescale information.
+    """
+
+    df = pd.read_csv(filename)
+    df.loc[:, ["Start", "End"]] = df.loc[:, ["Start", "End"]].apply(to_numeric)
+    _df = df.copy(deep=True)
+    grps = [i for i in _df.columns if not i in info_cols]
+    condensed = _df.loc[:, [i for i in _df.columns if not i in info_cols]].fillna(
+        value=""
+    )
+    _df["Level"] = condensed.apply(
+        lambda x: grps[[ix for ix, v in enumerate(x) if v][-1]], axis=1
+    )
+    condensed = listify(condensed).apply(lambda x: [i for i in x if i])
+    _df["Name"] = condensed.apply(age_name)
+    _df["Ident"] = condensed.apply("-".join)
+    _df["MeanAge"] = _df.apply(lambda x: (x.Start + x.End) / 2, axis=1)
+    _df["Unc"] = _df.apply(lambda x: (x.Start - x.End) / 2, axis=1)
+
+    # Aliases
+    _df.Aliases = _df.Aliases.apply(lambda x: [] if pd.isnull(x) else x.split(";"))
+    _df.Aliases = _df.apply(lambda x: [x.Name, x.Ident] + x.Aliases, axis=1)
+    _df.Aliases = _df.Aliases.apply(lambda x: [i.lower().strip() for i in x])
+
+    col_order = (
+        ["Ident", "Name", "Level", "Start", "End", "MeanAge", "Unc"]
+        + grps
+        + ["Aliases"]
+    )
+
+    return _df.loc[:, col_order]
+
+
+class Timescale(object):
+    """
+    Geological Timescale class to provide time-focused utility functions.
+    """
+
+    def __init__(self, filename=None):
+        if filename is None:
+            self.data = timescale_reference_frame()
+        else:
+            self.data = timescale_reference_frame(filename)
+        self.levels = [i for i in self.data.Level.unique() if not pd.isnull(i)]
+        self.levels = [i for i in self.data.columns if i in self.levels]
+
+        def getnan():
+            return np.nan, np.nan
+
+        self.locate = defaultdict(getnan)
+        self.build()
+
+    def build(self):
+        for ix, g in enumerate(self.levels):
+            others = self.levels[ix + 1 :]
+            fltr = (
+                self.data.loc[:, others].isnull().all(axis=1)
+                & ~self.data.loc[:, g].isnull()
+            )
+            setattr(self, g + "s", self.data.loc[fltr, :])
+
+        dicts = self.data.apply(
+            lambda x: {a: (x.Start, x.End) for a in x.Aliases}, axis=1
+        )
+        # should check that the keys are unique across all of these
+        self.locate.update(dict(ChainMap(*dicts)))
+        self.data = self.data.set_index("Ident")
+
+    def text2age(self, entry, nulls=[None, "None", "none", np.nan, "NaN"]):
+        """
+        Converts a text-based age to the corresponding age range (in Ma).
+
+        String-based entries return (max_age, min_age). Collection-based entries
+        return a list of tuples.
+
+        Parameters
+        ------------
+        entry: str
+            String name, or series of string names, for geological age range.
+
+        """
+        try:
+            entry = np.float(entry)
+            return (entry, entry)
+        except:
+            return self.locate[entry.lower().strip()]
+
+    def named_age(self, age, level="Period"):
+        """
+        Converts a numeric age (in Ma) to named age at a specific level.
+
+        Parameters
+        ------------
+        age: float
+            Numeric age in Ma.
+        level: {'Eon', 'Era', 'Period', 'Superepoch',
+                'Epoch', 'Age', 'Specific'}
+            Level of specificity.
+
+        Returns
+        ------------
+        str
+            String representation for the entry.
+        """
+
+        level = titlecase(level)
+        wthn_rng = lambda x: (age <= x.Start) & (age >= x.End)
+        relevant = self.data.loc[self.data.apply(wthn_rng, axis=1).values, :]
+        if level == "Specific":  # take the rightmost grouping
+            relevant = relevant.loc[:, self.levels]
+            idx_rel_row = (~pd.isnull(relevant)).count(axis=1).idxmax()
+            rel_row = relevant.loc[idx_rel_row, :]
+            spec = rel_row[~pd.isnull(rel_row)].values[-1]
+            return spec
+        else:
+            relevant = relevant.loc[:, level]
+            return relevant.unique()[~pd.isnull(relevant.unique())][0]

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite/util/wfs.py

@@ -0,0 +1,10 @@
+from owslib.wfs import WebFeatureService
+from owslib.fes import *
+from owslib.etree import etree
+import requests
+import json, geojson
+import codecs
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logger = logging.getLogger()

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite-0.0.14-py3.6.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: pyrolite
+Version: 0.0.14
+Summary: Tools for geochemical data analysis.
+Home-page: https://github.com/morganjwilliams/pyrolite
+Author: Morgan Williams
+Author-email: morgan.williams@csiro.au
+License: CSIRO Modifed MIT/BSD
+Description: # `pyrolite`
+        
+        <p align="left">
+          <a href="https://pypi.python.org/pypi/pyrolite/">
+            <img src="https://img.shields.io/pypi/v/pyrolite.svg" alt="PyPI"></a>
+          <a href="https://pyrolite.readthedocs.io/">
+             <img src="https://readthedocs.org/projects/pyrolite/badge/?version=latest" alt="Docs"/></a>
+          <a href="https://github.com/ambv/black">
+            <img src="https://img.shields.io/badge/code%20style-black-000000.svg"
+                 alt="Code Style: Black"></a>
+          <a href="https://pypi.python.org/pypi/pyrolite/">
+            <img src="https://img.shields.io/pypi/pyversions/pyrolite.svg"
+                 alt="Compatible Versions"></a>
+          <a href="https://github.com/morganjwilliams/pyrolite/blob/master/LICENSE" >
+            <img src="https://img.shields.io/badge/License-CSIRO_BSD/MIT_License-blue.svg"
+                 alt="License: CSIRO Modified BSD/MIT License"></a>
+          <a href="https://saythanks.io/to/morganjwilliams">
+            <img src="https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg"
+                 alt="Say Thanks"></a>
+        </p>
+        
+        ### Install
+        
+        ```bash
+        pip install pyrolite
+        ```
+        
+        ### Build Status
+        
+        
+        | **master** | **develop** |
+        |:----------:|:-----------:|
+        | [![Build Status](https://travis-ci.org/morganjwilliams/pyrolite.svg?branch=master)](https://travis-ci.org/morganjwilliams/pyrolite) | [![Build Status](https://travis-ci.org/morganjwilliams/pyrolite.svg?branch=develop)](https://travis-ci.org/morganjwilliams/pyrolite) |
+        | [![Coverage Status](https://coveralls.io/repos/github/morganjwilliams/pyrolite/badge.svg?branch=master)](https://coveralls.io/github/morganjwilliams/pyrolite?branch=master) | [![Coverage Status](https://coveralls.io/repos/github/morganjwilliams/pyrolite/badge.svg?branch=develop)](https://coveralls.io/github/morganjwilliams/pyrolite?branch=develop) |
+        
+        **Maintainer**: Morgan Williams (morgan.williams _at_ csiro.au)
+        
+Platform: UNKNOWN
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+Provides-Extra: skl
+Provides-Extra: spatial
+Provides-Extra: dev
+Provides-Extra: db
+Provides-Extra: impute

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite-0.0.14-py3.6.egg-info/SOURCES.txt

@@ -0,0 +1,83 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.cfg
+setup.py
+versioneer.py
+pyrolite/__init__.py
+pyrolite/_version.py
+pyrolite/alteration.py
+pyrolite/classification.py
+pyrolite/geochem.py
+pyrolite/norm.py
+pyrolite/plot.py
+pyrolite.egg-info/PKG-INFO
+pyrolite.egg-info/SOURCES.txt
+pyrolite.egg-info/dependency_links.txt
+pyrolite.egg-info/requires.txt
+pyrolite.egg-info/top_level.txt
+pyrolite/comp/__init__.py
+pyrolite/comp/aggregate.py
+pyrolite/comp/codata.py
+pyrolite/comp/impute.py
+pyrolite/data/georoc/contents.json
+pyrolite/data/melts/env.py
+pyrolite/data/melts/__pycache__/env.cpython-35.pyc
+pyrolite/data/melts/__pycache__/env.cpython-36.pyc
+pyrolite/data/models/TAS.clsf.gz
+pyrolite/data/models/aphanitic.clsf.gz
+pyrolite/data/models/gabbroic.clsf.gz
+pyrolite/data/models/peralkalinity.clsf.gz
+pyrolite/data/models/phaneritic.clsf.gz
+pyrolite/data/models/ultramafic.clsf.gz
+pyrolite/data/models/TAS/TAS.Ba.modelfield
+pyrolite/data/models/TAS/TAS.Bs.modelfield
+pyrolite/data/models/TAS/TAS.F.modelfield
+pyrolite/data/models/TAS/TAS.O1.modelfield
+pyrolite/data/models/TAS/TAS.O2.modelfield
+pyrolite/data/models/TAS/TAS.O3.modelfield
+pyrolite/data/models/TAS/TAS.Pc.modelfield
+pyrolite/data/models/TAS/TAS.Ph.modelfield
+pyrolite/data/models/TAS/TAS.R.modelfield
+pyrolite/data/models/TAS/TAS.S1.modelfield
+pyrolite/data/models/TAS/TAS.S2.modelfield
+pyrolite/data/models/TAS/TAS.S3.modelfield
+pyrolite/data/models/TAS/TAS.T1.modelfield
+pyrolite/data/models/TAS/TAS.T2.modelfield
+pyrolite/data/models/TAS/TAS.U1.modelfield
+pyrolite/data/models/TAS/TAS.U2.modelfield
+pyrolite/data/models/TAS/TAS.U3.modelfield
+pyrolite/data/models/TAS/TAS.modelfields
+pyrolite/data/models/TAS/TAS.nan.modelfield
+pyrolite/data/models/TAS/TAS.none.modelfield
+pyrolite/data/refcomp/CH_PalmeONeill2014.csv
+pyrolite/data/refcomp/DDMM_WorkmanHart2005.csv
+pyrolite/data/refcomp/DMM_WorkmanHart2005.csv
+pyrolite/data/refcomp/DM_SaltersStrake2004.csv
+pyrolite/data/refcomp/EDMM_WorkmanHart2005.csv
+pyrolite/data/refcomp/PM_PalmeONeill2014.csv
+pyrolite/data/timescale/geotimescale_spans.csv
+pyrolite/mineral/__init__.py
+pyrolite/mineral/db.py
+pyrolite/mineral/ions.py
+pyrolite/mineral/mineral.py
+pyrolite/mineral/sites.py
+pyrolite/util/__init__.py
+pyrolite/util/database.py
+pyrolite/util/env.py
+pyrolite/util/general.py
+pyrolite/util/georoc.py
+pyrolite/util/math.py
+pyrolite/util/multip.py
+pyrolite/util/pd.py
+pyrolite/util/plot.py
+pyrolite/util/skl.py
+pyrolite/util/spatial.py
+pyrolite/util/text.py
+pyrolite/util/time.py
+pyrolite/util/wfs.py
+test/test_alteration.py
+test/test_classification.py
+test/test_geochem.py
+test/test_norm.py
+test/test_plot.py

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite-0.0.14-py3.6.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+