oneforall-kjl 0.1.1__py3-none-any.whl

OneForAll/common/tablib/tablib.py

@@ -0,0 +1,360 @@
+from collections import OrderedDict
+from .format import registry
+
+
+class Row:
+    """Internal Row object. Mainly used for filtering."""
+
+    __slots__ = ['_row', 'tags']
+
+    def __init__(self, row=None, tags=None):
+        if tags is None:
+            tags = list()
+        if row is None:
+            row = list()
+        self._row = list(row)
+        self.tags = list(tags)
+
+    def __iter__(self):
+        return (col for col in self._row)
+
+    def __len__(self):
+        return len(self._row)
+
+    def __repr__(self):
+        return repr(self._row)
+
+    def __getitem__(self, i):
+        return self._row[i]
+
+    def __setitem__(self, i, value):
+        self._row[i] = value
+
+    def __delitem__(self, i):
+        del self._row[i]
+
+    def __getstate__(self):
+
+        slots = dict()
+
+        for slot in self.__slots__:
+            attribute = getattr(self, slot)
+            slots[slot] = attribute
+
+        return slots
+
+    def __setstate__(self, state):
+        for (k, v) in list(state.items()):
+            setattr(self, k, v)
+
+    def rpush(self, value):
+        self.insert(len(self._row), value)
+
+    def append(self, value):
+        self.rpush(value)
+
+    def insert(self, index, value):
+        self._row.insert(index, value)
+
+    def __contains__(self, item):
+        return (item in self._row)
+
+    @property
+    def tuple(self):
+        """Tuple representation of :class:`Row`."""
+        return tuple(self._row)
+
+
+class Dataset:
+    """The :class:`Dataset` object is the heart of Tablib. It provides all core
+    functionality.
+
+    Usually you create a :class:`Dataset` instance in your main module, and append
+    rows as you collect data. ::
+
+        data = tablib.Dataset()
+        data.headers = ('name', 'age')
+
+        for (name, age) in some_collector():
+            data.append((name, age))
+
+
+    Setting columns is similar. The column data length must equal the
+    current height of the data and headers must be set. ::
+
+        data = tablib.Dataset()
+        data.headers = ('first_name', 'last_name')
+
+        data.append(('John', 'Adams'))
+        data.append(('George', 'Washington'))
+
+        data.append_col((90, 67), header='age')
+
+
+    You can also set rows and headers upon instantiation. This is useful if
+    dealing with dozens or hundreds of :class:`Dataset` objects. ::
+
+        headers = ('first_name', 'last_name')
+        data = [('John', 'Adams'), ('George', 'Washington')]
+
+        data = tablib.Dataset(*data, headers=headers)
+
+    :param \\*args: (optional) list of rows to populate Dataset
+    :param headers: (optional) list strings for Dataset header row
+    :param title: (optional) string to use as title of the Dataset
+
+
+    .. admonition:: Format Attributes Definition
+
+     If you look at the code, the various output/import formats are not
+     defined within the :class:`Dataset` object. To add support for a new format, see
+     :ref:`Adding New Formats <newformats>`.
+
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._data = list(Row(arg) for arg in args)
+        self.__headers = None
+
+        # ('title', index) tuples
+        self._separators = []
+
+        # (column, callback) tuples
+        self._formatters = []
+
+        self.headers = kwargs.get('headers')
+
+        self.title = kwargs.get('title')
+
+    def __len__(self):
+        return self.height
+
+    def _validate(self, row=None, col=None, safety=False):
+        """Assures size of every row in dataset is of proper proportions."""
+        if row:
+            is_valid = (len(row) == self.width) if self.width else True
+        elif col:
+            if len(col) < 1:
+                is_valid = True
+            else:
+                is_valid = (len(col) == self.height) if self.height else True
+        else:
+            is_valid = all(len(x) == self.width for x in self._data)
+
+        if is_valid:
+            return True
+        if not safety:
+            raise InvalidDimensions
+        return False
+
+    def _package(self, dicts=True, ordered=True):
+        """Packages Dataset into lists of dictionaries for transmission."""
+        # TODO: Dicts default to false?
+
+        _data = list(self._data)
+
+        if ordered:
+            dict_pack = OrderedDict
+        else:
+            dict_pack = dict
+
+        # Execute formatters
+        if self._formatters:
+            for row_i, row in enumerate(_data):
+                for col, callback in self._formatters:
+                    try:
+                        if col is None:
+                            for j, c in enumerate(row):
+                                _data[row_i][j] = callback(c)
+                        else:
+                            _data[row_i][col] = callback(row[col])
+                    except IndexError:
+                        raise InvalidDatasetIndex
+
+        if self.headers:
+            if dicts:
+                data = [dict_pack(list(zip(self.headers, data_row)))
+                        for data_row in _data]
+            else:
+                data = [list(self.headers)] + list(_data)
+        else:
+            data = [list(row) for row in _data]
+
+        return data
+
+    def _get_headers(self):
+        """An *optional* list of strings to be used for header rows and attribute names.
+
+        This must be set manually. The given list length must equal :class:`Dataset.width`.
+
+        """
+        return self.__headers
+
+    def _set_headers(self, collection):
+        """Validating headers setter."""
+        self._validate(collection)
+        if collection:
+            try:
+                self.__headers = list(collection)
+            except TypeError:
+                raise TypeError
+        else:
+            self.__headers = None
+
+    headers = property(_get_headers, _set_headers)
+
+    def _get_dict(self):
+        """A native Python representation of the :class:`Dataset` object. If headers have
+        been set, a list of Python dictionaries will be returned. If no headers have been
+        set, a list of tuples (rows) will be returned instead.
+
+        A dataset object can also be imported by setting the `Dataset.dict` attribute: ::
+
+            data = tablib.Dataset()
+            data.dict = [{'age': 90, 'first_name': 'Kenneth', 'last_name': 'Reitz'}]
+
+        """
+        return self._package()
+
+    def _set_dict(self, pickle):
+        """A native Python representation of the Dataset object. If headers have been
+        set, a list of Python dictionaries will be returned. If no headers have been
+        set, a list of tuples (rows) will be returned instead.
+
+        A dataset object can also be imported by setting the :class:`Dataset.dict` attribute. ::
+
+            data = tablib.Dataset()
+            data.dict = [{'age': 90, 'first_name': 'Kenneth', 'last_name': 'Reitz'}]
+
+        """
+
+        if not len(pickle):
+            return
+
+        # if list of rows
+        if isinstance(pickle[0], list):
+            self.wipe()
+            for row in pickle:
+                self.append(Row(row))
+
+        # if list of objects
+        elif isinstance(pickle[0], dict):
+            self.wipe()
+            self.headers = list(pickle[0].keys())
+            for row in pickle:
+                self.append(Row(list(row.values())))
+        else:
+            raise UnsupportedFormat
+
+    dict = property(_get_dict, _set_dict)
+
+    @property
+    def height(self):
+        """The number of rows currently in the :class:`Dataset`.
+           Cannot be directly modified.
+        """
+        return len(self._data)
+
+    @property
+    def width(self):
+        """The number of columns currently in the :class:`Dataset`.
+           Cannot be directly modified.
+        """
+
+        try:
+            return len(self._data[0])
+        except IndexError:
+            try:
+                return len(self.headers)
+            except TypeError:
+                return 0
+
+    def export(self, format, **kwargs):
+        """
+        Export :class:`Dataset` object to `format`.
+
+        :param format: export format
+        :param kwargs: (optional) custom configuration to the format `export_set`.
+        """
+        fmt = registry.get_format(format)
+        if not hasattr(fmt, 'export_set'):
+            raise Exception('Format {} cannot be exported.'.format(format))
+
+        return fmt.export_set(self, **kwargs)
+
+    # ----
+    # Rows
+    # ----
+
+    def insert(self, index, row, tags=None):
+        """Inserts a row to the :class:`Dataset` at the given index.
+
+        Rows inserted must be the correct size (height or width).
+
+        The default behaviour is to insert the given row to the :class:`Dataset`
+        object at the given index.
+       """
+
+        if tags is None:
+            tags = list()
+        self._validate(row)
+        self._data.insert(index, Row(row, tags=tags))
+
+    def rpush(self, row, tags=None):
+        """Adds a row to the end of the :class:`Dataset`.
+        See :class:`Dataset.insert` for additional documentation.
+        """
+
+        if tags is None:
+            tags = list()
+        self.insert(self.height, row=row, tags=tags)
+
+    def append(self, row, tags=None):
+        """Adds a row to the :class:`Dataset`.
+        See :class:`Dataset.insert` for additional documentation.
+        """
+
+        if tags is None:
+            tags = list()
+        self.rpush(row, tags)
+
+    def extend(self, rows, tags=None):
+        """Adds a list of rows to the :class:`Dataset` using
+        :class:`Dataset.append`
+        """
+
+        if tags is None:
+            tags = list()
+        for row in rows:
+            self.append(row, tags)
+
+    # ----
+    # Misc
+    # ----
+
+    def remove_duplicates(self):
+        """Removes all duplicate rows from the :class:`Dataset` object
+        while maintaining the original order."""
+        seen = set()
+        self._data[:] = [row for row in self._data if
+                         not (tuple(row) in seen or seen.add(tuple(row)))]
+
+    def wipe(self):
+        """Removes all content and headers from the :class:`Dataset` object."""
+        self._data = list()
+        self.__headers = None
+
+
+registry.register_builtins()
+
+
+class InvalidDimensions(Exception):
+    """Invalid size"""
+
+
+class InvalidDatasetIndex(Exception):
+    """Outside of Dataset size"""
+
+
+class UnsupportedFormat(NotImplementedError):
+    """Format is not supported"""

OneForAll/common/tldextract.py

@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*-
+"""`tldextract` accurately separates the gTLD or ccTLD (generic or country code
+top-level domain) from the registered domain and subdomains of a URL.
+
+    >>> import tldextract
+
+    >>> tldextract.extract('http://forums.news.cnn.com/')
+    ExtractResult(subdomain='forums.news', domain='cnn', suffix='com')
+
+    >>> tldextract.extract('http://forums.bbc.co.uk/') # United Kingdom
+    ExtractResult(subdomain='forums', domain='bbc', suffix='co.uk')
+
+    >>> tldextract.extract('http://www.worldbank.org.kg/') # Kyrgyzstan
+    ExtractResult(subdomain='www', domain='worldbank', suffix='org.kg')
+
+`ExtractResult` is a namedtuple, so it's simple to access the parts you want.
+
+    >>> ext = tldextract.extract('http://forums.bbc.co.uk')
+    >>> (ext.subdomain, ext.domain, ext.suffix)
+    ('forums', 'bbc', 'co.uk')
+    >>> # rejoin subdomain and domain
+    >>> '.'.join(ext[:2])
+    'forums.bbc'
+    >>> # a common alias
+    >>> ext.registered_domain
+    'bbc.co.uk'
+
+Note subdomain and suffix are _optional_. Not all URL-like inputs have a
+subdomain or a valid suffix.
+
+    >>> tldextract.extract('google.com')
+    ExtractResult(subdomain='', domain='google', suffix='com')
+
+    >>> tldextract.extract('google.notavalidsuffix')
+    ExtractResult(subdomain='google', domain='notavalidsuffix', suffix='')
+
+    >>> tldextract.extract('http://127.0.0.1:8080/deployed/')
+    ExtractResult(subdomain='', domain='127.0.0.1', suffix='')
+
+If you want to rejoin the whole namedtuple, regardless of whether a subdomain
+or suffix were found:
+
+    >>> ext = tldextract.extract('http://127.0.0.1:8080/deployed/')
+    >>> # this has unwanted dots
+    >>> '.'.join(ext)
+    '.127.0.0.1.'
+"""
+
+
+import os
+import re
+import json
+import collections
+from urllib.parse import scheme_chars
+from functools import wraps
+
+import idna
+
+from common import utils
+
+IP_RE = re.compile(r'^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$')  # pylint: disable=line-too-long
+
+SCHEME_RE = re.compile(r'^([' + scheme_chars + ']+:)?//')
+
+
+class ExtractResult(collections.namedtuple('ExtractResult', 'subdomain domain suffix')):
+    """namedtuple of a URL's subdomain, domain, and suffix."""
+
+    # Necessary for __dict__ member to get populated in Python 3+
+    __slots__ = ()
+
+    @property
+    def registered_domain(self):
+        """
+        Joins the domain and suffix fields with a dot, if they're both set.
+
+        >>> extract('http://forums.bbc.co.uk').registered_domain
+        'bbc.co.uk'
+        >>> extract('http://localhost:8080').registered_domain
+        ''
+        """
+        if self.domain and self.suffix:
+            return self.domain + '.' + self.suffix
+        return ''
+
+    @property
+    def fqdn(self):
+        """
+        Returns a Fully Qualified Domain Name, if there is a proper domain/suffix.
+
+        >>> extract('http://forums.bbc.co.uk/path/to/file').fqdn
+        'forums.bbc.co.uk'
+        >>> extract('http://localhost:8080').fqdn
+        ''
+        """
+        if self.domain and self.suffix:
+            # self is the namedtuple (subdomain domain suffix)
+            return '.'.join(i for i in self if i)
+        return ''
+
+    @property
+    def ipv4(self):
+        """
+        Returns the ipv4 if that is what the presented domain/url is
+
+        >>> extract('http://127.0.0.1/path/to/file').ipv4
+        '127.0.0.1'
+        >>> extract('http://127.0.0.1.1/path/to/file').ipv4
+        ''
+        >>> extract('http://256.1.1.1').ipv4
+        ''
+        """
+        if not (self.suffix or self.subdomain) and IP_RE.match(self.domain):
+            return self.domain
+        return ''
+
+
+class TLDExtract(object):
+    """A callable for extracting, subdomain, domain, and suffix components from a URL."""
+
+    def __init__(self, cache_file=None):
+        """
+        Constructs a callable for extracting subdomain, domain, and suffix
+        components from a URL.
+        """
+
+        self.cache_file = os.path.expanduser(cache_file or '')
+        self._extractor = None
+
+    def __call__(self, url):
+        """
+        Takes a string URL and splits it into its subdomain, domain, and
+        suffix (effective TLD, gTLD, ccTLD, etc.) component.
+
+        >>> ext = TLDExtract()
+        >>> ext('http://forums.news.cnn.com/')
+        ExtractResult(subdomain='forums.news', domain='cnn', suffix='com')
+        >>> ext('http://forums.bbc.co.uk/')
+        ExtractResult(subdomain='forums', domain='bbc', suffix='co.uk')
+        """
+        netloc = SCHEME_RE.sub("", url) \
+            .partition("/")[0] \
+            .partition("?")[0] \
+            .partition("#")[0] \
+            .split("@")[-1] \
+            .partition(":")[0] \
+            .strip() \
+            .rstrip(".")
+
+        labels = netloc.split(".")
+
+        translations = [_decode_punycode(label) for label in labels]
+        suffix_index = self._get_tld_extractor().suffix_index(translations)
+
+        suffix = ".".join(labels[suffix_index:])
+        if not suffix and netloc and utils.looks_like_ip(netloc):
+            return ExtractResult('', netloc, '')
+
+        subdomain = ".".join(labels[:suffix_index - 1]) if suffix_index else ""
+        domain = labels[suffix_index - 1] if suffix_index else ""
+        return ExtractResult(subdomain, domain, suffix)
+
+    @property
+    def tlds(self):
+        return self._get_tld_extractor().tlds
+
+    def _get_tld_extractor(self):
+        """Get or compute this object's TLDExtractor. Looks up the TLDExtractor
+        in roughly the following order, based on the settings passed to
+        __init__:
+
+        1. Memoized on `self`
+        2. Local system cache file"""
+        # pylint: disable=no-else-return
+
+        if self._extractor:
+            return self._extractor
+        tlds = self._get_cached_tlds()
+        if tlds:
+            self._extractor = _PublicSuffixListTLDExtractor(tlds)
+            return self._extractor
+        else:
+            raise Exception("tlds is empty, cannot proceed without tlds.")
+
+    def _get_cached_tlds(self):
+        """Read the local TLD cache file. Returns None on IOError or other
+        error, or if this object is not set to use the cache
+        file."""
+        if not self.cache_file:
+            return None
+
+        with open(self.cache_file) as cache_file:
+            return json.loads(cache_file.read())
+
+
+TLD_EXTRACTOR = TLDExtract()
+
+
+@wraps(TLD_EXTRACTOR.__call__)
+def extract(url):
+    return TLD_EXTRACTOR(url)
+
+
+class _PublicSuffixListTLDExtractor(object):
+    """Wrapper around this project's main algo for PSL
+    lookups.
+    """
+    def __init__(self, tlds):
+        self.tlds = frozenset(tlds)
+
+    def suffix_index(self, lower_spl):
+        """Returns the index of the first suffix label.
+        Returns len(spl) if no suffix is found
+        """
+        length = len(lower_spl)
+        for i in range(length):
+            maybe_tld = '.'.join(lower_spl[i:])
+            exception_tld = '!' + maybe_tld
+            if exception_tld in self.tlds:
+                return i + 1
+
+            if maybe_tld in self.tlds:
+                return i
+
+            wildcard_tld = '*.' + '.'.join(lower_spl[i + 1:])
+            if wildcard_tld in self.tlds:
+                return i
+
+        return length
+
+
+def _decode_punycode(label):
+    lowered = label.lower()
+    looks_like_puny = lowered.startswith('xn--')
+    if looks_like_puny:
+        try:
+            return idna.decode(label.encode('ascii')).lower()
+        except (UnicodeError, IndexError):
+            pass
+    return lowered