text:
Diese Liste gibt einen Überblick über die Orden und Ehrenzeichen der Republik Slowenien.

 Ehrenzeichen der Freiheit der Republik Slowenien (Častni znak svobode Republike Slovenije), 1992 gestiftet, in drei Ordensstufen verliehen:
 Goldenes Ehrenzeichen der Freiheit (Zlati častni znak svobode Republike Slovenije)
 Silbernes Ehrenzeichen der Freiheit (Srebrni častni znak svobode Republike Slovenije)
 Ehrenzeichen der Freiheit (Častni znak svobode Republike Slovenije)
 Orden für außergewöhnliche Verdienste um die Republik Slowenien (Red za izredne zasluge)
 Verdienstorden (Red za zasluge), in drei Ordensstufen verliehen:
 Goldener Verdienstorden (Zlati red za zasluge)
 Silberner Verdienstorden (Srebrni red za zasluge)
 Verdienstorden (Red za zasluge)
 Verdienstmedaille (Medalja za zasluge)
 Tapferkeitsmedaille (Medalje za hrabrost)
 Medaille für ehrenhaftes Handeln (Medalja za častna dejanja)

Fußnoten

Slowenien

redpajama_set_name: RedPajamaWikipedia


Message: Thanks very much for the interesting mail. I will look into it!
During my research I have found many different spellings of Hebblethwaite, Heblethwayte etc. (Check out the Boynten family page! Great pictures of the crest.) In addition I believe that some folks find "Hebblethwaite" too cumbersome, Heblet would be a good shortened form. My grandfather, for example, changed his name to Heller, he had four sons, three remained Hellers as their families remain today, my father, the fourth son, changed his name back to Hebblethwaite. It is very difficult to follow any name changes going back past more than two generations.
As to the two charts I gave to the Hebblethwaite page..... A second cousin once removed, Keith Hebblethwaite did most of this research " on foot" back in the 50s, he travelled, procured church recods etc. He produced several hand written charts of which these are two. With the help of a local Yorkshire gen. research company and my own efforts I have tried to confirm as much as possible. My second cousin was a little eccentric, he often wore Victorian clothes and a top hat! He was very interested in Sir Thomas Hebblethwaite (spelling?) 1628-68 who married Barbara Marwood. The Marwood family has connections going back to the Percies of Northumberland (Hotspur fame!).


text:
SYNONYM

#### According to
Index Fungorum

#### Published in
Flora of the Guianas (Koenigstein), Series E: Fungi and Lichens. Fascicle 1. Pyxinaceae 11 (1987)

#### Original name
Gassicurtia coccinea Fée

### Remarks
null

redpajama_set_name: RedPajamaGithub


text:
Trump Blinks on Tech Tariffs, Apple Stock Soars (Update)
By Kate Kozuch 13 August 2019
The USTR issued a pause on pricier tech
(Image credit: Cheriss May/NurPhoto via Getty Images)
Update 4:00 pm ET: We've added a reference to the list of items affected by the delay, released after the USTR's initial announcement along with a comment by the president and a comment from the CTA.
The United States Trade Representative (USTR) announced today that it will delay tariffs on certain products imported from China, including cell phones, laptops, and video game consoles, until December 15.
On August 1, President Trump announced a 10% tariff on the remaining $300 billion worth of Chinese imports—notably centerpiece technology—excluded from the original trade talks. He said the new tariff would go into effect on September 1.
During the USTR's public comment and hearing process on the proposed expansion, "it was determined that the tariff should be delayed."
"Certain products are being removed from the tariff list based on health, safety, national security and other factors and will not face additional tariffs of 10 percent," the USTR said.
You can read the entire list of items included in the December 15 tariff delay here.
You'll notice smartwatches, wearable fitness trackers, and Bluetooth audio devices are not on the December 15 delay list. Tariffs on those items will go into effect on September 1, as scheduled.
"Next month, we'll begin to pay more for some of our favorite tech devices," said Gary Shapiro, president and CEO of the Consumer Technology Association (CTA).
The December 15 delay allows some devices to reach the U.S. without tariffs in time for the holiday season, which was a prominent point of concern for game console manufacturers. According to a joint letter filed by Sony, Nintendo, and Microsoft in June, a tariff-caused rise in cost would have "likely put a new video game console out of reach for many American families," during the 2019 holidays.
Speaking to reporters, the president confirmed that the holiday shopping season influenced the decision to delay the tariffs. "We've delayed it so it won't be relevant to the Christmas shopping season," Trump said. Previously, the president insisted that China is paying the cost of his tariffs, not U.S. consumers — a claim most economists dispute.
"Tariffs are taxes. The Chinese government doesn't pay for them – Americans bear the burden," Shapiro said.
The delay incited an instant sign of relief for manufacturers and retailers. Following the announcement, Apple shares (which had plummeted after Trump's August 1 tweets) rose 5% higher and Best Buy's increased more than 8%.
In the press release the USTR said it will specify which items are affected by the delay. We will update this story as it develops.
iPhone 11: Release Date, Specs, Price and Leaks
US Senator Says Wireless Carriers Helping Trump Build 'Surveillance State'
'iPhone 11 Pro' May Be Apple's Ultimate Smartphone

redpajama_set_name: RedPajamaCommonCrawl


text:
"""
Records from :ref:`equipment-database`\'s or :ref:`connections-database`\'s.
"""
from __future__ import unicode_literals
import json
import datetime
from enum import Enum
from xml.etree.cElementTree import Element
from collections import OrderedDict
try:
    from collections.abc import Mapping
except ImportError:
    from collections import Mapping  # Python 2.7

from dateutil.relativedelta import relativedelta

from .utils import (
    convert_to_enum,
    convert_to_date,
)
from .constants import (
    Parity,
    StopBits,
    DataBits,
    Backend,
    MSLInterface,
    LF,
    CR,
)
from .factory import (
    connect,
    find_interface,
)

class RecordDict(Mapping):

    __slots__ = '_mapping'

    def __delattr__(self, item):
        # override to raise TypeError and to control the error message
        self._raise('item deletion')

    def __getattr__(self, item):
        return self._mapping[item]

    def __getitem__(self, item):
        return self._mapping[item]

    def __init__(self, dictionary):
        """A read-only dictionary that supports attribute access via a key lookup."""

        if not isinstance(dictionary, dict):
            raise TypeError("Can only create a 'RecordDict' from a dict")

        # recursively make all values that are a dict a RecordDict
        for k, v in dictionary.items():
            if isinstance(v, dict):
                dictionary[k] = RecordDict(v)
            if isinstance(v, (list, tuple)):
                def deep_tuple(a):
                    return tuple(map(deep_tuple, a)) if isinstance(a, (list, tuple)) else a
                dictionary[k] = deep_tuple(v)

        super(RecordDict, self).__setattr__('_mapping', dictionary)

    def __iter__(self):
        return iter(self._mapping)

    def __len__(self):
        return len(self._mapping)

    def __repr__(self):
        return 'RecordDict<{}>'.format(self._mapping)

    def __setattr__(self, key, value):
        # override to raise TypeError and to control the error message
        self._raise('item assignment')

    def _raise(self, message):
        raise TypeError('A {!r} object does not support {}'.format(self.__class__.__name__, message))

    def clear(self):
        self._raise('clearing')

    def copy(self):
        """:class:`RecordDict`: Return a copy of the :class:`RecordDict`."""
        return RecordDict(self._mapping.copy())

    def fromkeys(self, *args, **kwargs):
        self._raise('fromkeys')

    def pop(self, *args, **kwargs):
        self._raise('popping')

    def popitem(self):
        self._raise('popitem')

    def setdefault(self, *args, **kwargs):
        self._raise('setdefault')

    def update(self, *args, **kwargs):
        self._raise('updating')

    def to_xml(self, tag='RecordDict'):
        """Convert the :class:`RecordDict` to an XML :class:`~xml.etree.ElementTree.Element`

        Parameters
        ----------
        tag : :class:`str`
            The name of the :class:`~xml.etree.ElementTree.Element`.

        Returns
        -------
        :class:`~xml.etree.ElementTree.Element`
            The :class:`RecordDict` as an XML :class:`~xml.etree.ElementTree.Element`.
        """
        root = Element(tag)
        for k, v in self._mapping.items():
            if isinstance(v, RecordDict):
                element = v.to_xml(tag=k)
            else:
                element = Element(k)
                element.text = repr(v)
            root.append(element)
        return root

    def to_json(self):
        """:class:`dict`: Convert the :class:`RecordDict` to be JSON_ serializable.

        .. _JSON: https://www.json.org/
        """
        root = dict()
        for k, v in self._mapping.items():
            if isinstance(v, RecordDict):
                root[k] = v.to_json()
            elif isinstance(v, Enum):
                root[k] = v.name
            else:
                try:
                    json.dumps(v)
                except TypeError:
                    root[k] = str(v)  # cannot be serialized
                else:
                    root[k] = v  # can be serialized
        return root

class Record(object):

    def to_dict(self):
        """:class:`dict`: Convert the Record to a :class:`dict`."""
        return dict((name, getattr(self, name)) for name in self.__slots__)

    def to_json(self):
        """:class:`dict`: Convert the Record to be JSON_ serializable.

        This differs from :meth:`to_dict` such that all values that are not
        JSON_ serializable, like :class:`datetime.date` objects, are
        converted to a :class:`str`.

        .. _JSON: https://www.json.org/
        """
        raise NotImplementedError

    def to_xml(self):
        """:class:`~xml.etree.ElementTree.Element`: Convert the Record to an XML
        :class:`~xml.etree.ElementTree.Element`."""
        raise NotImplementedError

    @staticmethod
    def _dict_to_str(dict_):
        if dict_:
            return '\n' + '\n'.join('    {}: {!r}'.format(k, v) for k, v in sorted(dict_.items()))
        else:
            return 'None'

    @staticmethod
    def _list_to_str(list_):
        if list_:
            return '\n' + '\n'.join(['    {}'.format(line) for c in list_
                                     for line in repr(c).splitlines()])
        else:
            return 'None'

class EquipmentRecord(Record):

    __slots__ = ('alias', 'calibrations', 'category', 'connection', 'description',
                 'is_operable', 'maintenances', 'manufacturer', 'model',
                 'serial', 'team', 'unique_key', 'user_defined')

    def __init__(self, alias='', calibrations=None, category='', connection=None,
                 description='', is_operable=False, maintenances=None,
                 manufacturer='', model='', serial='', team='', unique_key='', **user_defined):
        """Contains the information about an equipment record in an :ref:`equipment-database`.

        Parameters
        ----------
        alias : :class:`str`
            An alias to use to reference this equipment by.
        calibrations : :class:`list` of :class:`.CalibrationRecord`
            The calibration history of the equipment.
        category : :class:`str`
            The category (e.g., Laser, DMM) that the equipment belongs to.
        connection : :class:`.ConnectionRecord`
            The information necessary to communicate with the equipment.
        description : :class:`str`
            A description about the equipment.
        is_operable : :class:`bool`
            Whether the equipment is able to be used.
        maintenances : :class:`list` of :class:`.MaintenanceRecord`
            The maintenance history of the equipment.
        manufacturer : :class:`str`
            The name of the manufacturer of the equipment.
        model : :class:`str`
            The model number of the equipment.
        serial : :class:`str`
            The serial number (or unique identifier) of the equipment.
        team : :class:`str`
            The team (e.g., Light Standards) that the equipment belongs to.
        unique_key : :class:`str`
            The key that uniquely identifies the equipment record in a database.
        **user_defined
            All additional key-value pairs are added to the :attr:`.user_defined` attribute.
        """

        self.alias = alias  # the alias should be of type str, but this is up to the user
        """:class:`str`: An alias to use to reference this equipment by.

        The `alias` can be defined in 4 ways:

            * by specifying it when the EquipmentRecord is created
            * by setting the value after the EquipmentRecord has been created
            * in the **<equipment>** XML tag in a :ref:`configuration-file`
            * in the **Properties** field in a :ref:`connections-database`

        """

        self.calibrations = self._set_calibrations(calibrations)
        """:class:`tuple` of :class:`.CalibrationRecord`: The calibration history of the equipment."""

        self.category = '{}'.format(category)
        """:class:`str`: The category (e.g., Laser, DMM) that the equipment belongs to."""

        self.description = '{}'.format(description)
        """:class:`str`: A description about the equipment."""

        self.is_operable = bool(is_operable)
        """:class:`bool`: Whether the equipment is able to be used."""

        self.maintenances = self._set_maintenances(maintenances)
        """:class:`tuple` of :class:`.MaintenanceRecord`: The maintenance history of the equipment."""

        self.manufacturer = '{}'.format(manufacturer)
        """:class:`str`: The name of the manufacturer of the equipment."""

        self.model = '{}'.format(model)
        """:class:`str`: The model number of the equipment."""

        self.serial = '{}'.format(serial)
        """:class:`str`: The serial number (or unique identifier) of the equipment."""

        # requires self.manufacturer, self.model and self.serial to be already defined
        self.connection = self._set_connection(connection)
        """:class:`.ConnectionRecord`: The information necessary to communicate with the equipment."""

        # cache this value because __str__ is called a lot during logging
        self._str = 'EquipmentRecord<{}|{}|{}>'.format(self.manufacturer, self.model, self.serial)

        self.team = '{}'.format(team)
        """:class:`str`: The team (e.g., Light Standards) that the equipment belongs to."""

        self.unique_key = '{}'.format(unique_key)
        """:class:`str`: The key that uniquely identifies the equipment record in a database."""

        try:
            # a 'user_defined' kwarg was explicitly defined
            ud = user_defined.pop('user_defined')
        except KeyError:
            ud = user_defined
        else:
            ud.update(**user_defined)  # the user_defined dict might still contain other key-value pairs

        self.user_defined = RecordDict(ud)
        """:class:`.RecordDict`: User-defined, key-value pairs."""

    def __repr__(self):
        calibrations = self._list_to_str(self.calibrations)
        maintenances = self._list_to_str(self.maintenances)
        user_defined = self._dict_to_str(self.user_defined)

        if self.connection:
            connection = '\n    ' + '\n    '.join(repr(self.connection).splitlines())
        else:
            connection = 'None'

        return 'EquipmentRecord\n' \
               '  alias: {!r}\n' \
               '  calibrations: {}\n' \
               '  category: {!r}\n' \
               '  connection: {}\n' \
               '  description: {!r}\n' \
               '  is_operable: {}\n' \
               '  maintenances: {}\n' \
               '  manufacturer: {!r}\n' \
               '  model: {!r}\n' \
               '  serial: {!r}\n' \
               '  team: {!r}\n' \
               '  unique_key: {!r}\n' \
               '  user_defined: {}'.format(self.alias, calibrations, self.category, connection,
                                           self.description, self.is_operable, maintenances,
                                           self.manufacturer, self.model, self.serial,
                                           self.team, self.unique_key, user_defined)

    def __str__(self):
        return self._str

    def __setattr__(self, name, value):
        try:
            # once the `user_defined` attribute is created the class becomes read only
            # (except for the `alias` attribute which can be changed at any time)
            self.user_defined
        except AttributeError:
            super(EquipmentRecord, self).__setattr__(name, value)
        else:
            if name == 'alias':  # only allow the alias to be modified
                super(EquipmentRecord, self).__setattr__(name, value)
            else:
                raise TypeError("An 'EquipmentRecord' cannot be modified. "
                                "Cannot set {!r} to {!r}".format(name, value))

    def connect(self, demo=None):
        """Establish a connection to the equipment.

        Calls the :func:`~msl.equipment.factory.connect` function.

        Parameters
        ----------
        demo : :class:`bool`, optional
            Whether to simulate a connection to the equipment by opening
            a connection in demo mode. This allows you to test your code
            if the equipment is not physically connected to a computer.

            If :data:`None` then the `demo` value is determined from the
            :attr:`~.config.Config.DEMO_MODE` attribute.

        Returns
        -------
        A :class:`~msl.equipment.connection.Connection` subclass.
        """
        return connect(self, demo=demo)

    def is_calibration_due(self, months=0):
        """Whether the equipment needs to be re-calibrated.

        Parameters
        ----------
        months : :class:`int`, optional
            The number of months to add to today's date to determine if
            the equipment needs to be re-calibrated within a certain amount
            of time. For example, if ``months = 6`` then that is a way of
            asking *"is a re-calibration due within the next 6 months?"*.

        Returns
        -------
        :class:`bool`
            :data:`True` if the equipment needs to be re-calibrated, :data:`False`
            if it does not need to be re-calibrated (or it has never been calibrated).
        """
        next_date = self.next_calibration_date()
        if next_date is None:
            return False

        ask_date = datetime.date.today() + relativedelta(months=max(0, int(months)))
        return ask_date > next_date

    @property
    def latest_calibration(self):
        """:class:`.CalibrationRecord`: The latest calibration or :data:`None`
        if the equipment has never been calibrated."""
        latest = None
        date = datetime.date(datetime.MINYEAR, 1, 1)
        for report in self.calibrations:
            # the calibration date gets precedence over the report date
            if report.calibration_date > date:
                date = report.calibration_date
                latest = report
            elif report.report_date > date:
                date = report.report_date
                latest = report
        return latest

    def next_calibration_date(self):
        """The date that the next calibration is due.

        Returns
        -------
        :class:`datetime.date`
            The next calibration date (or :data:`None` if the equipment has
            never been calibrated or if it is no longer in operation).
        """
        if not self.is_operable:
            return None

        report = self.latest_calibration
        if report is None or report.calibration_cycle <= 0:
            return None

        # the calibration date gets precedence over the report date
        if report.calibration_date.year != datetime.MINYEAR:
            date = report.calibration_date
        elif report.report_date.year != datetime.MINYEAR:
            date = report.report_date
        else:
            return None

        years = int(report.calibration_cycle)
        months = int(round(12 * (report.calibration_cycle - years)))
        return date + relativedelta(years=years, months=months)

    def to_dict(self):
        """Convert this :class:`EquipmentRecord` to a :class:`dict`.

        Returns
        -------
        :class:`dict`
            The :class:`EquipmentRecord` as a :class:`dict`.
        """
        return {
            'alias': self.alias,
            'calibrations': tuple(cr.to_dict() for cr in self.calibrations),
            'category': self.category,
            'connection': None if self.connection is None else self.connection.to_dict(),
            'description': self.description,
            'is_operable': self.is_operable,
            'maintenances': tuple(mh.to_dict() for mh in self.maintenances),
            'manufacturer': self.manufacturer,
            'model': self.model,
            'serial': self.serial,
            'team': self.team,
            'unique_key': self.unique_key,
            'user_defined': self.user_defined,
        }

    def to_json(self):
        """Convert this :class:`EquipmentRecord` to be JSON_ serializable.

        .. _JSON: https://www.json.org/

        Returns
        -------
        :class:`dict`
            The :class:`EquipmentRecord` as a JSON_\\-serializable object.
        """
        return {
            'alias': self.alias,
            'calibrations': tuple(cr.to_json() for cr in self.calibrations),
            'category': self.category,
            'connection': None if self.connection is None else self.connection.to_json(),
            'description': self.description,
            'is_operable': self.is_operable,
            'maintenances': tuple(mh.to_json() for mh in self.maintenances),
            'manufacturer': self.manufacturer,
            'model': self.model,
            'serial': self.serial,
            'team': self.team,
            'unique_key': self.unique_key,
            'user_defined': self.user_defined.to_json(),
        }

    def to_xml(self):
        """Convert this :class:`EquipmentRecord` to an XML :class:`~xml.etree.ElementTree.Element`.

        Returns
        -------
        :class:`~xml.etree.ElementTree.Element`
            The :class:`EquipmentRecord` as an XML element.
        """
        root = Element('EquipmentRecord')
        for name in EquipmentRecord.__slots__:
            element = Element(name)
            if name == 'connection':
                if self.connection is not None:
                    element.append(self.connection.to_xml())
            elif name == 'maintenances':
                for mh in self.maintenances:
                    element.append(mh.to_xml())
            elif name == 'calibrations':
                for cr in self.calibrations:
                    element.append(cr.to_xml())
            elif name == 'user_defined':
                for key, value in sorted(self.user_defined.items()):
                    prop = Element(key)
                    prop.text = '{}'.format(value)
                    element.append(prop)
            else:
                element.text = '{}'.format(getattr(self, name))
            root.append(element)
        return root

    def _set_connection(self, record):
        if not record:
            return None

        if not isinstance(record, ConnectionRecord):
            if isinstance(record, dict):
                record = ConnectionRecord(**record)
            else:
                raise TypeError('Must pass in a ConnectionRecord object. Got {!r}'.format(record))

        # ensure that the manufacturer, model and serial match
        for item in ('manufacturer', 'model', 'serial'):
            r, s = getattr(record, item), getattr(self, item)
            if not r:  # then it was not set in the ConnectionRecord
                setattr(record, item, s)
            elif r != s:
                raise ValueError('ConnectionRecord.{0} ({1}) != EquipmentRecord.{0} ({2})'.format(item, r, s))

        return record

    @staticmethod
    def _set_calibrations(calibrations):
        if calibrations is None:
            return tuple()

        reports = []
        for report in calibrations:
            if isinstance(report, CalibrationRecord):
                reports.append(report)
            elif isinstance(report, dict):
                report['measurands'] = [MeasurandRecord(**m) for m in report['measurands']]
                reports.append(CalibrationRecord(**report))
            else:
                raise TypeError("Invalid data type {!r} for creating a 'CalibrationRecord'".format(type(report)))
        return tuple(reports)

    @staticmethod
    def _set_maintenances(maintenances):
        if maintenances is None:
            return tuple()

        history = []
        for maintenance in maintenances:
            if isinstance(maintenance, MaintenanceRecord):
                history.append(maintenance)
            elif isinstance(maintenance, dict):
                history.append(MaintenanceRecord(**maintenance))
            else:
                raise TypeError("Invalid data type {!r} for creating a 'MaintenanceRecord'".format(type(maintenance)))
        return tuple(history)

class ConnectionRecord(Record):

    __slots__ = ('address', 'backend', 'interface', 'manufacturer', 'model', 'properties', 'serial')

    _LF = ['\\n', "'\\n'", '"\\n"', "b'\\n'", b'\n', b'\\n', b"b'\\n'"]
    _CR = ['\\r', "'\\r'", '"\\r"', "b'\\r'", b'\r', b'\\r', b"b'\\r'"]
    _CRLF = ['\\r\\n', "'\\r\\n'", '"\\r\\n"', "b'\\r\\n'", b'\r\n', b'\\r\\n', b"b'\r\n'", b"b'\\r\\n'"]

    def __init__(self, address='', backend=Backend.MSL, interface=None, manufacturer='',
                 model='', serial='', **properties):
        """Contains the information about a connection record in a :ref:`connections-database`.

        Parameters
        ----------
        address : :class:`str`
            The address to use for the connection (see :ref:`address-syntax` for examples).
        backend : :class:`str`, :class:`int`, or :class:`.Backend`
            The backend to use to communicate with the equipment. The value must be able to
            be converted to a :class:`.Backend` enum.
        interface : :class:`str`, :class:`int`, or :class:`.MSLInterface`
            The interface to use to communicate with the equipment. If :data:`None` then
            determines the `interface` based on the value of `address`. If specified then
            the value must be able to be converted to a :class:`.MSLInterface` enum.
        manufacturer : :class:`str`
            The name of the manufacturer of the equipment.
        model : :class:`str`
            The model number of the equipment.
        serial : :class:`str`
            The serial number (or unique identifier) of the equipment.
        properties
            Additional key-value pairs that are required to communicate with the equipment.
        """
        self.address = '{}'.format(address)
        """:class:`str`: The address to use for the connection (see :ref:`address-syntax` for examples)."""

        self.backend = convert_to_enum(backend, Backend)
        """:class:`.Backend`: The backend to use to communicate with the equipment."""

        if interface:
            self.interface = convert_to_enum(interface, MSLInterface, to_upper=True)
        elif not address or self.backend != Backend.MSL:
            self.interface = MSLInterface.NONE
        else:
            self.interface = find_interface(address)
        """:class:`.MSLInterface`: The interface that is used for the communication system that
        transfers data between a computer and the equipment (only used if the :attr:`.backend`
        is equal to :attr:`~.Backend.MSL`)."""

        self.manufacturer = '{}'.format(manufacturer)
        """:class:`str`: The name of the manufacturer of the equipment."""

        self.model = '{}'.format(model)
        """:class:`str`: The model number of the equipment."""

        self.properties = self._set_properties(properties)
        """:class:`dict`: Additional key-value pairs that are required to communicate with the equipment.

        For example, communicating via RS-232 may require::

            {'baud_rate': 19200, 'parity': 'even'}

        See the :ref:`connections-database` for examples on how to set the `properties`.
        """

        self.serial = '{}'.format(serial)
        """:class:`str`: The serial number (or unique identifier) of the equipment."""

    def __repr__(self):
        props = self._dict_to_str(dict((k, self.properties[k]) for k in sorted(self.properties)))
        return 'ConnectionRecord\n' \
               '  address: {!r}\n' \
               '  backend: {!r}\n' \
               '  interface: {!r}\n' \
               '  manufacturer: {!r}\n' \
               '  model: {!r}\n' \
               '  properties: {}\n' \
               '  serial: {!r}'.format(self.address, self.backend, self.interface,
                                       self.manufacturer, self.model, props, self.serial)

    def __str__(self):
        return 'ConnectionRecord<{}|{}|{}>'.format(self.manufacturer, self.model, self.serial)

    def to_json(self):
        """Convert this :class:`ConnectionRecord` to be JSON_ serializable.

        .. _JSON: https://www.json.org/

        Returns
        -------
        :class:`dict`
            The :class:`ConnectionRecord` as a JSON_\\-serializable object.
        """
        props = dict()
        for k, v in self.properties.items():
            if isinstance(v, Enum):
                props[k] = v.name
            else:
                try:
                    json.dumps(v)
                except TypeError:
                    props[k] = repr(v)  # cannot be serialized
                else:
                    props[k] = v  # can be serialized

        return {
            'address': self.address,
            'backend': self.backend.name,
            'interface': self.interface.name,
            'manufacturer': self.manufacturer,
            'model': self.model,
            'properties': props,
            'serial': self.serial,
        }

    def to_xml(self):
        """Convert this :class:`ConnectionRecord` to an XML :class:`~xml.etree.ElementTree.Element`.

        Returns
        -------
        :class:`~xml.etree.ElementTree.Element`
            The :class:`ConnectionRecord` as a XML :class:`~xml.etree.ElementTree.Element`.
        """
        root = Element('ConnectionRecord')
        for name, value in self.to_dict().items():
            element = Element(name)
            if name == 'properties':
                for prop_key in sorted(self.properties):
                    prop_value = self.properties[prop_key]
                    prop = Element(prop_key)
                    if isinstance(prop_value, Enum):
                        prop.text = prop_value.name
                    elif prop_key.endswith('termination'):
                        prop.text = repr(prop_value)
                    elif isinstance(prop_value, bytes):
                        prop.text = repr(prop_value)
                    else:
                        prop.text = '{}'.format(prop_value)
                    element.append(prop)
            elif isinstance(value, Enum):
                element.text = value.name
            else:
                element.text = '{}'.format(value)
            root.append(element)
        return root

    def _set_properties(self, kwargs):
        try:
            # a 'properties' kwarg was explicitly defined
            properties = kwargs.pop('properties')
        except KeyError:
            properties = kwargs
        else:
            if not properties:
                properties = {}
            elif not isinstance(properties, dict):
                raise TypeError('The properties kwarg for a ConnectionRecord must be of type dict. '
                                'Got {!r} -> {!r}'.format(type(properties), properties))
            properties.update(kwargs)

        if self.address.startswith('UDP'):
            properties['socket_type'] = 'SOCK_DGRAM'

        is_serial = self.interface == MSLInterface.SERIAL
        if not is_serial and self.backend == Backend.PyVISA:
            for alias in ('COM', 'ASRL', 'ASRLCOM'):
                if self.address.startswith(alias):
                    is_serial = True
                    break

        for key, value in properties.items():
            if is_serial:
                if key == 'parity':
                    properties[key] = convert_to_enum(value, Parity, to_upper=True)
                elif key == 'stop_bits' or key == 'stopbits':
                    properties[key] = convert_to_enum(value, StopBits, to_upper=True)
                elif key == 'data_bits' or key == 'bytesize':
                    properties[key] = convert_to_enum(value, DataBits, to_upper=True)
            if key.endswith('termination'):
                if value in ConnectionRecord._CRLF:  # must check before LR and CR checks
                    properties[key] = CR + LF
                elif value in ConnectionRecord._LF:
                    properties[key] = LF
                elif value in ConnectionRecord._CR:
                    properties[key] = CR
                elif not isinstance(value, bytes) and value is not None:
                    properties[key] = value.encode()

        return properties

class MaintenanceRecord(Record):

    __slots__ = ('comment', 'date')

    def __init__(self, comment='', date=None):
        """Contains the information about a maintenance record in an :ref:`equipment-database`.

        Parameters
        ----------
        comment : :class:`str`
            A description of the maintenance that was performed.
        date : :class:`datetime.date`, :class:`datetime.datetime` or :class:`str`
            An object that can be converted to a :class:`datetime.date` object.
            If a :class:`str` then in the format ``'YYYY-MM-DD'``.
        """
        self.comment = '{}'.format(comment)
        """:class:`str`: A description of the maintenance that was performed."""

        self.date = convert_to_date(date)
        """:class:`datetime.date`: The date that the maintenance was performed."""

    def __setattr__(self, name, value):
        try:
            self.date  # once the `date` is defined the class becomes read only
        except AttributeError:
            super(MaintenanceRecord, self).__setattr__(name, value)
        else:
            raise TypeError("A 'MaintenanceRecord' cannot be modified. Cannot set {!r} to {!r}".format(name, value))

    def __repr__(self):
        return 'MaintenanceRecord\n' \
               '  comment: {!r}\n' \
               '  date: {}'.format(self.comment, self.date)

    def __str__(self):
        return 'MaintenanceRecord<{}>'.format(self.date)

    def to_json(self):
        """Convert this :class:`MaintenanceRecord` to be JSON_ serializable.

        .. _JSON: https://www.json.org/

        Returns
        -------
        :class:`dict`
            The :class:`MaintenanceRecord` as a JSON_\\-serializable object.
        """
        return {
            'comment': self.comment,
            'date': self.date.isoformat(),
        }

    def to_xml(self):
        """Convert this :class:`MaintenanceRecord` to an XML :class:`~xml.etree.ElementTree.Element`.

        Returns
        -------
        :class:`~xml.etree.ElementTree.Element`
            The :class:`MaintenanceRecord` as a XML :class:`~xml.etree.ElementTree.Element`.
        """
        root = Element('MaintenanceRecord')

        comment_element = Element('comment')
        comment_element.text = self.comment
        root.append(comment_element)

        date_element = Element('date')
        date_element.text = self.date.isoformat()
        date_element.attrib['format'] = 'YYYY-MM-DD'
        root.append(date_element)

        return root

class MeasurandRecord(Record):

    __slots__ = ('calibration', 'conditions', 'type', 'unit')

    def __init__(self, calibration=None, conditions=None, type='', unit=''):
        """Contains the information about a measurement for a calibration.

        Parameters
        ----------
        calibration : :class:`dict`
            The information about the calibration.
        conditions : :class:`dict`
            The information about the conditions under which the measurement was performed.
        type : :class:`str`
            The type of measurement (e.g., voltage, temperature, transmittance, ...).
        unit : :class:`str`
            The unit that is associated with the measurement (e.g., V, deg C, %, ...).
        """
        if calibration is None:
            calibration = {}
        elif not isinstance(calibration, dict):
            raise TypeError("the 'calibration' parameter must be a dict")

        if conditions is None:
            conditions = {}
        elif not isinstance(conditions, dict):
            raise TypeError("the 'conditions' parameter must be a dict")

        self.calibration = RecordDict(calibration)
        """:class:`.RecordDict`: The information about calibration."""

        self.conditions = RecordDict(conditions)
        """:class:`.RecordDict`: The information about the measurement conditions."""

        self.type = '{}'.format(type)
        """:class:`str`: The type of measurement (e.g., voltage, temperature, transmittance, ...)."""

        self.unit = '{}'.format(unit)
        """:class:`str`: The unit that is associated with the measurement (e.g., V, deg C, %, ...)."""

    def __setattr__(self, name, value):
        try:
            self.unit  # once the `unit` is defined the class becomes read only
        except AttributeError:
            super(MeasurandRecord, self).__setattr__(name, value)
        else:
            raise TypeError("A 'MeasurandRecord' cannot be modified. Cannot set {!r} to {!r}".format(name, value))

    def __repr__(self):
        cal = self._dict_to_str(self.calibration)
        con = self._dict_to_str(self.conditions)
        return 'MeasurandRecord\n' \
               '  calibration: {}\n' \
               '  conditions: {}\n' \
               '  type: {!r}\n' \
               '  unit: {!r}'.format(cal, con, self.type, self.unit)

    def __str__(self):
        return 'MeasurandRecord<{}>'.format(self.type)

    def to_json(self):
        """Convert this :class:`MeasurandRecord` to be JSON_ serializable.

        .. _JSON: https://www.json.org/

        Returns
        -------
        :class:`dict`
            The :class:`MeasurandRecord` as a JSON_\\-serializable object.
        """
        return {
            'calibration': self.calibration.to_json(),
            'conditions': self.conditions.to_json(),
            'type': self.type,
            'unit': self.unit,
        }

    def to_xml(self):
        """Convert this :class:`MeasurandRecord` to an XML :class:`~xml.etree.ElementTree.Element`.

        Returns
        -------
        :class:`~xml.etree.ElementTree.Element`
            The :class:`MeasurandRecord` as a XML :class:`~xml.etree.ElementTree.Element`.
        """
        root = Element('MeasurandRecord')

        for name in ('calibration', 'conditions'):
            root.append(getattr(self, name).to_xml(tag=name))

        for name in ('type', 'unit'):
            element = Element(name)
            element.text = getattr(self, name)
            root.append(element)

        return root

class CalibrationRecord(Record):

    __slots__ = ('calibration_cycle', 'calibration_date', 'measurands', 'report_date', 'report_number')

    def __init__(self, calibration_cycle=0, calibration_date=None, measurands=None,
                 report_date=None, report_number=''):
        """Contains the information about a calibration record in an :ref:`equipment-database`.

        Parameters
        ----------
        calibration_cycle : :class:`int` or :class:`float`
            The number of years that can pass before the equipment must be re-calibrated.
        calibration_date : :class:`datetime.date`, :class:`datetime.datetime` or :class:`str`
            The date that the calibration was performed. If a :class:`str` then in the
            format ``'YYYY-MM-DD'``.
        measurands : :class:`list` of :class:`.MeasurandRecord`
            The quantities that were measured.
        report_date : :class:`datetime.date`, :class:`datetime.datetime` or :class:`str`
            The date that the report was issued. If a :class:`str` then in the
            format ``'YYYY-MM-DD'``.
        report_number : :class:`str`
            The report number.
        """
        if measurands is None:
            measurands = []

        measures = []
        for m in measurands:
            if isinstance(m, MeasurandRecord):
                measures.append(m)
            elif m and isinstance(m, dict):
                measures.append(MeasurandRecord(**m))

        self.calibration_cycle = float(calibration_cycle)
        """:class:`float`: The number of years that can pass before the equipment must be re-calibrated."""

        self.calibration_date = convert_to_date(calibration_date)
        """:class:`datetime.date`: The date that the calibration was performed."""

        self.measurands = RecordDict(OrderedDict((m.type, m) for m in measures))
        """:class:`.RecordDict`: The quantities that were measured."""

        self.report_date = convert_to_date(report_date)
        """:class:`datetime.date`: The date that the report was issued."""

        self.report_number = '{}'.format(report_number)
        """:class:`str`: The report number."""

    def __setattr__(self, name, value):
        try:
            self.report_number  # once the `report_number` is defined the class becomes read only
        except AttributeError:
            super(CalibrationRecord, self).__setattr__(name, value)
        else:
            raise TypeError("A 'CalibrationRecord' cannot be modified. Cannot set {!r} to {!r}".format(name, value))

    def __repr__(self):
        if self.measurands:
            measurands = '\n' + '\n'.join('    {}'.format(line) for value in self.measurands.values()
                                          for line in repr(value).splitlines())
        else:
            measurands = 'None'

        return 'CalibrationRecord\n' \
               '  calibration_cycle: {}\n' \
               '  calibration_date: {}\n' \
               '  measurands: {}\n' \
               '  report_date: {}\n' \
               '  report_number: {!r}'.format(self.calibration_cycle, self.calibration_date,
                                              measurands, self.report_date, self.report_number)

    def __str__(self):
        return 'CalibrationRecord<{}>'.format(self.report_number)

    def to_json(self):
        """Convert this :class:`CalibrationRecord` to be JSON_ serializable.

        .. _JSON: https://www.json.org/

        Returns
        -------
        :class:`dict`
            The :class:`CalibrationRecord` as a JSON_\\-serializable object.
        """
        return {
            'calibration_cycle': self.calibration_cycle,
            'calibration_date': self.calibration_date.isoformat(),
            'measurands': tuple(m.to_json() for m in self.measurands.values()),
            'report_date': self.report_date.isoformat(),
            'report_number': self.report_number
        }

    def to_xml(self):
        """Convert this :class:`CalibrationRecord` to an XML :class:`~xml.etree.ElementTree.Element`.

        Returns
        -------
        :class:`~xml.etree.ElementTree.Element`
            The :class:`CalibrationRecord` as a XML :class:`~xml.etree.ElementTree.Element`.
        """
        root = Element('CalibrationRecord')

        calibration_date = Element('calibration_date')
        calibration_date.text = self.calibration_date.isoformat()
        calibration_date.attrib['format'] = 'YYYY-MM-DD'
        root.append(calibration_date)

        calibration_cycle = Element('calibration_cycle')
        calibration_cycle.text = str(self.calibration_cycle)
        calibration_cycle.attrib['unit'] = 'years'
        root.append(calibration_cycle)

        measurands = Element('measurands')
        for measurand in self.measurands.values():
            measurands.append(measurand.to_xml())
        root.append(measurands)

        report_number = Element('report_number')
        report_number.text = self.report_number
        root.append(report_number)

        report_date = Element('report_date')
        report_date.text = self.report_date.isoformat()
        report_date.attrib['format'] = 'YYYY-MM-DD'
        root.append(report_date)

        return root


text:
KEEPER SAYS BREWERS ARE TAKING POSITIVES FROM FIRST TWO GAMES
ALBION goalkeeper Jon McLaughlin says that the mood in the Brewers camp is good - despite defeats in their opening two league games.
Albion were beaten late on by a stoppage time winner from Tammy Abraham for Bristol City but McLaughlin doesn't think that the squad will allow their heads to drop.
"It's (the mood) mixed at the moment obviously - we are well aware of the disappointing aspect of the performances in that we have conceded goals and have lost the two league games but we are taking all of the positives. We are a team who know not to get too high when we win or too low when we lose.
"We are taking all of the positives and remaining confident - we knew it was going to be difficult and that we wouldn't have it all our own way like we have the last two years. Even then it was difficult, so we aren't letting it affect us too much and it will take a lot more than that to break the spirit that we have."
The Brewers came up against one of the toughest strike partnerships in The Championship; with last season's 20-goal man Jonathan Kodjia pairing up with Chelsea's young loanee Tammy Abraham but McLaughlin feels Burton handled them well, as is adamant that the squad know the difficulty of the division.
"I think we handled them very well we haven't been troubled that much by the teams that we have played so far, but are coming up against very good strikers every week and that is going to continue.
"It isn't going to get any easier, every time the team sheets come in there are going to be big names on there every week now. We are very proud of the fact that we have got to that stage."
The Brewers now go on to face Sheffield Wednesday on Tuesday night, hoping to secure their first points of the Championship season.


A distribution system consists of all the facilities and equipment connecting a transmission system to the customer's equipment.
The following are examples of distribution systems components. Collectively they constitute a typical distribution system. These typically deliver voltages as high as 34,000 volts (34 kV) and as low as 120 volts.
Most industries need 2,400 to 4,160 volts to run heavy machinery and usually their own substation or substations to reduce the voltage from the transmission line to the desired level for distribution throughout the plant area. They usually require 3-phase lines to power 3-phase motors.
Commercial customers are usually served at distribution voltages, ranging from 14.4 kV to 7.2 kV through a service drop line which leads from a transformer on or near the distribution pole to the customer's end use structure. They may require 3-phase lines to power 3-phase motors.
The distribution electricity is reduced to the end use voltage (120/240 volts single phase) via a pole mounted or pad-mounted transformer. Power is delivered to the residential customer through a service drop line which leads from the distribution pole transformer to the customer's structure, for overhead lines, or underground.
Currently the only electric transportation systems are light rail and subway systems. A small distribution substation reduces the local distribution voltage to the transportation system requirements. The overhead lines supply electric power to the transportation system motors and the return current lines are connected to the train tracks.
Figure 15. Power runs from the substation underground to the poles where power is delivered to the power lines. The circuit is completed through the train tracks, with lines returning to the substation.


The Department of Tourism, Culture, Industry and Innovation operates a tourism literature distribution program which assists Newfoundland and Labrador tourism groups/associations and private sector tourism operators to distribute and display their Literature free of charge at provincial and regional Visitor Information Centres (VICs). This document describes the operational guidelines for this service - specifically the types of literature accepted for distribution; literature content and design specifications; and the distribution process.
Materials will only be accepted from tourism businesses that are compliant under the Tourism Assurance Plan (TAP). Information on the Tourism Assurance plan can be found on the Hospitality Newfoundland and Labrador website www.hnl.ca/resources/tourism-assurance-plan .
Photocopies of brochures will not be accepted.
Posters will not be accepted.
The name of the business/service should be prominently displayed on the top third of the brochure.
It is recommended that firm paper stock with a minimum paper weight of 160 (M) or 70 lb. be used.
Brochures that do not fit in the brochure racks will not be accepted for distribution.
Brochures may be dropped off directly at Provincial VIC's.
Note: The Department does not control what regional/local VIC's display. Most focus on their own areas.
Your literature/brochures must be bundled in lots of either 50 or 100, enabling our Distribution Centre staff to quickly make allocations.
The maximum weight of cartons that will be accepted is 28 kilograms or 45 pounds.
The maximum quantity of brochures that you can ship to the Distribution Centre is 5,000, although a smaller amount is recommended to reduce your costs and the possibility of unused brochures. Provincial and Regional VICs order brochures from the Distribution Centre based on need and storage space restrictions.
Brochures and completed submission forms should be delivered to the Distribution Centre at least three weeks prior to the scheduled opening of the VIC's. Provincial and Regional VIC's open at different times but generally the Provincial VICs operate from mid-May to late September, except the St. John's International Airport and the Deer Lake Airport VICs which operate year round.
Typically, the initial shipment of brochures are delivered to the VIC's in early May. Following the initial shipments, brochures are ordered by the VICs on a weekly basis.
Note that while your brochures are distributed from the Distribution Centre to the VIC's free of charge, you are responsible for the cost of getting your brochures to the Distribution Centre. Likewise, it is the owner's responsibility to pick up or make arrangements for the return of any unused brochures.
It is the responsibility of the brochure owner to ensure that sufficient quantities are delivered to the Distribution Centre and to monitor the supply and replenish stock as necessary.
If the above noted guidelines are not met, the literature will not be distributed.


text:
Three Crowns Golf Course is Under New Management
Tom Morton
Tom Morton, Townsquare Media
The Three Crowns Golf Club has hemorrhaged millions of dollars since it opened on the former Amoco refinery site, but the board that oversees the property hopes a new management company will slow the losses.
"We have brought in Landscapes Unlimited out of Lincoln, Nebraska, as the new consulting management company," Amoco Reuse Agreement Joint Powers Board Chairman Reed Merschat said Wednesday.
"We think we have the best candidate to lower this deficit," Merschat said after the board meeting.
The ARAJPB was created in 1998 to oversee the development of the former Amoco refinery and tank farm properties.
The Three Crowns Golf Club is the largest feature on the site, now known as the Platte River Commons.
It opened in 2005 and was supposed to break even after a few years.
It never did.
Annual subsidies have ranged up to $500,000 a year from the ARAJPB.
For this fiscal year ending March 31, the board approved $323,000 to subsidize the course. However, the Three Crowns deficit rose to about $374,000, so the board on Wednesday authorized more money to cover the additional loss because of poor weather.
The ARAJPB won't run out of money subsidizing Three Crowns, Merschat said. "So the sustainability actually is fairly long term; we have a comfortable cash pot."
But the board is not comfortable with the losses, either, he said.
So the board sought a third-party management company with more aggressive goals than the previous manager OB Sports, whose contract ended in December.
The board signed a contract with Landscapes Unlimited, which took over in January, and has its work cut out, Merschat said.
Three Crowns competes with three other local golf courses, and the golf has been on a downward trend for the past decade, he said.
So Merschat and the board hope the new management can resist those factors and stem the losses.
Landscapes Unlimited manages The Golf Club at Devils Tower near Hulett and several courses in Colorado, so it understands the challenges of short seasons in the Rocky Mountain region, he said.
The company intends to expand its youth and ladies golf program, and offer more non-golf events including catering, parties, weddings and operating the restaurant, Merschat said. Three Crowns employs 18 to 24 employees and more groundskeepers during the regular season, he added.
The board also announced the new general manager and golf pro. Matt Reams comes from San Antonio, Texas, and has managed courses in Colorado, Maryland, California and Oregon, according to golftrips.com.
The ARAJPB was created in 1998 when Amoco — now BP — signed an agreement with the City of Casper and Natrona County to oversee the development of the property and replace the hundreds of jobs lost when the refinery closed in 1991.
The Casper City Council and the Natrona County Commission appoint the board members.
The joint powers board does not receive any funding from the city or the county.
BP pledged more than $28 million toward the goal of replacing the number of jobs lost when the refinery shut down in 1991. The board has received all that money.
Besides BP, the joint powers board receives revenue from interest income, and sales and leases of its property on the former refinery site now known as the Platte River Commons and the former tank farm now known as the Salt Creek Heights Business Center.
Filed Under: golf course
Categories: Casper News, Sports


May 30, 2017. Acid reflux. When stomach acids travel up into the food pipe, a burning sensation occurs. Acid reflux also often causes nausea, vomiting, gas, bloating, sore throat, and cough. A number of factors. Cramping, bloating, gas, and general discomfort often occur during menstruation as the uterine lining sheds.
There are things you can do to reduce gas, bloating, and abdominal distension, for example, eliminating sugar, fructose, milk, and certain vegetables from your diet. Medical. Although everyone goes through periods of excessive gas, particularly flatulence, it is only when the symptoms become chronic that people become.
Pain from bloating on the upper left side can be mistaken for heart pains and if you experience bloating and pain on the right side you might think you are having. Lettuce is often an offender and eating apples, peaches and pears may cause you stomach and bloating distress. Heartburn issues definitely cause bloating.
Full-on stomach ache. Nothing made it better except the few winks of sleep I was able to get, and I didn't get back to feeling 100% for a few days. Okay, I thought; I can. of gas. So bloated you could even call my abdomen.
Why You Should Rethink That Drink Before Dinner. gas, bloating, nausea and stomach. Toxic shock syndrome is a serious bacterial infection and causes fever, low.
Intestinal gas and bloating can come from some surprising sources, Surprising Causes of Excessive Gas. or too much stomach acid.
Can too much stomach acid cause bloating?. for low stomach acid. Very often, indigestion can be remedied. Matt Smith before posing with his The.
If you are among the millions of adults who suffer from uncomfortable stomach and digestive problems, such as gas, bloating, heartburn and indigestion, your symptoms could be caused by one of the most misunderstood and misdiagnosed medical conditions among adults, Hypochlorhydria. Table of content: What Is.
Mint 10 Worst Foods for Your Stomach such as peppermint tea and even peppermint gum and eath mints. Too Much Stomach Acid Causes Gas Pain Cycle Mid Period Bloating aloeCure extracts the true essence of aloe vera AloeCure extracts the true essence of aloe vera treat cure or prevent any Can Acid Reflux Cause.
If you suffer from bloating, gas, acid is a digestive disorder in which there is a low level of hydrochloric acid in the stomach. What Causes Low Stomach Acid?
Common symptoms before period include breast tenderness, headaches, bloating, acne, back and thigh pain, fatigue, constipation or diarrhea, dizziness and. Hypoglycemia refers to low blood sugar and during the premenstrual phase of the menstrual cycle can cause dizziness and nausea. Excess Stomach Acid.
14 Ways To Reduce Bloating During Your Period. Bustle. levels are high in the days before your period, hence the bloating. Foods That Can Cause Acid Reflux.
Mar 9, 2017. You can still do everything that you would during the rest of the month, if you know how to manage the baggage your monthly visitor may bring. That's the sharp ache you feel between your stomach and lower back. Cramps can start before your period and last throughout the bleeding process. If they feel.
Six Tips for Avoiding Digestive Problems during Menopause – But if your digestive tract is constantly troubled, it could be a result of going through perimenopause. Perimenopause, the phase before menopause, is actually a major cause of digestive problems for women aged 45 to 55. If you're. Digestive problems include cramps, diarrhea, bloating, gas, heartburn, and constipation.
Abruptly increasing the amount of fiber you eat can cause gas, bloating, of the stomach opening can make it hard for food. of Low-Digestible.
Apr 5, 2017. 'The main cause for abdominal pain is commonly IBS, resulting in stomach cramps, bloating, constipation and diarrhoea,' says Dr O'Malley. Period pain ( when the muscular wall of the womb tightens) is a common occurrence in menstruating women from the puberty to menopause, but can sometimes be.
Cause Bloating Stomach – Signs, Symptoms & Causes | AllLocal.net – Explore Useful Info On Stomach Bloating Causes. Search Here.
Bloating, gas, acid reflux, heartburn, burping, and even acne can all be signs that you have low stomach acid. Most believe that stomach acid is the culprit behind.
Nov 20, 2015. Constipation can cause stool to remain in the intestines, leaving you with a hard- feeling stomach, pain, discomfort and gas. Having a bloated stomach before or during your period can differ depending on your cycle, and some women experience severe water retention for up to two weeks. Why do women.
Aug 17, 2017. Kelly, a Hormonology reader, wrote to me saying she gets more heartburn during Week 3 of her cycle–which is the week that starts right after ovulation. However , the researchers found that while hormones, specifically progesterone, can be a factor when it comes to heartburn symptoms, it's only during.
Mar 10, 2013. Hair Loss may be caused by low stomach acid with malabsorption of proteins, minerals and vitamins. She has gas and bloating after meals, and finds that many foods don't agree with her. Mary's nails. Before you decide, learn why testing your stomach acid levels for hypochlorhydria can be beneficial.
Dec 8, 2016. "There's a lot of overlap, the symptoms aren't always specific—for example, pretty much every GI condition can cause bloating or pain—and it's possible. Or consider a low FODMAP diet; a 2016 study from the University of Michigan Health System showed that this eating style led to major improvement in.


After more than two months, I thought this would be a good time for another installment of the recurring music history feature. These posts are driven by happenings that sufficiently intrigue me, which limits their number, plus I've already covered numerous dates. But it seems to me there is still plenty left to explore.
As on previous occasions, this post is an arbitrary selection of events, not an attempt to capture everything that happened on that date. For example, while as a parent I find child birth a beautiful thing, I don't include birthdays of music artists' children. However, birthdays of the artists qualify. But if you die to know, Jade Jagger, daughter of Mick Jagger and Bianca Jagger, one of eight children Mick has with five women, was born on October 21, 1971 in Paris, France. With that important factoid out of the way, let's get to some other events that happened on October 21 throughout rock & roll history.
1940: Manfred Mann was born as Michael Lubowitz in Johannesburg, South Africa. In 1961, he moved to the U.K. and began his long music career. He initially became successful with a band named Manfred Mann and a series of hits in the mid to late '60s like Do Wah Diddy Diddy, Sha La La and Pretty Flamingo. Immediately after that band's breakup, Mann formed experimental jazz rock outfit Manfred Mann Chapter Three. They lasted for two years and two albums before Mann found long-lasting success with progressive rockers Manfred Mann's Earth Band. They had hits throughout the '70s and '80s, especially with covers of Bruce Springsteen tunes like Spirits In The Night and Blinded By The Light. After a hiatus in the late '80s and early '90s, the band still appears to be active to this day. Mann has also released various solo albums. Here's a clip of Do Wah Diddy Diddy, Mann's first number one single released in July 1964. Written by Jeff Barry and Ellie Greenwich, the song was first recorded in 1963 as Do-Wah-Diddy by American vocal group The Exciters.
1941: Steve Cropper was born as Steven Lee Cropper on a farm near Dora, Missouri. An accomplished guitarist, who is ranked at no. 39 on the Rolling Stone list of the 100 Greatest Guitarists Of All Time, Cropper got his first guitar via mail order as a 14-year-old. At the time, he was already living in Memphis, Tenn. where in 1964 be became A&R man of Stax Records and a founding member of the label's house band Booker T. & The M.G.'s. Together with the band, be backed soul legends, such as Otis Redding, Sam & Dave and Wilson Pickett, and co-wrote some of their songs like (Sittin' On) The Dock Of The Bay, Soul Man and In The Midnight Hour. Booker T. & The M.G.'s also released their own music. During the second half of the '70s, Cropper became a member of The Blues Brothers. He has also worked as a producer with many artists. Here's a great clip of a Sam & Dave performance of Soul Man from 1974 – always loved that tune and Cropper's guitar work on it!
1957: Steve Lukather was born as Steven Lee Lukather in the San Fernando Valley, Calif. The prolific session guitarist is best known for being a longtime member of Toto, which he co-founded with David Paich (keyboards), Steve Porcaro (keyboards) and Jeff Porcaro (drums) in 1976. Lukather also is a songwriter, arranger and producer. He played guitar and bass on various tracks of Michael Jackson's Thriller album from 1982. While Beat It was among those songs, he did not play the killer solo on that tune, which was performed by Eddie Van Halen. Lukather has also released seven solo records to date. He is currently on the road with Toto for their 40th anniversary tour. Here's a clip of I Won't Hold You Back, a ballad Lukather wrote for Toto IV, the band's most successful album released in April 1982.
1965: As part of the recording sessions for their sixth studio album Rubber Soul, The Beatles were working at Abbey Road Studios. Following an unsatisfactory attempt to record Norwegian Wood 10 days earlier, they did three additional takes on October 21, of which they ended up selecting the last. Lyrically influenced by Bob Dylan and credited to John Lennon and Paul McCartney, the tune is an early example of a Western pop song featuring Indian instruments. In this case, it was the sitar played by George Harrison, who had been inspired by sitar maestro and his friend Ravi Shankar.
1976: Keith Moon performed his last public show with The Who at Maple Leaf Gardens in Toronto, Canada. It was the final gig of the band's 1976 tour. Moon's lifestyle had begun to impact his health and performance several years earlier. In perhaps the most infamous incident, Moon passed out on stage at Cow Palace in Daly City, Calif. during the first U.S. date of The Who's 1973 Quadrophenia tour. Prompted by Pete Townshend who asked whether anyone in the audience was good at playing the drums, Scot Halpin, a drummer, stepped forward and played the rest of the show. Moon also faced challenges during the '76 tour. By the end of the U.S. leg in Miami in August, a delirious Moon was treated in a hospital for eight days. When The Who performed a private show at a theater in London in December 1977 for The Kids Are Alright, a visibly overweight Moon had difficulty sustaining a solid performance. Moon passed away in September 1978 at the age of 32 from an overdose of a medication to treat alcohol withdrawal symptoms. Here's a clip of Moon in action with The Who during a raucous 1967 performance of My Generation. As a guitar lover, I'm glad Townshend no longer smashes his gear these days.