Dr. Ali bin Samikh Al-Marri, chairman of the National Human Rights Committee, called on the United Nations Special Rapporteur on the protection of human rights and fundamental freedoms in the context of combating terrorism to take urgent action to find the whereabouts of the four Qatari nationals detained by the Saudi authorities and demand their immediate release. This came during a meeting with Ms. Fionola Delean, UN Special Rapporteur on the protection of human rights and fundamental freedoms while countering terrorism, on the sidelines of her visit to Doha to participate in a conference to address the issue of returnees from terrorist areas.
During the meeting, Dr. Ali Bin Samikh Al-Marri briefed the efforts of the National Human Rights Committee to counter terrorism and protect human rights, and the outcomes of the recommendations of the international conference held by the National Human Rights Committee in cooperation with the Office of the High Commissioner for Human Rights on Confronting Conflict in the Arab Region, held during the period from 20 to 21 February 2017, and the International Conference on the Challenges of Security and Human Rights in the Arab Region, held from 5 to 6 November 2014, in cooperation with the General Secretariat of the Council of Arab Ministers of the Interior, the League of Arab States, and the Arab Network of National Human Rights Institutions, and attended by more than 300 organizations and prominent figures and representatives of the Interior and Justice Ministries.
Al Marri briefed Ms. Fionola about the repercussions of the unjust blockade imposed on the State of Qatar since 5 June 2017, and the serious violations of human rights, as documented by the report of the Office of the High Commissioner for Human Rights, and handed over copies of the annual reports of the National Human Rights Committee and the general report on the blockade imposed of Qatar.
Dr. Ali Bin Smeikh addressed the issue of the four Qatari nationals detained by the Saudi authorities, who are victims of arbitrary detention and enforced disappearances, calling for urgent action to know the fate of the detained Qatari nationals and pressure on the Saudi authorities to release them immediately, stressing that the fate of the four citizens is still unknown since their arrest by the Saudi authorities in arbitrary and unfair ways, pointing at the same time the efforts and moves made by the National Human Rights Committee to try to obtain information about them and demand the international community to pressure the Saudi authorities to reveal Their fate.
Dr. Al Marri also discussed with Ms. Fionola the issue of the terrorist lists declared by the countries of blockade which classify a number of institutions, personalities and humanitarian organizations in Qatar, along with human rights activists, journalists as terrorists, without any legal basis or argument, stressing that these lists aimed at discrediting the State of Qatar and attempts to level accusations of terrorism against Qatar, as well as the efforts of the blockading countries to strike at the charitable humanitarian work carried out by the State of Qatar and Qatari humanitarian organizations throughout the world.
On the other hand, Al Marri discussed during the meeting possible aspects of cooperation and a partnership to coordinate efforts to combat terrorism and protect human rights between the National Human Rights Committee and the United Nations Special Rapporteur on the protection of human rights and fundamental freedoms while countering terrorism.


text:
То́чність вимі́рювань () — головна характеристика якості вимірювання, що відображає близькість результату вимірювання до істинного значення вимірюваної фізичної величини .

Точність результату вимірювання () – одна з головних характеристик якості вимірювання, що відображає близькість до нуля похибки результату вимірювання.

Точність () - ступінь наближення результату вимірювання до прийнятого опорного значення.

Кількісні міри точності
З визначення випливає, що чим ближчим є результат вимірювання до істинного значення фізичної величини, тим точнішим є вимірювання і навпаки. Точність вимірювання не має числового вираження, а є суто якісною характеристикою.

Кількісною оцінкою точності вимірювання є похибка вимірювання або невизначеність вимірювання. Це обумовлено тим, що існує два основні підходи, щодо оцінювання точності результату вимірювання, які спираються відповідно на теорію похибок вимірювання та  теорію невизначеності у вимірюваннях.

В галузі кількісного хімічного аналізу набув поширення також підхід, коли точність кількісно оцінюється через правильність та збіжність, тобто, через два параметри.

Засоби досягнення точності
Підвищити точність вимірювань можна шляхом зменшення ступеня квантування  і розмаху  значень сукупності результатів вимірювання. При вимірюванні зі сталим ступенем квантування, підвищити точність можна тільки шляхом зменшення розмаху значень результатів вимірювання.

Примітки

метрологія
Вимірювання
Вимірювальні прилади

redpajama_set_name: RedPajamaWikipedia


Lounge Pug CloudSac® Velvet, Giant memory foam bean bag is the ultimate giant sized comfort piece for your relaxation space. It comes with our incredibly comfortable cloud like filling which is unique to the market. Our filling is a custom blend of high quality memory foam, latex foam & supportive foam encased within virgin polyester fibres. It outperforms pure memory foam beanbags in terms of longevity, support & comfort. The fibre gives this beanbag extra bounce and prevents clumping whilst the foams provide incredible comfort.
The C500-L is our most popular memory foam bean bag. It is a giant in size but requires a fraction of the floor space of its larger brother, the massive C1000-L. Its shape has been designed to provide excellent comfort whilst lounging out.
Being so luxurious, this bean bag could easily replace the traditional sofa in your playroom or lounge and would be perfect for a young professional's home.


The strength of the University of Manchester team working on responsible innovation lies in the depth and breadth of relevant social science research and expertise. Together they undertake inter-disciplinary research, teaching and policy engagement on the responsible governance and development of new and emerging technologies from the perspective of science and innovation policy (SIP); sociology of science, technology and society (STS); Ethics and regulatory sciences.
Philip Shapira, is Professor of Innovation Management and Policy at Manchester Business School and Professor of Public Policy at Georgia Institute of Technology, Atlanta, USA. Shapira leads the Responsible Research and Innovation team within the 5 year Manchester SYNBIOCHEM centre, one of six centres funded by the Biotechnology and Biological Sciences (BBSRC) which commenced in December 2014. (www.synbiochem.manchester.ac.uk). Dr Sally Randles is a Senior Research Fellow at the inter-disciplinary Manchester Institute of Innovation Research (MIOIR). Randles/Shapira co-lead the MIOIR Research Theme : Emerging Technologies, Dynamics and Governance and Randles with Jakob Edler lead WP3 of the 3 year (2012- 2015) European FP7 project RES-AGorA, tasked with producing a socio-normative governance framework for Responsible Research and Innovation for Europe http://res-agora.eu/about/. Randles is Co-I on SYNBIOCHEM. Dr Andrew Balmer is a Lecturer in Sociology, at the School of Social Sciences and undertakes research and teaching on technology, science and everyday life with a focus on synthetic biology and medical contexts. Balmer is Co-I on SYNBIOCHEM. Dr Sarah Chan is Deputy Director at the Institute for Science, Ethics and Innovation (iSEI) and Research Fellow in Bioethics and Law, at the Faculty of Life Sciences. Chan is Co-I on SYNBIOCHEM.. Dr Katie Bulpin is a Research Associate and STS scholar at the School of Social Sciences with special expertise in IGEM http://igem.org/Main_Page. Dr Abdullah Gok is a Research Fellow at MIOIR with a special interest in emerging technologies and their implications for business strategy and with specialist methodology skills in text mining and bibliometrics. Dr Yanchao Li is a Research Associate at MIOIR with interests in the evaluation of innovation policies and emerging technologies including new energy and implications for next-generation innovation systems development in China and Russia. Dr Catherine Rhodes is a Research Fellow in Science Ethics at iSEI, Faculty of Life Sciences with specialist expertise in the international regulation of new and emerging technologies. Xiao Liang is a PhD candidate at MIOIR with a focus on the commercialization of synthetic biology products and processes.
Sally Randles, Senior Research Fellow, Manchester Institute of Innovation Research.


We are collaborating with Peanuts to officially launch the URBAN 'One World' Chronograph Collection, featuring characters from the beloved Peanuts comic strip.
Step into the charming world of Peanuts—where Charlie Brown is the loveable loser who never gives up, Snoopy is his flamboyant sidekick, and the bossy, sarcastic Lucy is in love with Schroeder...who thinks Beethoven was the first President of the United States.
From the wildly-imaginative Snoopy, to the philosophic Linus, the Peanut's gang is a playful expression of different personalities. Life in Peanuts isn't always easy, but in the end, loyalty, togetherness, and perseverance win the day.
The 'One World' Collection including ONE limited edition watch and FOUR special edition.


text:
"""
Defines a request dispatcher, a HTTP request handler, a HTTP server and a
CGI request handler.

:authors: Josh Marshall, Thomas Calmant
:copyright: Copyright 2015, isandlaTech
:license: Apache License 2.0
:version: 0.2.6

..

    Copyright 2015 isandlaTech

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
"""

# Module version
__version_info__ = (0, 2, 6)
__version__ = ".".join(str(x) for x in __version_info__)

# Documentation strings format
__docformat__ = "restructuredtext en"

# ------------------------------------------------------------------------------
# Local modules
from jsonrpclib import Fault
import jsonrpclib.config
import jsonrpclib.utils as utils
import jsonrpclib.threadpool

# Standard library
import logging
import socket
import sys
import traceback

# Prepare the logger
_logger = logging.getLogger(__name__)

try:
    # Python 3
    # pylint: disable=F0401,E0611
    import xmlrpc.server as xmlrpcserver
    import socketserver
except (ImportError, AttributeError):
    # Python 2 or IronPython
    # pylint: disable=F0401,E0611
    import SimpleXMLRPCServer as xmlrpcserver
    import SocketServer as socketserver

try:
    # Windows
    import fcntl
except ImportError:
    # Other systems
    # pylint: disable=C0103
    fcntl = None

# ------------------------------------------------------------------------------

def get_version(request):
    """
    Computes the JSON-RPC version

    :param request: A request dictionary
    :return: The JSON-RPC version or None
    """
    if 'jsonrpc' in request:
        return 2.0
    elif 'id' in request:
        return 1.0

    return None

def validate_request(request, json_config):
    """
    Validates the format of a request dictionary

    :param request: A request dictionary
    :param json_config: A JSONRPClib Config instance
    :return: True if the dictionary is valid, else a Fault object
    """
    if not isinstance(request, utils.DictType):
        # Invalid request type
        fault = Fault(-32600, 'Request must be a dict, not {0}'
                      .format(type(request).__name__),
                      config=json_config)
        _logger.warning("Invalid request content: %s", fault)
        return fault

    # Get the request ID
    rpcid = request.get('id', None)

    # Check request version
    version = get_version(request)
    if not version:
        fault = Fault(-32600, 'Request {0} invalid.'.format(request),
                      rpcid=rpcid, config=json_config)
        _logger.warning("No version in request: %s", fault)
        return fault

    # Default parameters: empty list
    request.setdefault('params', [])

    # Check parameters
    method = request.get('method', None)
    params = request.get('params')
    param_types = (utils.ListType, utils.DictType, utils.TupleType)

    if not method or not isinstance(method, utils.STRING_TYPES) or \
            not isinstance(params, param_types):
        # Invalid type of method name or parameters
        fault = Fault(-32600, 'Invalid request parameters or method.',
                      rpcid=rpcid, config=json_config)
        _logger.warning("Invalid request content: %s", fault)
        return fault

    # Valid request
    return True

# ------------------------------------------------------------------------------

class NoMulticallResult(Exception):
    """
    No result in multicall
    """
    pass

class SimpleJSONRPCDispatcher(xmlrpcserver.SimpleXMLRPCDispatcher, object):
    """
    Mix-in class that dispatches JSON-RPC requests.

    This class is used to register JSON-RPC method handlers
    and then to dispatch them. This class doesn't need to be
    instanced directly when used by SimpleJSONRPCServer.
    """
    def __init__(self, encoding=None, config=jsonrpclib.config.DEFAULT):
        """
        Sets up the dispatcher with the given encoding.
        None values are allowed.
        """
        xmlrpcserver.SimpleXMLRPCDispatcher.__init__(
            self, allow_none=True, encoding=encoding or "UTF-8")
        self.json_config = config

        # Notification thread pool
        self.__notification_pool = None

    def set_notification_pool(self, thread_pool):
        """
        Sets the thread pool to use to handle notifications
        """
        self.__notification_pool = thread_pool

    def _unmarshaled_dispatch(self, request, dispatch_method=None):
        """
        Loads the request dictionary (unmarshaled), calls the method(s)
        accordingly and returns a JSON-RPC dictionary (not marshaled)

        :param request: JSON-RPC request dictionary (or list of)
        :param dispatch_method: Custom dispatch method (for method resolution)
        :return: A JSON-RPC dictionary (or an array of) or None if the request
                 was a notification
        :raise NoMulticallResult: No result in batch
        """
        if not request:
            # Invalid request dictionary
            fault = Fault(-32600, 'Request invalid -- no request data.',
                          config=self.json_config)
            _logger.warning("Invalid request: %s", fault)
            return fault.dump()

        if isinstance(request, utils.ListType):
            # This SHOULD be a batch, by spec
            responses = []
            for req_entry in request:
                # Validate the request
                result = validate_request(req_entry, self.json_config)
                if isinstance(result, Fault):
                    responses.append(result.dump())
                    continue

                # Call the method
                resp_entry = self._marshaled_single_dispatch(req_entry,
                                                             dispatch_method)

                # Store its result
                if isinstance(resp_entry, Fault):
                    # pylint: disable=E1103
                    responses.append(resp_entry.dump())
                elif resp_entry is not None:
                    responses.append(resp_entry)

            if not responses:
                # No non-None result
                _logger.error("No result in Multicall")
                raise NoMulticallResult("No result")

            return responses

        else:
            # Single call
            result = validate_request(request, self.json_config)
            if isinstance(result, Fault):
                return result.dump()

            # Call the method
            response = self._marshaled_single_dispatch(request,
                                                       dispatch_method)
            if isinstance(response, Fault):
                # pylint: disable=E1103
                return response.dump()

            return response

    def _marshaled_dispatch(self, data, dispatch_method=None, path=None):
        """
        Parses the request data (marshaled), calls method(s) and returns a
        JSON string (marshaled)

        :param data: A JSON request string
        :param dispatch_method: Custom dispatch method (for method resolution)
        :param path: Unused parameter, to keep compatibility with xmlrpclib
        :return: A JSON-RPC response string (marshaled)
        """
        # Parse the request
        try:
            request = jsonrpclib.loads(data, self.json_config)
        except Exception as ex:
            # Parsing/loading error
            fault = Fault(-32700, 'Request {0} invalid. ({1}:{2})'
                          .format(data, type(ex).__name__, ex),
                          config=self.json_config)
            _logger.warning("Error parsing request: %s", fault)
            return fault.response()

        # Get the response dictionary
        try:
            response = self._unmarshaled_dispatch(request, dispatch_method)
            if response is not None:
                # Compute the string representation of the dictionary/list
                return jsonrpclib.jdumps(response, self.encoding)
            else:
                # No result (notification)
                return ''
        except NoMulticallResult:
            # Return an empty string (jsonrpclib internal behaviour)
            return ''

    def _marshaled_single_dispatch(self, request, dispatch_method=None):
        """
        Dispatches a single method call

        :param request: A validated request dictionary
        :param dispatch_method: Custom dispatch method (for method resolution)
        :return: A JSON-RPC response dictionary, or None if it was a
                 notification request
        """
        method = request.get('method')
        params = request.get('params')

        # Prepare a request-specific configuration
        if 'jsonrpc' not in request and self.json_config.version >= 2:
            # JSON-RPC 1.0 request on a JSON-RPC 2.0
            # => compatibility needed
            config = self.json_config.copy()
            config.version = 1.0
        else:
            # Keep server configuration as is
            config = self.json_config

        # Test if this is a notification request
        is_notification = 'id' not in request or request['id'] in (None, '')
        if is_notification and self.__notification_pool is not None:
            # Use the thread pool for notifications
            if dispatch_method is not None:
                self.__notification_pool.enqueue(dispatch_method,
                                                 method, params)
            else:
                self.__notification_pool.enqueue(self._dispatch,
                                                 method, params, config)

            # Return immediately
            return None
        else:
            # Synchronous call
            try:
                # Call the method
                if dispatch_method is not None:
                    response = dispatch_method(method, params)
                else:
                    response = self._dispatch(method, params, config)
            except Exception as ex:
                # Return a fault
                fault = Fault(-32603, '{0}:{1}'.format(type(ex).__name__, ex),
                              config=config)
                _logger.error("Error calling method %s: %s", method, fault)
                return fault.dump()

            if is_notification:
                # It's a notification, no result needed
                # Do not use 'not id' as it might be the integer 0
                return None

        # Prepare a JSON-RPC dictionary
        try:
            return jsonrpclib.dump(response, rpcid=request['id'],
                                   is_response=True, config=config)
        except Exception as ex:
            # JSON conversion exception
            fault = Fault(-32603, '{0}:{1}'.format(type(ex).__name__, ex),
                          config=config)
            _logger.error("Error preparing JSON-RPC result: %s", fault)
            return fault.dump()

    def _dispatch(self, method, params, config=None):
        """
        Default method resolver and caller

        :param method: Name of the method to call
        :param params: List of arguments to give to the method
        :param config: Request-specific configuration
        :return: The result of the method
        """
        config = config or self.json_config

        func = None
        try:
            # Look into registered methods
            func = self.funcs[method]
        except KeyError:
            if self.instance is not None:
                # Try with the registered instance
                try:
                    # Instance has a custom dispatcher
                    return getattr(self.instance, '_dispatch')(method, params)
                except AttributeError:
                    # Resolve the method name in the instance
                    try:
                        func = xmlrpcserver.resolve_dotted_attribute(
                            self.instance, method, True)
                    except AttributeError:
                        # Unknown method
                        pass

        if func is not None:
            try:
                # Call the method
                if isinstance(params, utils.ListType):
                    return func(*params)
                else:
                    return func(**params)
            except TypeError as ex:
                # Maybe the parameters are wrong
                fault = Fault(-32602, 'Invalid parameters: {0}'.format(ex),
                              config=config)
                _logger.warning("Invalid call parameters: %s", fault)
                return fault
            except:
                # Method exception
                err_lines = traceback.format_exc().splitlines()
                trace_string = '{0} | {1}'.format(err_lines[-3], err_lines[-1])
                fault = Fault(-32603, 'Server error: {0}'.format(trace_string),
                              config=config)
                _logger.exception("Server-side exception: %s", fault)
                return fault
        else:
            # Unknown method
            fault = Fault(-32601, 'Method {0} not supported.'.format(method),
                          config=config)
            _logger.warning("Unknown method: %s", fault)
            return fault

# ------------------------------------------------------------------------------

class SimpleJSONRPCRequestHandler(xmlrpcserver.SimpleXMLRPCRequestHandler):
    """
    HTTP request handler.

    The server that receives the requests must have a json_config member,
    containing a JSONRPClib Config instance
    """
    def do_POST(self):
        """
        Handles POST requests
        """
        if not self.is_rpc_path_valid():
            self.report_404()
            return

        # Retrieve the configuration
        config = getattr(self.server, 'json_config', jsonrpclib.config.DEFAULT)

        try:
            # Read the request body
            max_chunk_size = 10 * 1024 * 1024
            size_remaining = int(self.headers["content-length"])
            chunks = []
            while size_remaining:
                chunk_size = min(size_remaining, max_chunk_size)
                raw_chunk = self.rfile.read(chunk_size)
                if not raw_chunk:
                    break
                chunks.append(utils.from_bytes(raw_chunk))
                size_remaining -= len(chunks[-1])
            data = ''.join(chunks)

            try:
                # Decode content
                data = self.decode_request_content(data)
                if data is None:
                    # Unknown encoding, response has been sent
                    return
            except AttributeError:
                # Available since Python 2.7
                pass

            # Execute the method
            response = self.server._marshaled_dispatch(
                data, getattr(self, '_dispatch', None), self.path)

            # No exception: send a 200 OK
            self.send_response(200)
        except:
            # Exception: send 500 Server Error
            self.send_response(500)
            err_lines = traceback.format_exc().splitlines()
            trace_string = '{0} | {1}'.format(err_lines[-3], err_lines[-1])
            fault = jsonrpclib.Fault(-32603, 'Server error: {0}'
                                     .format(trace_string), config=config)
            _logger.exception("Server-side error: %s", fault)
            response = fault.response()

        if response is None:
            # Avoid to send None
            response = ''

        # Convert the response to the valid string format
        response = utils.to_bytes(response)

        # Send it
        self.send_header("Content-type", config.content_type)
        self.send_header("Content-length", str(len(response)))
        self.end_headers()
        if response:
            self.wfile.write(response)

# ------------------------------------------------------------------------------

class SimpleJSONRPCServer(socketserver.TCPServer, SimpleJSONRPCDispatcher):
    """
    JSON-RPC server (and dispatcher)
    """
    # This simplifies server restart after error
    allow_reuse_address = True

    # pylint: disable=C0103
    def __init__(self, addr, requestHandler=SimpleJSONRPCRequestHandler,
                 logRequests=True, encoding=None, bind_and_activate=True,
                 address_family=socket.AF_INET,
                 config=jsonrpclib.config.DEFAULT):
        """
        Sets up the server and the dispatcher

        :param addr: The server listening address
        :param requestHandler: Custom request handler
        :param logRequests: Flag to(de)activate requests logging
        :param encoding: The dispatcher request encoding
        :param bind_and_activate: If True, starts the server immediately
        :param address_family: The server listening address family
        :param config: A JSONRPClib Config instance
        """
        # Set up the dispatcher fields
        SimpleJSONRPCDispatcher.__init__(self, encoding, config)

        # Prepare the server configuration
        # logRequests is used by SimpleXMLRPCRequestHandler
        self.logRequests = logRequests
        self.address_family = address_family
        self.json_config = config

        # Work on the request handler
        class RequestHandlerWrapper(requestHandler, object):
            """
            Wraps the request handle to have access to the configuration
            """
            def __init__(self, *args, **kwargs):
                """
                Constructs the wrapper after having stored the configuration
                """
                self.config = config
                super(RequestHandlerWrapper, self).__init__(*args, **kwargs)

        # Set up the server
        socketserver.TCPServer.__init__(self, addr, requestHandler,
                                        bind_and_activate)

        # Windows-specific
        if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
            flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
            flags |= fcntl.FD_CLOEXEC
            fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)

# ------------------------------------------------------------------------------

class PooledJSONRPCServer(SimpleJSONRPCServer, socketserver.ThreadingMixIn):
    """
    JSON-RPC server based on a thread pool
    """
    def __init__(self, addr, requestHandler=SimpleJSONRPCRequestHandler,
                 logRequests=True, encoding=None, bind_and_activate=True,
                 address_family=socket.AF_INET,
                 config=jsonrpclib.config.DEFAULT, thread_pool=None):
        """
        Sets up the server and the dispatcher

        :param addr: The server listening address
        :param requestHandler: Custom request handler
        :param logRequests: Flag to(de)activate requests logging
        :param encoding: The dispatcher request encoding
        :param bind_and_activate: If True, starts the server immediately
        :param address_family: The server listening address family
        :param config: A JSONRPClib Config instance
        :param thread_pool: A ThreadPool object. The pool must be started.
        """
        # Normalize the thread pool
        if thread_pool is None:
            # Start a thread pool with  30 threads max, 0 thread min
            thread_pool = jsonrpclib.threadpool.ThreadPool(
                30, 0, logname="PooledJSONRPCServer")
            thread_pool.start()

        # Store the thread pool
        self.__request_pool = thread_pool

        # Prepare the server
        SimpleJSONRPCServer.__init__(self, addr, requestHandler, logRequests,
                                     encoding, bind_and_activate,
                                     address_family, config)

    def process_request(self, request, client_address):
        """
        Handle a client request: queue it in the thread pool
        """
        self.__request_pool.enqueue(self.process_request_thread,
                                    request, client_address)

    def server_close(self):
        """
        Clean up the server
        """
        SimpleJSONRPCServer.server_close(self)
        self.__request_pool.stop()

# ------------------------------------------------------------------------------

class CGIJSONRPCRequestHandler(SimpleJSONRPCDispatcher):
    """
    JSON-RPC CGI handler (and dispatcher)
    """
    def __init__(self, encoding=None, config=jsonrpclib.config.DEFAULT):
        """
        Sets up the dispatcher

        :param encoding: Dispatcher encoding
        :param config: A JSONRPClib Config instance
        """
        SimpleJSONRPCDispatcher.__init__(self, encoding, config)

    def handle_jsonrpc(self, request_text):
        """
        Handle a JSON-RPC request
        """
        response = self._marshaled_dispatch(request_text)
        sys.stdout.write('Content-Type: {0}\r\n'
                         .format(self.json_config.content_type))
        sys.stdout.write('Content-Length: {0:d}\r\n'.format(len(response)))
        sys.stdout.write('\r\n')
        sys.stdout.write(response)

    # XML-RPC alias
    handle_xmlrpc = handle_jsonrpc

redpajama_set_name: RedPajamaGithub


Breaks: The £1m fund will be used to provide short breaks for carers.
More than 2600 carers will benefit from £1m of funding for short breaks, the Scottish Government has announced.
The latest round of cash from the Creative Breaks programme will support in excess of 60 projects, giving carers the chance to enjoy activities such as residential weekend stays and daytime breaks.
The more than 190 projects supporting about 9000 carers have benefited from funding for short breaks in the past.
Public health minister Michael Matheson said there were "considerable pressures on adult and young carers" and it was important the government supported them.
"The short breaks fund, now in its third year, plays a large part in giving our carers a well-deserved short break," he said.
"Importantly, these breaks allow young carers the chance to socialise and meet other young people in a similar position.


Dealing a setback to Gov. Jay Inslee's climate agenda, a judge has invalidated major portions of a state rule requiring greenhouse-gas cuts by refineries, fuel distributors and dozens of other major industrial emitters.
In an oral ruling Friday, Thurston County Superior Court Judge James Dixon sided with employer groups who sued last year, contending the state Department of Ecology lacked authority to impose the Clean Air Rule without legislative approval.
The City Preparing for Climate Change Without Ever Saying the Words Advocating for the Environment When Your Rural Town Won't To Speed Up Infrastructure Projects, Trump Revisits Environmental Regs Can States and Cities Really Uphold the Paris Climate Deal?
Dixon agreed the state cannot force emission reductions on gasoline and natural-gas distributors and similar businesses that do not burn fuels themselves, according to business and environmental representatives who were on hand for the ruling.
"We're obviously disappointed," said Camille St. Onge, an Ecology spokeswoman. "Our environment and infrastructure and economy are dependent on us reducing our greenhouse gases. A decision like this does threaten our progress."
St. Onge said that the state may appeal but is still awaiting Dixon's final written order, which will spell out whether Ecology can still partially enforce the rule for power plants and manufacturers for fuels they burn on site.
Mary Catherine McAleer, a lobbyist for the Association of Washington Business (AWB), which challenged the state over the rule, said the ruling means the state cannot target a leading cause of emissions -- gasoline burned in automobiles.
"For the purposes of carbon reduction, the rule has lost its relevance," McAleer said, calling the judge's ruling a "useful clarification" on the limits of state authority. She said it was a shame government and businesses both have spent so much time and money preparing for the rule.
Ecology received a $4.5 million appropriation and authority to hire 20 full-time employees to help roll out the new regulations, St. Onge said, but not all of those jobs have been filled.
The Clean Air Rule required dozens of affected industries to cap and gradually reduce their carbon emissions by an average 1.7 percent a year -- or pay for equivalent reductions elsewhere. It initially targeted facilities releasing at least 100,000 metric tons of carbon emissions annually, expanding to others over time.
The rule sought to ease the burden on some industries, such as aluminum producers, by delaying compliance and giving credit for past energy-efficiency investments.
Inslee has made combating climate change a signature issue, flagging an "existential threat" posed by rising global temperatures attributed by scientists to human activity. He joined other governors and local officials in vowing to meet the goals of the 2015 Paris climate accord despite President Donald Trump's decision to pull the U.S. out of the agreement.
A second-term Democrat, Inslee first ordered Ecology to pursue the new clean-air regulation in 2015 after unsuccessful efforts to convince the state Legislature to pass a carbon tax or cap-and-trade program.
Jaime Smith, an Inslee spokeswoman, called Dixon's ruling "disappointing" and said in an email the governor's office is talking with Ecology about "options they can pursue."
AWB, which was joined in challenging the rule by major private utilities including Avista and Puget Sound Energy, has long criticized Inslee's efforts to impose new taxes and regulations to reduce carbon emissions.
"We are pleased with the judge's decision," AWB President Kris Johnson said in a news release, adding that employers "will continue to reduce carbon emissions through innovation and private investment."
Marisa Ordonia, an attorney for the Washington Environmental Council and other groups who helped defend the Clean Air Rule in court, said the organizations disagree with Dixon's ruling.
Ordonia said state agencies were granted broad authority to regulate emissions under the state's Clean Air Act, first adopted by the Legislature in 1967.
"We will be appealing the decision," she said. "We'll continue fighting."
Meanwhile, Inslee, bolstered by Democrats who now hold majorities in the state House and Senate, has said he'll propose a carbon tax to the 2018 Legislature, which convenes in January.


text:
Despite these many dissimilarities, in 2009 the FDA elected to apply 21 C.F.R. Part 1271 to Arsenault's donations. Although it is unclear how the FDA was alerted to Arsenault's activities, in April of 2009 an investigator from the FDA's Sacramento office initiated contact with Arsenault. 113 After conversations with the investigator and without the advice of legal counsel, Arsenault filed a form in November registering himself as a "directed donor" of HCT/P's, but asserting that his activities were exempt from the regulatory requirements of 21 C.F.R. Part 1271.114 Shortly afterwards, FDA agents began a series of four on-site inspections of Arsenault's "business." (Because the site of manufacture and packaging was Arsenault's home, this meant that the FDA conducted four separate inspections of his personal residence.) At the time of the first inspection, on August 27, 2012, Arsenault attempted to explain to three FDA agents in his home that he believed that his activities were exempt, but the federal investigators disagreed. They conducted three additional inspections, on September 2, 2010; September 9, 2010; and September 16, 2010. At the September 9th inspection, Arsenault provided to the FDA copies of forty-one donor agreements, a calendar with the names of recipients and donation dates, and lists naming individuals who signed donor agreements, even those who did not later receive a donation. 115 The FDA also took copies of Arsenault's health records, including the results of communicable disease testing.
On September 20, 2010, FDA investigators issued Arsenault with an inspection observations report describing the various ways in which his conduct failed to meet 21 C.F.R. Part 1271's regulatory requirements. The FDA asserted that Arsenault was "not determined to be eligible based on the results of donor screening and testing." 116 He "did not adequately screen [himself] for risk factors related to relevant communicable diseases . . . every six months," and the FDA specifically faulted him for
113. E-mail from Shelley H. Beausoleil, Investigator, Sacramento Office, Food and Drug Administration, to Trent Arsenault (Apr. 29, 2009, 14: 57 PST) available at http://trentdonor.org/sites/g2sites/trentdonor/d/21570-1/FDA-sacramento-request- registration-email-trentdonor-29-apr-2009.pdf.
114. Interview with Trent Arsenault (Oct. 6, 2011); Trent Arsenault, 2010 FDA Directed Donor Registration, http://trentdonor.org/v/logos/fda_human_cell_and_tissue_ establishment_registration/ FDA3356_FEI3007575901A2009-portrait_p2.jpg.html (last visited June 13, 2012).
115. Trent Arsenault, Form FDA 463a Signed Affadavit – 16-Sep-2010, http://trentdonor.org/sites/g2sites/trentdonor/d/21523-1/FDA-463a-signed-affadavit-16-Sep- 2010-4-Pages.pdf (last visited June 13, 2012).
116. U.S. FOOD & DRUG ADMIN., FDA Form 483 Inspection-Observation 20-Sep-2010, http://trentdonor.org/trentdonor/d/21520-2/FDA-Form-483-Inspection-Observations-
TrentDonor-20-Sep-2010-5-Pages.pdf (last visited Aug. 3, 2012) [hereinafter FDA Inspection Form 483].

redpajama_set_name: RedPajamaCommonCrawl


80% superwash merino wool and 20% silk super fluffy and glossy pencil roving! This roving is unbelievably soft and very smooth, and since it is pencil roving, there is no need to draft - simply enjoy your spinning and watching the colors meld. The silk provides a rich gloss to the yarn! The pencil roving comes in a generous 4 ounce lots.


text:
LongRoom News › General
CNN pays homage to Bourdain with show that charts his career success, drug addiction and how Obama ASKED producers if he could dine with the late chef in that famous episode
Mail Online | 6/11/2018 | Keith Griffith;Emily Crane;Mary Kekatos For Dailymail.com
bab_ohh (Posted by) Level 3
6/11/2018 12:11 AM EST in General
Click For Photo: http://i.dailymail.co.uk/i/newpix/2018/06/11/04/4D14D0D000000578-0-The_late_Anthony_Bourdain_posted_this_snapshot_of_himself_sittin-a-14_1528687586173.jpg
Click For Video: http://video.dailymail.co.uk/video/mol/2018/06/08/1438394073620986748/1024x576_MP4_1438394073620986748.mp4
CNN has paid homage to its star Anthony Bourdain in a tribute show following the celebrity chef's suicide on Friday.
The tribute show aired on Sunday night after a new episode of Bourdain's show Parts Unknown, and tracked his rise through footage from past shows and interviews with CNN colleagues.
Moment - CNN - Jake - Tapper - Barack
In one surprising moment, CNN anchor Jake Tapper revealed that Barack Obama's appearance on the show was at the request of the then-President himself.
'It was the Obama White House who reached out to CNN, and I put them in touch with Bourdain,' said Tapper. 'That's who Anthony Bourdain was: Obama wanted to go have food with him not the other way around.'
Interview - Anchor - Anderson - Cooper - Verge
In another interview, anchor Anderson Cooper was on the verge of tears as he discussed how Bourdain had inspired him.
I just turned 51, and I remember thinking: "Wow if I could age like he is aging." He was 61, and he was getting tattoos, doing jujitsu and he was just, he actually...' Cooper said, trailing off to compose himself.
'I - Months - Hope - Life
'I was actually thinking about this two months ago, I was thinking about how he gave me hope for what one's life could become at 61.'
In other footage originally shot for an episode of his show that aired in 2015, Bourdain got painfully honest with a group of recovering addicts in Massachusetts.
Something - Time - Mirror - Grin - Bourdain
'I'll tell you something really shameful about myself. The first time I shot up, I looked at myself in the mirror with a big grin,' Bourdain told the group.
'You know, something was missing in me, whether it was a self- image situation, whether it was a character flaw. I came from a stable family, the suburbs, you know, I had a lot of advantages. There was some dark genie inside me that I very much hesitate to call a disease,...
(Excerpt) Read more at: Mail Online
50 Top Stories Breaking Now!
Where The World Finds Its News - LongRoom News!
Wake Up To Breaking News!
"Those who stand for nothing fall for anything." - Alexander Hamilton