text:
"""DNS Messages"""

import contextlib
import io
import time

import dns.wire
import dns.edns
import dns.enum
import dns.exception
import dns.flags
import dns.name
import dns.opcode
import dns.entropy
import dns.rcode
import dns.rdata
import dns.rdataclass
import dns.rdatatype
import dns.rrset
import dns.renderer
import dns.ttl
import dns.tsig
import dns.rdtypes.ANY.OPT
import dns.rdtypes.ANY.TSIG

class ShortHeader(dns.exception.FormError):
    """The DNS packet passed to from_wire() is too short."""

class TrailingJunk(dns.exception.FormError):
    """The DNS packet passed to from_wire() has extra junk at the end of it."""

class UnknownHeaderField(dns.exception.DNSException):
    """The header field name was not recognized when converting from text
    into a message."""

class BadEDNS(dns.exception.FormError):
    """An OPT record occurred somewhere other than
    the additional data section."""

class BadTSIG(dns.exception.FormError):
    """A TSIG record occurred somewhere other than the end of
    the additional data section."""

class UnknownTSIGKey(dns.exception.DNSException):
    """A TSIG with an unknown key was received."""

class Truncated(dns.exception.DNSException):
    """The truncated flag is set."""

    supp_kwargs = {'message'}

    def message(self):
        """As much of the message as could be processed.

        Returns a ``dns.message.Message``.
        """
        return self.kwargs['message']

class NotQueryResponse(dns.exception.DNSException):
    """Message is not a response to a query."""

class ChainTooLong(dns.exception.DNSException):
    """The CNAME chain is too long."""

class AnswerForNXDOMAIN(dns.exception.DNSException):
    """The rcode is NXDOMAIN but an answer was found."""

class NoPreviousName(dns.exception.SyntaxError):
    """No previous name was known."""

class MessageSection(dns.enum.IntEnum):
    """Message sections"""
    QUESTION = 0
    ANSWER = 1
    AUTHORITY = 2
    ADDITIONAL = 3

    @classmethod
    def _maximum(cls):
        return 3

DEFAULT_EDNS_PAYLOAD = 1232
MAX_CHAIN = 16

class Message:
    """A DNS message."""

    _section_enum = MessageSection

    def __init__(self, id=None):
        if id is None:
            self.id = dns.entropy.random_16()
        else:
            self.id = id
        self.flags = 0
        self.sections = [[], [], [], []]
        self.opt = None
        self.request_payload = 0
        self.keyring = None
        self.tsig = None
        self.request_mac = b''
        self.xfr = False
        self.origin = None
        self.tsig_ctx = None
        self.index = {}

    @property
    def question(self):
        """ The question section."""
        return self.sections[0]

    @question.setter
    def question(self, v):
        self.sections[0] = v

    @property
    def answer(self):
        """ The answer section."""
        return self.sections[1]

    @answer.setter
    def answer(self, v):
        self.sections[1] = v

    @property
    def authority(self):
        """ The authority section."""
        return self.sections[2]

    @authority.setter
    def authority(self, v):
        self.sections[2] = v

    @property
    def additional(self):
        """ The additional data section."""
        return self.sections[3]

    @additional.setter
    def additional(self, v):
        self.sections[3] = v

    def __repr__(self):
        return '<DNS message, ID ' + repr(self.id) + '>'

    def __str__(self):
        return self.to_text()

    def to_text(self, origin=None, relativize=True, **kw):
        """Convert the message to text.

        The *origin*, *relativize*, and any other keyword
        arguments are passed to the RRset ``to_wire()`` method.

        Returns a ``str``.
        """

        s = io.StringIO()
        s.write('id %d\n' % self.id)
        s.write('opcode %s\n' % dns.opcode.to_text(self.opcode()))
        s.write('rcode %s\n' % dns.rcode.to_text(self.rcode()))
        s.write('flags %s\n' % dns.flags.to_text(self.flags))
        if self.edns >= 0:
            s.write('edns %s\n' % self.edns)
            if self.ednsflags != 0:
                s.write('eflags %s\n' %
                        dns.flags.edns_to_text(self.ednsflags))
            s.write('payload %d\n' % self.payload)
        for opt in self.options:
            s.write('option %s\n' % opt.to_text())
        for (name, which) in self._section_enum.__members__.items():
            s.write(f';{name}\n')
            for rrset in self.section_from_number(which):
                s.write(rrset.to_text(origin, relativize, **kw))
                s.write('\n')
        #
        # We strip off the final \n so the caller can print the result without
        # doing weird things to get around eccentricities in Python print
        # formatting
        #
        return s.getvalue()[:-1]

    def __eq__(self, other):
        """Two messages are equal if they have the same content in the
        header, question, answer, and authority sections.

        Returns a ``bool``.
        """

        if not isinstance(other, Message):
            return False
        if self.id != other.id:
            return False
        if self.flags != other.flags:
            return False
        for i, section in enumerate(self.sections):
            other_section = other.sections[i]
            for n in section:
                if n not in other_section:
                    return False
            for n in other_section:
                if n not in section:
                    return False
        return True

    def __ne__(self, other):
        return not self.__eq__(other)

    def is_response(self, other):
        """Is *other* a response this message?

        Returns a ``bool``.
        """

        if other.flags & dns.flags.QR == 0 or \
           self.id != other.id or \
           dns.opcode.from_flags(self.flags) != \
           dns.opcode.from_flags(other.flags):
            return False
        if other.rcode() in {dns.rcode.FORMERR, dns.rcode.SERVFAIL,
                             dns.rcode.NOTIMP, dns.rcode.REFUSED}:
            # We don't check the question section in these cases if
            # the other question section is empty, even though they
            # still really ought to have a question section.
            if len(other.question) == 0:
                return True
        if dns.opcode.is_update(self.flags):
            # This is assuming the "sender doesn't include anything
            # from the update", but we don't care to check the other
            # case, which is that all the sections are returned and
            # identical.
            return True
        for n in self.question:
            if n not in other.question:
                return False
        for n in other.question:
            if n not in self.question:
                return False
        return True

    def section_number(self, section):
        """Return the "section number" of the specified section for use
        in indexing.

        *section* is one of the section attributes of this message.

        Raises ``ValueError`` if the section isn't known.

        Returns an ``int``.
        """

        for i, our_section in enumerate(self.sections):
            if section is our_section:
                return self._section_enum(i)
        raise ValueError('unknown section')

    def section_from_number(self, number):
        """Return the section list associated with the specified section
        number.

        *number* is a section number `int` or the text form of a section
        name.

        Raises ``ValueError`` if the section isn't known.

        Returns a ``list``.
        """

        section = self._section_enum.make(number)
        return self.sections[section]

    def find_rrset(self, section, name, rdclass, rdtype,
                   covers=dns.rdatatype.NONE, deleting=None, create=False,
                   force_unique=False):
        """Find the RRset with the given attributes in the specified section.

        *section*, an ``int`` section number, or one of the section
        attributes of this message.  This specifies the
        the section of the message to search.  For example::

            my_message.find_rrset(my_message.answer, name, rdclass, rdtype)
            my_message.find_rrset(dns.message.ANSWER, name, rdclass, rdtype)

        *name*, a ``dns.name.Name``, the name of the RRset.

        *rdclass*, an ``int``, the class of the RRset.

        *rdtype*, an ``int``, the type of the RRset.

        *covers*, an ``int`` or ``None``, the covers value of the RRset.
        The default is ``None``.

        *deleting*, an ``int`` or ``None``, the deleting value of the RRset.
        The default is ``None``.

        *create*, a ``bool``.  If ``True``, create the RRset if it is not found.
        The created RRset is appended to *section*.

        *force_unique*, a ``bool``.  If ``True`` and *create* is also ``True``,
        create a new RRset regardless of whether a matching RRset exists
        already.  The default is ``False``.  This is useful when creating
        DDNS Update messages, as order matters for them.

        Raises ``KeyError`` if the RRset was not found and create was
        ``False``.

        Returns a ``dns.rrset.RRset object``.
        """

        if isinstance(section, int):
            section_number = section
            section = self.section_from_number(section_number)
        else:
            section_number = self.section_number(section)
        key = (section_number, name, rdclass, rdtype, covers, deleting)
        if not force_unique:
            if self.index is not None:
                rrset = self.index.get(key)
                if rrset is not None:
                    return rrset
            else:
                for rrset in section:
                    if rrset.full_match(name, rdclass, rdtype, covers,
                                        deleting):
                        return rrset
        if not create:
            raise KeyError
        rrset = dns.rrset.RRset(name, rdclass, rdtype, covers, deleting)
        section.append(rrset)
        if self.index is not None:
            self.index[key] = rrset
        return rrset

    def get_rrset(self, section, name, rdclass, rdtype,
                  covers=dns.rdatatype.NONE, deleting=None, create=False,
                  force_unique=False):
        """Get the RRset with the given attributes in the specified section.

        If the RRset is not found, None is returned.

        *section*, an ``int`` section number, or one of the section
        attributes of this message.  This specifies the
        the section of the message to search.  For example::

            my_message.get_rrset(my_message.answer, name, rdclass, rdtype)
            my_message.get_rrset(dns.message.ANSWER, name, rdclass, rdtype)

        *name*, a ``dns.name.Name``, the name of the RRset.

        *rdclass*, an ``int``, the class of the RRset.

        *rdtype*, an ``int``, the type of the RRset.

        *covers*, an ``int`` or ``None``, the covers value of the RRset.
        The default is ``None``.

        *deleting*, an ``int`` or ``None``, the deleting value of the RRset.
        The default is ``None``.

        *create*, a ``bool``.  If ``True``, create the RRset if it is not found.
        The created RRset is appended to *section*.

        *force_unique*, a ``bool``.  If ``True`` and *create* is also ``True``,
        create a new RRset regardless of whether a matching RRset exists
        already.  The default is ``False``.  This is useful when creating
        DDNS Update messages, as order matters for them.

        Returns a ``dns.rrset.RRset object`` or ``None``.
        """

        try:
            rrset = self.find_rrset(section, name, rdclass, rdtype, covers,
                                    deleting, create, force_unique)
        except KeyError:
            rrset = None
        return rrset

    def to_wire(self, origin=None, max_size=0, multi=False, tsig_ctx=None,
                **kw):
        """Return a string containing the message in DNS compressed wire
        format.

        Additional keyword arguments are passed to the RRset ``to_wire()``
        method.

        *origin*, a ``dns.name.Name`` or ``None``, the origin to be appended
        to any relative names.  If ``None``, and the message has an origin
        attribute that is not ``None``, then it will be used.

        *max_size*, an ``int``, the maximum size of the wire format
        output; default is 0, which means "the message's request
        payload, if nonzero, or 65535".

        *multi*, a ``bool``, should be set to ``True`` if this message is
        part of a multiple message sequence.

        *tsig_ctx*, a ``dns.tsig.HMACTSig`` or ``dns.tsig.GSSTSig`` object, the
        ongoing TSIG context, used when signing zone transfers.

        Raises ``dns.exception.TooBig`` if *max_size* was exceeded.

        Returns a ``bytes``.
        """

        if origin is None and self.origin is not None:
            origin = self.origin
        if max_size == 0:
            if self.request_payload != 0:
                max_size = self.request_payload
            else:
                max_size = 65535
        if max_size < 512:
            max_size = 512
        elif max_size > 65535:
            max_size = 65535
        r = dns.renderer.Renderer(self.id, self.flags, max_size, origin)
        for rrset in self.question:
            r.add_question(rrset.name, rrset.rdtype, rrset.rdclass)
        for rrset in self.answer:
            r.add_rrset(dns.renderer.ANSWER, rrset, **kw)
        for rrset in self.authority:
            r.add_rrset(dns.renderer.AUTHORITY, rrset, **kw)
        if self.opt is not None:
            r.add_rrset(dns.renderer.ADDITIONAL, self.opt)
        for rrset in self.additional:
            r.add_rrset(dns.renderer.ADDITIONAL, rrset, **kw)
        r.write_header()
        if self.tsig is not None:
            (new_tsig, ctx) = dns.tsig.sign(r.get_wire(),
                                            self.keyring,
                                            self.tsig[0],
                                            int(time.time()),
                                            self.request_mac,
                                            tsig_ctx,
                                            multi)
            self.tsig.clear()
            self.tsig.add(new_tsig)
            r.add_rrset(dns.renderer.ADDITIONAL, self.tsig)
            r.write_header()
            if multi:
                self.tsig_ctx = ctx
        return r.get_wire()

    @staticmethod
    def _make_tsig(keyname, algorithm, time_signed, fudge, mac, original_id,
                   error, other):
        tsig = dns.rdtypes.ANY.TSIG.TSIG(dns.rdataclass.ANY, dns.rdatatype.TSIG,
                                         algorithm, time_signed, fudge, mac,
                                         original_id, error, other)
        return dns.rrset.from_rdata(keyname, 0, tsig)

    def use_tsig(self, keyring, keyname=None, fudge=300,
                 original_id=None, tsig_error=0, other_data=b'',
                 algorithm=dns.tsig.default_algorithm):
        """When sending, a TSIG signature using the specified key
        should be added.

        *key*, a ``dns.tsig.Key`` is the key to use.  If a key is specified,
        the *keyring* and *algorithm* fields are not used.

        *keyring*, a ``dict``, ``callable`` or ``dns.tsig.Key``, is either
        the TSIG keyring or key to use.

        The format of a keyring dict is a mapping from TSIG key name, as
        ``dns.name.Name`` to ``dns.tsig.Key`` or a TSIG secret, a ``bytes``.
        If a ``dict`` *keyring* is specified but a *keyname* is not, the key
        used will be the first key in the *keyring*.  Note that the order of
        keys in a dictionary is not defined, so applications should supply a
        keyname when a ``dict`` keyring is used, unless they know the keyring
        contains only one key.  If a ``callable`` keyring is specified, the
        callable will be called with the message and the keyname, and is
        expected to return a key.

        *keyname*, a ``dns.name.Name``, ``str`` or ``None``, the name of
        thes TSIG key to use; defaults to ``None``.  If *keyring* is a
        ``dict``, the key must be defined in it.  If *keyring* is a
        ``dns.tsig.Key``, this is ignored.

        *fudge*, an ``int``, the TSIG time fudge.

        *original_id*, an ``int``, the TSIG original id.  If ``None``,
        the message's id is used.

        *tsig_error*, an ``int``, the TSIG error code.

        *other_data*, a ``bytes``, the TSIG other data.

        *algorithm*, a ``dns.name.Name``, the TSIG algorithm to use.  This is
        only used if *keyring* is a ``dict``, and the key entry is a ``bytes``.
        """

        if isinstance(keyring, dns.tsig.Key):
            key = keyring
            keyname = key.name
        elif callable(keyring):
            key = keyring(self, keyname)
        else:
            if isinstance(keyname, str):
                keyname = dns.name.from_text(keyname)
            if keyname is None:
                keyname = next(iter(keyring))
            key = keyring[keyname]
            if isinstance(key, bytes):
                key = dns.tsig.Key(keyname, key, algorithm)
        self.keyring = key
        if original_id is None:
            original_id = self.id
        self.tsig = self._make_tsig(keyname, self.keyring.algorithm, 0, fudge,
                                    b'', original_id, tsig_error, other_data)

    @property
    def keyname(self):
        if self.tsig:
            return self.tsig.name
        else:
            return None

    @property
    def keyalgorithm(self):
        if self.tsig:
            return self.tsig[0].algorithm
        else:
            return None

    @property
    def mac(self):
        if self.tsig:
            return self.tsig[0].mac
        else:
            return None

    @property
    def tsig_error(self):
        if self.tsig:
            return self.tsig[0].error
        else:
            return None

    @property
    def had_tsig(self):
        return bool(self.tsig)

    @staticmethod
    def _make_opt(flags=0, payload=DEFAULT_EDNS_PAYLOAD, options=None):
        opt = dns.rdtypes.ANY.OPT.OPT(payload, dns.rdatatype.OPT,
                                      options or ())
        return dns.rrset.from_rdata(dns.name.root, int(flags), opt)

    def use_edns(self, edns=0, ednsflags=0, payload=DEFAULT_EDNS_PAYLOAD,
                 request_payload=None, options=None):
        """Configure EDNS behavior.

        *edns*, an ``int``, is the EDNS level to use.  Specifying
        ``None``, ``False``, or ``-1`` means "do not use EDNS", and in this case
        the other parameters are ignored.  Specifying ``True`` is
        equivalent to specifying 0, i.e. "use EDNS0".

        *ednsflags*, an ``int``, the EDNS flag values.

        *payload*, an ``int``, is the EDNS sender's payload field, which is the
        maximum size of UDP datagram the sender can handle.  I.e. how big
        a response to this message can be.

        *request_payload*, an ``int``, is the EDNS payload size to use when
        sending this message.  If not specified, defaults to the value of
        *payload*.

        *options*, a list of ``dns.edns.Option`` objects or ``None``, the EDNS
        options.
        """

        if edns is None or edns is False:
            edns = -1
        elif edns is True:
            edns = 0
        if edns < 0:
            self.opt = None
            self.request_payload = 0
        else:
            # make sure the EDNS version in ednsflags agrees with edns
            ednsflags &= 0xFF00FFFF
            ednsflags |= (edns << 16)
            if options is None:
                options = []
            self.opt = self._make_opt(ednsflags, payload, options)
            if request_payload is None:
                request_payload = payload
            self.request_payload = request_payload

    @property
    def edns(self):
        if self.opt:
            return (self.ednsflags & 0xff0000) >> 16
        else:
            return -1

    @property
    def ednsflags(self):
        if self.opt:
            return self.opt.ttl
        else:
            return 0

    @ednsflags.setter
    def ednsflags(self, v):
        if self.opt:
            self.opt.ttl = v
        elif v:
            self.opt = self._make_opt(v)

    @property
    def payload(self):
        if self.opt:
            return self.opt[0].payload
        else:
            return 0

    @property
    def options(self):
        if self.opt:
            return self.opt[0].options
        else:
            return ()

    def want_dnssec(self, wanted=True):
        """Enable or disable 'DNSSEC desired' flag in requests.

        *wanted*, a ``bool``.  If ``True``, then DNSSEC data is
        desired in the response, EDNS is enabled if required, and then
        the DO bit is set.  If ``False``, the DO bit is cleared if
        EDNS is enabled.
        """

        if wanted:
            self.ednsflags |= dns.flags.DO
        elif self.opt:
            self.ednsflags &= ~dns.flags.DO

    def rcode(self):
        """Return the rcode.

        Returns an ``int``.
        """
        return dns.rcode.from_flags(int(self.flags), int(self.ednsflags))

    def set_rcode(self, rcode):
        """Set the rcode.

        *rcode*, an ``int``, is the rcode to set.
        """
        (value, evalue) = dns.rcode.to_flags(rcode)
        self.flags &= 0xFFF0
        self.flags |= value
        self.ednsflags &= 0x00FFFFFF
        self.ednsflags |= evalue

    def opcode(self):
        """Return the opcode.

        Returns an ``int``.
        """
        return dns.opcode.from_flags(int(self.flags))

    def set_opcode(self, opcode):
        """Set the opcode.

        *opcode*, an ``int``, is the opcode to set.
        """
        self.flags &= 0x87FF
        self.flags |= dns.opcode.to_flags(opcode)

    def _get_one_rr_per_rrset(self, value):
        # What the caller picked is fine.
        return value

    # pylint: disable=unused-argument

    def _parse_rr_header(self, section, name, rdclass, rdtype):
        return (rdclass, rdtype, None, False)

    # pylint: enable=unused-argument

    def _parse_special_rr_header(self, section, count, position,
                                 name, rdclass, rdtype):
        if rdtype == dns.rdatatype.OPT:
            if section != MessageSection.ADDITIONAL or self.opt or \
               name != dns.name.root:
                raise BadEDNS
        elif rdtype == dns.rdatatype.TSIG:
            if section != MessageSection.ADDITIONAL or \
               rdclass != dns.rdatatype.ANY or \
               position != count - 1:
                raise BadTSIG
        return (rdclass, rdtype, None, False)

class ChainingResult:
    """The result of a call to dns.message.QueryMessage.resolve_chaining().

    The ``answer`` attribute is the answer RRSet, or ``None`` if it doesn't
    exist.

    The ``canonical_name`` attribute is the canonical name after all
    chaining has been applied (this is the name as ``rrset.name`` in cases
    where rrset is not ``None``).

    The ``minimum_ttl`` attribute is the minimum TTL, i.e. the TTL to
    use if caching the data.  It is the smallest of all the CNAME TTLs
    and either the answer TTL if it exists or the SOA TTL and SOA
    minimum values for negative answers.

    The ``cnames`` attribute is a list of all the CNAME RRSets followed to
    get to the canonical name.
    """
    def __init__(self, canonical_name, answer, minimum_ttl, cnames):
        self.canonical_name = canonical_name
        self.answer = answer
        self.minimum_ttl = minimum_ttl
        self.cnames = cnames

class QueryMessage(Message):
    def resolve_chaining(self):
        """Follow the CNAME chain in the response to determine the answer
        RRset.

        Raises ``dns.message.NotQueryResponse`` if the message is not
        a response.

        Raises ``dns.message.ChainTooLong`` if the CNAME chain is too long.

        Raises ``dns.message.AnswerForNXDOMAIN`` if the rcode is NXDOMAIN
        but an answer was found.

        Raises ``dns.exception.FormError`` if the question count is not 1.

        Returns a ChainingResult object.
        """
        if self.flags & dns.flags.QR == 0:
            raise NotQueryResponse
        if len(self.question) != 1:
            raise dns.exception.FormError
        question = self.question[0]
        qname = question.name
        min_ttl = dns.ttl.MAX_TTL
        answer = None
        count = 0
        cnames = []
        while count < MAX_CHAIN:
            try:
                answer = self.find_rrset(self.answer, qname, question.rdclass,
                                         question.rdtype)
                min_ttl = min(min_ttl, answer.ttl)
                break
            except KeyError:
                if question.rdtype != dns.rdatatype.CNAME:
                    try:
                        crrset = self.find_rrset(self.answer, qname,
                                                 question.rdclass,
                                                 dns.rdatatype.CNAME)
                        cnames.append(crrset)
                        min_ttl = min(min_ttl, crrset.ttl)
                        for rd in crrset:
                            qname = rd.target
                            break
                        count += 1
                        continue
                    except KeyError:
                        # Exit the chaining loop
                        break
                else:
                    # Exit the chaining loop
                    break
        if count >= MAX_CHAIN:
            raise ChainTooLong
        if self.rcode() == dns.rcode.NXDOMAIN and answer is not None:
            raise AnswerForNXDOMAIN
        if answer is None:
            # Further minimize the TTL with NCACHE.
            auname = qname
            while True:
                # Look for an SOA RR whose owner name is a superdomain
                # of qname.
                try:
                    srrset = self.find_rrset(self.authority, auname,
                                             question.rdclass,
                                             dns.rdatatype.SOA)
                    min_ttl = min(min_ttl, srrset.ttl, srrset[0].minimum)
                    break
                except KeyError:
                    try:
                        auname = auname.parent()
                    except dns.name.NoParent:
                        break
        return ChainingResult(qname, answer, min_ttl, cnames)

    def canonical_name(self):
        """Return the canonical name of the first name in the question
        section.

        Raises ``dns.message.NotQueryResponse`` if the message is not
        a response.

        Raises ``dns.message.ChainTooLong`` if the CNAME chain is too long.

        Raises ``dns.message.AnswerForNXDOMAIN`` if the rcode is NXDOMAIN
        but an answer was found.

        Raises ``dns.exception.FormError`` if the question count is not 1.
        """
        return self.resolve_chaining().canonical_name

def _maybe_import_update():
    # We avoid circular imports by doing this here.  We do it in another
    # function as doing it in _message_factory_from_opcode() makes "dns"
    # a local symbol, and the first line fails :)

    # pylint: disable=redefined-outer-name,import-outside-toplevel,unused-import
    import dns.update  # noqa: F401

def _message_factory_from_opcode(opcode):
    if opcode == dns.opcode.QUERY:
        return QueryMessage
    elif opcode == dns.opcode.UPDATE:
        _maybe_import_update()
        return dns.update.UpdateMessage
    else:
        return Message

class _WireReader:

    """Wire format reader.

    parser: the binary parser
    message: The message object being built
    initialize_message: Callback to set message parsing options
    question_only: Are we only reading the question?
    one_rr_per_rrset: Put each RR into its own RRset?
    keyring: TSIG keyring
    ignore_trailing: Ignore trailing junk at end of request?
    multi: Is this message part of a multi-message sequence?
    DNS dynamic updates.
    """

    def __init__(self, wire, initialize_message, question_only=False,
                 one_rr_per_rrset=False, ignore_trailing=False,
                 keyring=None, multi=False):
        self.parser = dns.wire.Parser(wire)
        self.message = None
        self.initialize_message = initialize_message
        self.question_only = question_only
        self.one_rr_per_rrset = one_rr_per_rrset
        self.ignore_trailing = ignore_trailing
        self.keyring = keyring
        self.multi = multi

    def _get_question(self, section_number, qcount):
        """Read the next *qcount* records from the wire data and add them to
        the question section.
        """

        section = self.message.sections[section_number]
        for _ in range(qcount):
            qname = self.parser.get_name(self.message.origin)
            (rdtype, rdclass) = self.parser.get_struct('!HH')
            (rdclass, rdtype, _, _) = \
                self.message._parse_rr_header(section_number, qname, rdclass,
                                              rdtype)
            self.message.find_rrset(section, qname, rdclass, rdtype,
                                    create=True, force_unique=True)

    def _get_section(self, section_number, count):
        """Read the next I{count} records from the wire data and add them to
        the specified section.

        section: the section of the message to which to add records
        count: the number of records to read
        """

        section = self.message.sections[section_number]
        force_unique = self.one_rr_per_rrset
        for i in range(count):
            rr_start = self.parser.current
            absolute_name = self.parser.get_name()
            if self.message.origin is not None:
                name = absolute_name.relativize(self.message.origin)
            else:
                name = absolute_name
            (rdtype, rdclass, ttl, rdlen) = self.parser.get_struct('!HHIH')
            if rdtype in (dns.rdatatype.OPT, dns.rdatatype.TSIG):
                (rdclass, rdtype, deleting, empty) = \
                    self.message._parse_special_rr_header(section_number,
                                                          count, i, name,
                                                          rdclass, rdtype)
            else:
                (rdclass, rdtype, deleting, empty) = \
                    self.message._parse_rr_header(section_number,
                                                  name, rdclass, rdtype)
            if empty:
                if rdlen > 0:
                    raise dns.exception.FormError
                rd = None
                covers = dns.rdatatype.NONE
            else:
                with self.parser.restrict_to(rdlen):
                    rd = dns.rdata.from_wire_parser(rdclass, rdtype,
                                                    self.parser,
                                                    self.message.origin)
                covers = rd.covers()
            if self.message.xfr and rdtype == dns.rdatatype.SOA:
                force_unique = True
            if rdtype == dns.rdatatype.OPT:
                self.message.opt = dns.rrset.from_rdata(name, ttl, rd)
            elif rdtype == dns.rdatatype.TSIG:
                if self.keyring is None:
                    raise UnknownTSIGKey('got signed message without keyring')
                if isinstance(self.keyring, dict):
                    key = self.keyring.get(absolute_name)
                    if isinstance(key, bytes):
                        key = dns.tsig.Key(absolute_name, key, rd.algorithm)
                elif callable(self.keyring):
                    key = self.keyring(self.message, absolute_name)
                else:
                    key = self.keyring
                if key is None:
                    raise UnknownTSIGKey("key '%s' unknown" % name)
                self.message.keyring = key
                self.message.tsig_ctx = \
                    dns.tsig.validate(self.parser.wire,
                                      key,
                                      absolute_name,
                                      rd,
                                      int(time.time()),
                                      self.message.request_mac,
                                      rr_start,
                                      self.message.tsig_ctx,
                                      self.multi)
                self.message.tsig = dns.rrset.from_rdata(absolute_name, 0, rd)
            else:
                rrset = self.message.find_rrset(section, name,
                                                rdclass, rdtype, covers,
                                                deleting, True,
                                                force_unique)
                if rd is not None:
                    if ttl > 0x7fffffff:
                        ttl = 0
                    rrset.add(rd, ttl)

    def read(self):
        """Read a wire format DNS message and build a dns.message.Message
        object."""

        if self.parser.remaining() < 12:
            raise ShortHeader
        (id, flags, qcount, ancount, aucount, adcount) = \
            self.parser.get_struct('!HHHHHH')
        factory = _message_factory_from_opcode(dns.opcode.from_flags(flags))
        self.message = factory(id=id)
        self.message.flags = dns.flags.Flag(flags)
        self.initialize_message(self.message)
        self.one_rr_per_rrset = \
            self.message._get_one_rr_per_rrset(self.one_rr_per_rrset)
        self._get_question(MessageSection.QUESTION, qcount)
        if self.question_only:
            return self.message
        self._get_section(MessageSection.ANSWER, ancount)
        self._get_section(MessageSection.AUTHORITY, aucount)
        self._get_section(MessageSection.ADDITIONAL, adcount)
        if not self.ignore_trailing and self.parser.remaining() != 0:
            raise TrailingJunk
        if self.multi and self.message.tsig_ctx and not self.message.had_tsig:
            self.message.tsig_ctx.update(self.parser.wire)
        return self.message

def from_wire(wire, keyring=None, request_mac=b'', xfr=False, origin=None,
              tsig_ctx=None, multi=False,
              question_only=False, one_rr_per_rrset=False,
              ignore_trailing=False, raise_on_truncation=False):
    """Convert a DNS wire format message into a message
    object.

    *keyring*, a ``dns.tsig.Key`` or ``dict``, the key or keyring to use
    if the message is signed.

    *request_mac*, a ``bytes``.  If the message is a response to a
    TSIG-signed request, *request_mac* should be set to the MAC of
    that request.

    *xfr*, a ``bool``, should be set to ``True`` if this message is part of
    a zone transfer.

    *origin*, a ``dns.name.Name`` or ``None``.  If the message is part
    of a zone transfer, *origin* should be the origin name of the
    zone.  If not ``None``, names will be relativized to the origin.

    *tsig_ctx*, a ``dns.tsig.HMACTSig`` or ``dns.tsig.GSSTSig`` object, the
    ongoing TSIG context, used when validating zone transfers.

    *multi*, a ``bool``, should be set to ``True`` if this message is
    part of a multiple message sequence.

    *question_only*, a ``bool``.  If ``True``, read only up to
    the end of the question section.

    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its
    own RRset.

    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
    junk at end of the message.

    *raise_on_truncation*, a ``bool``.  If ``True``, raise an exception if
    the TC bit is set.

    Raises ``dns.message.ShortHeader`` if the message is less than 12 octets
    long.

    Raises ``dns.message.TrailingJunk`` if there were octets in the message
    past the end of the proper DNS message, and *ignore_trailing* is ``False``.

    Raises ``dns.message.BadEDNS`` if an OPT record was in the
    wrong section, or occurred more than once.

    Raises ``dns.message.BadTSIG`` if a TSIG record was not the last
    record of the additional data section.

    Raises ``dns.message.Truncated`` if the TC flag is set and
    *raise_on_truncation* is ``True``.

    Returns a ``dns.message.Message``.
    """

    def initialize_message(message):
        message.request_mac = request_mac
        message.xfr = xfr
        message.origin = origin
        message.tsig_ctx = tsig_ctx

    reader = _WireReader(wire, initialize_message, question_only,
                         one_rr_per_rrset, ignore_trailing, keyring, multi)
    try:
        m = reader.read()
    except dns.exception.FormError:
        if reader.message and (reader.message.flags & dns.flags.TC) and \
           raise_on_truncation:
            raise Truncated(message=reader.message)
        else:
            raise
    # Reading a truncated message might not have any errors, so we
    # have to do this check here too.
    if m.flags & dns.flags.TC and raise_on_truncation:
        raise Truncated(message=m)

    return m

class _TextReader:

    """Text format reader.

    tok: the tokenizer.
    message: The message object being built.
    DNS dynamic updates.
    last_name: The most recently read name when building a message object.
    one_rr_per_rrset: Put each RR into its own RRset?
    origin: The origin for relative names
    relativize: relativize names?
    relativize_to: the origin to relativize to.
    """

    def __init__(self, text, idna_codec, one_rr_per_rrset=False,
                 origin=None, relativize=True, relativize_to=None):
        self.message = None
        self.tok = dns.tokenizer.Tokenizer(text, idna_codec=idna_codec)
        self.last_name = None
        self.one_rr_per_rrset = one_rr_per_rrset
        self.origin = origin
        self.relativize = relativize
        self.relativize_to = relativize_to
        self.id = None
        self.edns = -1
        self.ednsflags = 0
        self.payload = DEFAULT_EDNS_PAYLOAD
        self.rcode = None
        self.opcode = dns.opcode.QUERY
        self.flags = 0

    def _header_line(self, _):
        """Process one line from the text format header section."""

        token = self.tok.get()
        what = token.value
        if what == 'id':
            self.id = self.tok.get_int()
        elif what == 'flags':
            while True:
                token = self.tok.get()
                if not token.is_identifier():
                    self.tok.unget(token)
                    break
                self.flags = self.flags | dns.flags.from_text(token.value)
        elif what == 'edns':
            self.edns = self.tok.get_int()
            self.ednsflags = self.ednsflags | (self.edns << 16)
        elif what == 'eflags':
            if self.edns < 0:
                self.edns = 0
            while True:
                token = self.tok.get()
                if not token.is_identifier():
                    self.tok.unget(token)
                    break
                self.ednsflags = self.ednsflags | \
                    dns.flags.edns_from_text(token.value)
        elif what == 'payload':
            self.payload = self.tok.get_int()
            if self.edns < 0:
                self.edns = 0
        elif what == 'opcode':
            text = self.tok.get_string()
            self.opcode = dns.opcode.from_text(text)
            self.flags = self.flags | dns.opcode.to_flags(self.opcode)
        elif what == 'rcode':
            text = self.tok.get_string()
            self.rcode = dns.rcode.from_text(text)
        else:
            raise UnknownHeaderField
        self.tok.get_eol()

    def _question_line(self, section_number):
        """Process one line from the text format question section."""

        section = self.message.sections[section_number]
        token = self.tok.get(want_leading=True)
        if not token.is_whitespace():
            self.last_name = self.tok.as_name(token, self.message.origin,
                                              self.relativize,
                                              self.relativize_to)
        name = self.last_name
        if name is None:
            raise NoPreviousName
        token = self.tok.get()
        if not token.is_identifier():
            raise dns.exception.SyntaxError
        # Class
        try:
            rdclass = dns.rdataclass.from_text(token.value)
            token = self.tok.get()
            if not token.is_identifier():
                raise dns.exception.SyntaxError
        except dns.exception.SyntaxError:
            raise dns.exception.SyntaxError
        except Exception:
            rdclass = dns.rdataclass.IN
        # Type
        rdtype = dns.rdatatype.from_text(token.value)
        (rdclass, rdtype, _, _) = \
            self.message._parse_rr_header(section_number, name, rdclass, rdtype)
        self.message.find_rrset(section, name, rdclass, rdtype, create=True,
                                force_unique=True)
        self.tok.get_eol()

    def _rr_line(self, section_number):
        """Process one line from the text format answer, authority, or
        additional data sections.
        """

        section = self.message.sections[section_number]
        # Name
        token = self.tok.get(want_leading=True)
        if not token.is_whitespace():
            self.last_name = self.tok.as_name(token, self.message.origin,
                                              self.relativize,
                                              self.relativize_to)
        name = self.last_name
        if name is None:
            raise NoPreviousName
        token = self.tok.get()
        if not token.is_identifier():
            raise dns.exception.SyntaxError
        # TTL
        try:
            ttl = int(token.value, 0)
            token = self.tok.get()
            if not token.is_identifier():
                raise dns.exception.SyntaxError
        except dns.exception.SyntaxError:
            raise dns.exception.SyntaxError
        except Exception:
            ttl = 0
        # Class
        try:
            rdclass = dns.rdataclass.from_text(token.value)
            token = self.tok.get()
            if not token.is_identifier():
                raise dns.exception.SyntaxError
        except dns.exception.SyntaxError:
            raise dns.exception.SyntaxError
        except Exception:
            rdclass = dns.rdataclass.IN
        # Type
        rdtype = dns.rdatatype.from_text(token.value)
        (rdclass, rdtype, deleting, empty) = \
            self.message._parse_rr_header(section_number, name, rdclass, rdtype)
        token = self.tok.get()
        if empty and not token.is_eol_or_eof():
            raise dns.exception.SyntaxError
        if not empty and token.is_eol_or_eof():
            raise dns.exception.UnexpectedEnd
        if not token.is_eol_or_eof():
            self.tok.unget(token)
            rd = dns.rdata.from_text(rdclass, rdtype, self.tok,
                                     self.message.origin, self.relativize,
                                     self.relativize_to)
            covers = rd.covers()
        else:
            rd = None
            covers = dns.rdatatype.NONE
        rrset = self.message.find_rrset(section, name,
                                        rdclass, rdtype, covers,
                                        deleting, True, self.one_rr_per_rrset)
        if rd is not None:
            rrset.add(rd, ttl)

    def _make_message(self):
        factory = _message_factory_from_opcode(self.opcode)
        message = factory(id=self.id)
        message.flags = self.flags
        if self.edns >= 0:
            message.use_edns(self.edns, self.ednsflags, self.payload)
        if self.rcode:
            message.set_rcode(self.rcode)
        if self.origin:
            message.origin = self.origin
        return message

    def read(self):
        """Read a text format DNS message and build a dns.message.Message
        object."""

        line_method = self._header_line
        section_number = None
        while 1:
            token = self.tok.get(True, True)
            if token.is_eol_or_eof():
                break
            if token.is_comment():
                u = token.value.upper()
                if u == 'HEADER':
                    line_method = self._header_line

                if self.message:
                    message = self.message
                else:
                    # If we don't have a message, create one with the current
                    # opcode, so that we know which section names to parse.
                    message = self._make_message()
                try:
                    section_number = message._section_enum.from_text(u)
                    # We found a section name.  If we don't have a message,
                    # use the one we just created.
                    if not self.message:
                        self.message = message
                        self.one_rr_per_rrset = \
                            message._get_one_rr_per_rrset(self.one_rr_per_rrset)
                    if section_number == MessageSection.QUESTION:
                        line_method = self._question_line
                    else:
                        line_method = self._rr_line
                except Exception:
                    # It's just a comment.
                    pass
                self.tok.get_eol()
                continue
            self.tok.unget(token)
            line_method(section_number)
        if not self.message:
            self.message = self._make_message()
        return self.message

def from_text(text, idna_codec=None, one_rr_per_rrset=False,
              origin=None, relativize=True, relativize_to=None):
    """Convert the text format message into a message object.

    The reader stops after reading the first blank line in the input to
    facilitate reading multiple messages from a single file with
    ``dns.message.from_file()``.

    *text*, a ``str``, the text format message.

    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
    encoder/decoder.  If ``None``, the default IDNA 2003 encoder/decoder
    is used.

    *one_rr_per_rrset*, a ``bool``.  If ``True``, then each RR is put
    into its own rrset.  The default is ``False``.

    *origin*, a ``dns.name.Name`` (or ``None``), the
    origin to use for relative names.

    *relativize*, a ``bool``.  If true, name will be relativized.

    *relativize_to*, a ``dns.name.Name`` (or ``None``), the origin to use
    when relativizing names.  If not set, the *origin* value will be used.

    Raises ``dns.message.UnknownHeaderField`` if a header is unknown.

    Raises ``dns.exception.SyntaxError`` if the text is badly formed.

    Returns a ``dns.message.Message object``
    """

    # 'text' can also be a file, but we don't publish that fact
    # since it's an implementation detail.  The official file
    # interface is from_file().

    reader = _TextReader(text, idna_codec, one_rr_per_rrset, origin,
                         relativize, relativize_to)
    return reader.read()

def from_file(f, idna_codec=None, one_rr_per_rrset=False):
    """Read the next text format message from the specified file.

    Message blocks are separated by a single blank line.

    *f*, a ``file`` or ``str``.  If *f* is text, it is treated as the
    pathname of a file to open.

    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
    encoder/decoder.  If ``None``, the default IDNA 2003 encoder/decoder
    is used.

    *one_rr_per_rrset*, a ``bool``.  If ``True``, then each RR is put
    into its own rrset.  The default is ``False``.

    Raises ``dns.message.UnknownHeaderField`` if a header is unknown.

    Raises ``dns.exception.SyntaxError`` if the text is badly formed.

    Returns a ``dns.message.Message object``
    """

    with contextlib.ExitStack() as stack:
        if isinstance(f, str):
            f = stack.enter_context(open(f))
        return from_text(f, idna_codec, one_rr_per_rrset)

def make_query(qname, rdtype, rdclass=dns.rdataclass.IN, use_edns=None,
               want_dnssec=False, ednsflags=None, payload=None,
               request_payload=None, options=None, idna_codec=None):
    """Make a query message.

    The query name, type, and class may all be specified either
    as objects of the appropriate type, or as strings.

    The query will have a randomly chosen query id, and its DNS flags
    will be set to dns.flags.RD.

    qname, a ``dns.name.Name`` or ``str``, the query name.

    *rdtype*, an ``int`` or ``str``, the desired rdata type.

    *rdclass*, an ``int`` or ``str``,  the desired rdata class; the default
    is class IN.

    *use_edns*, an ``int``, ``bool`` or ``None``.  The EDNS level to use; the
    default is None (no EDNS).
    See the description of dns.message.Message.use_edns() for the possible
    values for use_edns and their meanings.

    *want_dnssec*, a ``bool``.  If ``True``, DNSSEC data is desired.

    *ednsflags*, an ``int``, the EDNS flag values.

    *payload*, an ``int``, is the EDNS sender's payload field, which is the
    maximum size of UDP datagram the sender can handle.  I.e. how big
    a response to this message can be.

    *request_payload*, an ``int``, is the EDNS payload size to use when
    sending this message.  If not specified, defaults to the value of
    *payload*.

    *options*, a list of ``dns.edns.Option`` objects or ``None``, the EDNS
    options.

    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
    encoder/decoder.  If ``None``, the default IDNA 2003 encoder/decoder
    is used.

    Returns a ``dns.message.QueryMessage``
    """

    if isinstance(qname, str):
        qname = dns.name.from_text(qname, idna_codec=idna_codec)
    rdtype = dns.rdatatype.RdataType.make(rdtype)
    rdclass = dns.rdataclass.RdataClass.make(rdclass)
    m = QueryMessage()
    m.flags |= dns.flags.RD
    m.find_rrset(m.question, qname, rdclass, rdtype, create=True,
                 force_unique=True)
    # only pass keywords on to use_edns if they have been set to a
    # non-None value.  Setting a field will turn EDNS on if it hasn't
    # been configured.
    kwargs = {}
    if ednsflags is not None:
        kwargs['ednsflags'] = ednsflags
    if payload is not None:
        kwargs['payload'] = payload
    if request_payload is not None:
        kwargs['request_payload'] = request_payload
    if options is not None:
        kwargs['options'] = options
    if kwargs and use_edns is None:
        use_edns = 0
    kwargs['edns'] = use_edns
    m.use_edns(**kwargs)
    m.want_dnssec(want_dnssec)
    return m

def make_response(query, recursion_available=False, our_payload=8192,
                  fudge=300, tsig_error=0):
    """Make a message which is a response for the specified query.
    The message returned is really a response skeleton; it has all
    of the infrastructure required of a response, but none of the
    content.

    The response's question section is a shallow copy of the query's
    question section, so the query's question RRsets should not be
    changed.

    *query*, a ``dns.message.Message``, the query to respond to.

    *recursion_available*, a ``bool``, should RA be set in the response?

    *our_payload*, an ``int``, the payload size to advertise in EDNS
    responses.

    *fudge*, an ``int``, the TSIG time fudge.

    *tsig_error*, an ``int``, the TSIG error.

    Returns a ``dns.message.Message`` object whose specific class is
    appropriate for the query.  For example, if query is a
    ``dns.update.UpdateMessage``, response will be too.
    """

    if query.flags & dns.flags.QR:
        raise dns.exception.FormError('specified query message is not a query')
    factory = _message_factory_from_opcode(query.opcode())
    response = factory(id=query.id)
    response.flags = dns.flags.QR | (query.flags & dns.flags.RD)
    if recursion_available:
        response.flags |= dns.flags.RA
    response.set_opcode(query.opcode())
    response.question = list(query.question)
    if query.edns >= 0:
        response.use_edns(0, 0, our_payload, query.payload)
    if query.had_tsig:
        response.use_tsig(query.keyring, query.keyname, fudge, None,
                          tsig_error, b'', query.keyalgorithm)
        response.request_mac = query.mac
    return response

### BEGIN generated MessageSection constants

QUESTION = MessageSection.QUESTION
ANSWER = MessageSection.ANSWER
AUTHORITY = MessageSection.AUTHORITY
ADDITIONAL = MessageSection.ADDITIONAL

### END generated MessageSection constants

redpajama_set_name: RedPajamaGithub


text:
Q: AppLoading errors/issues for expo SDK version: 44
My problem seems to be that I'm unable to install AppLoading on Expo.
Looking inside the package.json dependencies, I'm not able to find expo-app-loading
It says I have to install it manually by typing: expo install expo-app-loading in the terminal. I've tried doing so but nothing changes and I still can't see expo-app-loading installed in package.json dependencies.
As soon as I import AppLoading from 'expo-app-loading'; I get bombarded by errors that I've copy/pasted below:
Any help on how to solve this issue would be greatly appreciated!

1 | import React from 'react';
2 |
3 | import { AppLoadingProps } from './AppLoading.types';
4 | import NativeAppLoading from './AppLoadingNativeWrapper';
…/…/…/…/…/node_modules/expo-app-loading/build/AppLoadingNativeWrapper.js:2
Module not found: Can't resolve 'react'
1 | import * as SplashScreen from 'expo-splash-screen';
2 | import React from 'react';
3 |
4 | type Props = {
5 | autoHideSplash?: boolean;
…/…/…/…/…/node_modules/expo-modules-core/build/PermissionsHook.js:1
Module not found: Can't resolve 'react'
1 | import { useCallback, useEffect, useRef, useState } from 'react';
2 |
3 | import { PermissionResponse } from './PermissionsInterface';
4 |
C:/Users/Admin/node_modules/expo-modules-core/build/index.js
Module not found: Error: Can't resolve 'react-native-web/dist/exports/DeviceEventEmitter' in 'C:\Users\Admin\node_modules\expo-modules-core\build'
C:/Users/Admin/node_modules/expo-modules-core/build/EventEmitter.js
Module not found: Error: Can't resolve 'react-native-web/dist/exports/NativeEventEmitter' in 'C:\Users\Admin\node_modules\expo-modules-core\build'
C:/Users/Admin/node_modules/expo-modules-core/build/Platform.js
Module not found: Error: Can't resolve 'react-native-web/dist/exports/Platform' in 'C:\Users\Admin\node_modules\expo-modules-core\build'
C:/Users/Admin/node_modules/expo-modules-core/build/EventEmitter.js
Module not found: Error: Can't resolve 'react-native-web/dist/exports/Platform' in 'C:\Users\Admin\node_modules\expo-modules-core\build'
…/…/…/…/…/node_modules/expo-modules-core/build/SyntheticPlatformEmitter.web.js:5
Module not found: Can't resolve 'react-native-web/dist/vendor/react-native/NativeEventEmitter/RCTDeviceEventEmitter'
3 | * registered in the API layer with NativeEventEmitter.
4 | */
5 | export { default } from 'react-native-web/dist/vendor/react-native/NativeEventEmitter/RCTDeviceEventEmitter';
6 |
Error from chokidar (C:): Error: EBUSY: resource busy or locked, lstat 'C:\DumpStack.log.tmp'```

redpajama_set_name: RedPajamaStackExchange


text:
Désert Blues est un film réalisé en 2006 par Michel Jaffrennou.

Synopsis
Issus d'ethnies différentes, trois artistes maliens se réunissent pour faire entendre le désert : Habib Koité, le Bambara, descendant des Khassonkés de l'ouest du Mali, Afel Bocoum, le Songhai, considéré comme l'héritier d'Ali Farka Touré, et Tartit, groupe de femmes touaregs de Tombouctou, proches ethniquement des Berbères et parole engagée d'un peuple qui survit. La réunion de ces trois artistes représente un véritable événement politique face aux événements tragiques qui ont ébranlé le Mali dans les années 1995-1996.

Fiche technique
 Réalisation : Michel Jaffrenou
 Scénario : Michel Jaffrenou
 Production : Mondomix Média, Arte France, Contre-Jour, Divano Production, Mali K7
 Image : Emmanuel Soyer
 Son : Yves Wernert
 Montage : Nicolas Sardjvéladzé

Récompenses
 Festival Internacional de Cine de África y de las Islas (FIFAI), La Reunión, 2007

Références

Voir aussi

Article connexe
 Histoire du Mali

Liens externes

Téléfilm français des années 2000
Téléfilm belge des années 2000
Téléfilm diffusé en 2006
Téléfilm documentaire
Film se déroulant au Mali
Bambaras
Film documentaire sur un chanteur

redpajama_set_name: RedPajamaWikipedia


text:
6.6 Second Style Roman Wall Painting and the Family of Augustus
罗马建筑
Roman Architecture is a course for people who love to travel and want to discover the power of architecture to shape politics, society, and culture.
truly a really well structured course with very interesting content. exactly the kind of thing i wish i could have done at university!
an excellent course on Roman Art and Architecture. The Professor is a great teacher and the illustrations are wonderful. Thank you.
Habitats at Herculaneum and Early Roman Interior Decoration
What befell the city of Herculaneum's inhabitants when they tried to escape Vesuvius. The development of the city's domestic architecture, especially the Houses of the Mosaic Atrium and the Stags, is traced as is the evolution of First and Second Style Roman wall painting, the latter transforming the flat wall into a panoramic window.
6.1 Introduction and the History of Herculaneum 13:30
6.2 Houses at Herculaneum and the Samnite House 7:06
6.3 Further Developments in Domestic Architecture at Herculaneum: The House of the Mosaic Atrium and the House of the Stags 17:13
6.4 First Style Roman Wall Painting14:18
6.5 Second Style Roman Wall Painting 12:17
6.6 Second Style Roman Wall Painting and the Family of Augustus8:27
Diana E.E. Kleiner
Dunham Professor of History of Art and Classics at Yale University
選擇語言中文(簡體)土耳其語(Turkish)希臘語意大利語英語(English)西班牙語(Spanish)
I want to show you, in the few minutes that remain, just two more houses quickly.
One of them, both of them are important though.
Because they belonged to the Emperor and Empress to Augustus and to Livia.
Augustus purchased some property on the Palatine Hill.
He wanted to live as Rome's first Emperor of Rome, he
wanted to live where Romulus had lived before him, of course.
And he buys some property up here,
builds a house, he puts a, a temple to his patron god, right next door, Apollo.
And then Livia has her own house right across the street: his wife Livia.
She lives with him in his house, but she's
also got her own house right across the street.
And both of these houses were decorated with paintings.
I want to show you first the ones in the House of Augustus, the
most famous room in the House of Augustus, called the Room of the Masks.
And here is where we see most
clearly the possible relationship between Roman wall painting
of the Second Style--because this is also
Second Style Roman wall painting, and the theater.
You look at the restored view at the top, of
a typical theater facade as we think it would've looked, a
theater stage building, as we think it would have looked
early on, possibly made out of wood again rather than stone.
has a central section with a pediment and then it
has two wings and we see the same scheme here.
The central section which is called
technically a regia in theater architecture,
r-e-g-i-a, and then two wings that
are technically called hospitalia, h-o-s-p-i-t-a-l-i-a; hospitalia.
So this tripartite scheme of a Roman theater.
And if, if that is lost on us, note that
there are masks, one on either side, theatrical masks that also
give us a hint that we are looking at a theater set.
Here's a more vivid view of one of the walls, where you
can see that tripartite type division into central section and two wings.
You can see the masks and you can see a view into some sort of landscape.
The sky is no longer blue, it's white, but it does continue back beyond,
behind the architecture.
So you get the sense that you're being beckoned into.
There's no, in fact there's no barrier here at all.
The wall is gone here. There's no gateway.
You can walk right in to this. What is this?
There's no blue sky, so it doesn't look as real as the others did.
It's not the sort of thing that might
have been right outside your window, of a house.
It's some kind of sacred landscape, some kind of strange, sacred landscape with
a curved colonnade, with a tree, and with a very phallic
looking shrine here in the center, some kind of sacred space.
We call these sacro-idyllic landscapes, sort of idyllic and sacred
at the same time that you're being beckoned into to explore.
Again, this is a stage set of some sort?
Or is it something else?
Is it something that makes religious connot-, has religious connotations.
The other interesting thing [COUGH] about the room
of the masks in the House of Augustus
is that some scholars have claimed that, although
it is usually said that one-point linear perspective,
in which all lines converge at a single point in the distance, was created in the,
was invented in the Renaissance, a case can
be made that it was invented in Roman times.
And if, if it happened, it happened here
in this house where-- and, and scholars, even
of the Renaissance, have studied the way in
which these points converge in this painting all
the way to a point at the end.
So if that's true, the Romans may
have done that, perhaps inadvertently, perhaps on purpose.
They were very interested in perspective.
I'll say a bit more about that in a moment.
But if they invented it here, they quickly rejected
it, as we're going to see, in next week's lecture.
Just a couple of details, the mask and the beautiful way in
which this very talented artist probably one of the best artists of
the day, has build up this mask out of, out of, out
of you know, touches of gray and white and black, an extraordinary thing.
And then again I really do urge you to, to look at these de, and
look at these paintings in detail, because if you do you will be very rewarded.
You'll see all kinds of strange creatures,
like winged figures, this very strange thing lurking up there.
Is that vegetal?
Is it animal? Is it human?
These wonderful, what look like swans, golden swans that decorate this.
When you look very close, you can see there's a figural frieze here.
And look at that wonderful representation of the fruit or vegetables in a
bowl, a bowl that is represented
so magnificently and translucently by the artist.
In the, in the maybe three minutes or so
that remain, I want to show you one last painting.
And it's a very special painting indeed, and I think
it ties together everything that we've been talking about today.
It is a painting from, not the House of Livia, where
there are some preserved paintings, we're not going to look at those.
But from a villa of Livia, located north of Rome at
a place called Prima Porta, the Villa of Livia at Prima Porta.
And it is the, in a sense, the ultimate example
and the very last gasp of Second Style Roman wall painting.
The villa was put up in 30 to 25
B.C., a barrel-vaulted room was decorated with this gardenscape.
Now as you look at this, you'd probably say to
me, that's, doesn't look like anything we've looked at today.
There's no architecture there, there's no remnants of a First Style wall.
There are no projecting columns.
There are no black curtains and so on and so forth.
It's very different from anything we've seen.
But we categorize this as a Second Style wall.
Why do we do that?
Because there's a division between where we stand as
spectator and the space that lies beyond the fence.
There is a fence, divides our space from the space
that lies outside, but it's a very, very, very delicate fence.
A white, kind of lattice fence, not unlike one we saw in the Samnite
house on the second story.
We don't have columns, we have trees, a different kind of upright here.
But what connects this to the Second Style is that it is
the ultimate example of a Roman painting as a panoramic picture window.
This is what, this was the, this is what they hope you would see when you looked
out of the rooms of your house, of
your great bay window of the Villa of Mysteries.
You didn't see the sea, you would see some
glorious landscape, out gardenscape, out aside
of your window, with beautiful trees.
This is, if you look at these with care you will see that
this is an artist who understood nature and observed it, who knew the difference.
Between, among the fruits that would be on trees
like this, they're fruit trees here, who knew, who had
a sense of the way in which birds would
alight on a leaf if they were headed toward one.
Who had a sense of the way in which leaves
would rustle in the breeze, who had a sense of the way in which light can fall
differently on a leaf, so that you sometimes
see the lighted side, or the side in shadow.
This is an artist who has really observed nature and has depicted what he saw.
And here are a couple of details where you can see that very well, of this tree.
You see what I mean by some leaves cast
in shadow, some leaves have light shining on them.
You get a sense of the breeze.
You get this wonderful, wonderful way on which this
black bird alights on the edge of a leaf.
This bird over here, is surveying this piece of
fruit, deciding whether he wants to peck it or not.
This is very sophisticated stuff.
And, you can also see, if you explore
this, this painting a bit more, that it has,
that it partakes of what we call today
atmospheric perspective, not one point perspective, but atmospheric perspective.
What is atmospheric perspective?
If you look at this carefully you will see that all of the items
that are in, all the objects that
are in the foreground have very distinct outlines.
Whereas those in the middle ground are a little
fuzzier, and those way in the background are fuzzier still.
And there're actually probably could barely see
them but they're actually mountains in the distance.
And those mountains in the distance are so fuzzy,
and their silhouette that you can barely see them.
But you get this sense of space,
of moving back because of this use of atmospheric perspective.
So this, the ultimate, Roman painting, Second Style.
The Roman painting, as panorama, that again
corresponds so well, to all the discussions
we've been having in the last couple
of lectures of this move towards increased vista.
Increased panorama, both in painting and also in architecture.

redpajama_set_name: RedPajamaCommonCrawl


text:
'Christian Voice is outside, praying for our souls ... '
What's it like to direct a play amid pickets and religious riots? Stewart Lee on the battle to keep Jerry Springer - the Opera on the road
Hot potato... a scene from the National Theatre production of Jerry Springer the Opera
Wed 15 Feb 2006 06.26 EST
Richard Thomas' multi-award winning musical Jerry Springer - the Opera, which I directed, is finally on the road. Christian groups scared one-third of possible venues off a proposed tour last year with threats of prosecution for blasphemy, but Plymouth Theatre Royal, Birmingham Hippodrome and His Majesty's Theatre Aberdeen helped devise a rescue package on a reduced budget and, after a year of frustration, we are now up and running. Choreographer Jenny Arnold and I returned for our seventh attempt at staging JSTO in a record time of three weeks, waiving our royalty payments, as have all the core creative team, to cut costs.
I arrive in Plymouth for five days of technical rehearsals. I'm staying at the Quality Inn, east of the multi-storeys, overlooking the sea. As a stand-up, I've been on the road for 12 of the past 14 months. I am at home in hotel rooms, with their tea bags, individually wrapped soaps and the rubbish in-house Fantastic Four movie.
On entering the neutral space of room 405, I line up the books I have brought as a magical firewall. I'm packing Bertrand Russell, Kierkegaard, DH Lawrence essays and Richard Holloway, the former Bishop of Edinburgh, so I'm up to speed in the case for the defence. This may seem paranoid to you, but it was only the late entry of the BNP into the Plymouth Stop Springer campaign that seemed to fragment a coalition of 1,200 religious protestors. Never mind, I suppose it's good that the BNP has finally formulated an arts policy.
Public relations people at Plymouth Theatre Royal discuss how to rescue the show from the Christian right and restate its artistic credentials. Next I hear the theatre house manager's plans for dealing with any violent protestors. This doesn't happen on the We Will Rock You tour. In the afternoon the cast arrive. I feel a paternal love for the young ones, and a filial gratitude to the veterans. An Equity rep tells them the union is fighting for their right to perform, and combating the withdrawal from Sainsbury's and Woolworths of the opera's DVD, following complaints from Christian Voice.
I pitch in that it's about economics, and while it seems odd for the much-trumpeted arts sponsors Sainsbury's to cave in, ultimately Sainsbury's are nothing more than another big business, and capitalism makes slaves of us all. Then I realise I'd probably better leave.
The vast machine of the technical rehearsal lumbers into action. The 21 actors wait patiently on stage for the following four days while lights and equipment are arranged around them. Everyone is fighting the budgetary restrictions brought about by the Christian fundamentalists. A computerised flying gibbet, to swing Jerry over the fires of hell, would have cost more than our manual one, but might have saved expensive man-hours. Rolf Saxon, the charming American actor playing Springer, rises and falls erratically for half a day while this clanking metaphor for his moral descent is calibrated for maximum symbolic effect.
Christian Voice assembles outside the theatre, praying for the souls of those involved in the production. Rolf is apparently portraying a version of the Antichrist, a part neither Richard nor I remember writing. Even though only 35 protesters show, it still creates something of a frisson, and the standing ovation at the end of the show, which seems utterly innocuous and good-natured in comparison with the complaints now levelled against it, is perhaps partly informed by the audience's irritation at the protests.
There were no protestors present tonight but the piece was again brilliantly received, despite the reduced external excitement. I was very relieved by this, realising again that, underneath all the arguments about meaning and freedom of speech, the idea of what you can and can't say and about re-writing the rules of musical theatre, Jerry Springer - the Opera remains a great night out.
Press night. Previous incarnations of the opera had enjoyed universal acclaim, with the exception of Michael Coveney in the Daily Mail and Maddy Costa in this paper, but will compassion fatigue set in? The Stage suggested that the collapse of the tour was a publicity stunt, which was annoying for people who had spent a year working hard to salvage it. A local vicar wrote in today's Plymouth Herald that the second half of the show, which is set in hell, made him feel like he was "in hell", and said: "You could read it as much as a celebration of Springer, as an attack on it." This, of course, has always been our intention, and the cast have worked hard to avoid applying an ironic gloss to the characters,allowing the audience to make up their own minds about the subject matter. Thus, I was able to read his comments to the company as an example of how well they were doing.
On the way out of the theatre I pick up a letter from a woman in Kingsteignton who is looking forward to the moment that I stand before God and am sent to hell. Idiot.
Journalists and an MP want me to speak about the government's badly thought out incitement to religious hatred bill, which is debated today, and how it will affect the arts. I'd love to do this, but worry about being billed as a representative of the opera itself, and compromising my co-workers. The bill appears to suggest, for example, that the opera could be closed down immediately if there was a complaint while police investigate it, and that even our own intent for the piece would be no excuse for any offence caused, so I sign on. The show gets another ovation. I get a text from the Lib Dems' Evan Harris saying the bill has been defeated.
I should have left Plymouth by now, except that I'm down to do an after-show talk later. Cast member Valda Aviks makes an unannounced case for the piece as a Christian allegory for free will, which is delightful, if unexpected. Everyone asks great questions and there's none of the gay-hate angle that characterised some of the questions from born-again Christians at a similar event in Aberdeen last year.
In my new capacity as sin-eater for the religious guilt of the entire world, I fulfil a lifetime's ambition by appearing on the Today programme, with a member of the Muslim Council to discuss the Danish Mohammed cartoon controversy. Everyone's anxious to draw parallels with the opera's persecution by the Christian right, but the Danish cartoonists wandered into a world of protected religious symbols they didn't understand. We have used a set of icons whose implications we appreciate, within a tradition of Christian imagery. And you can now buy Virgin Mary snow-globes in Vatican Square, so it's a bit late to start getting all protective.
I have a one-off performance of my 2005 stand-up show, 90s Comedian, at the Hackney Empire in London. The piece was a response to my own experiences of religious censorship but, in the light of the Danish cartoon row, I feel like its meaning is running away without my permission, and I find myself trying to re-edit sentences on stage so that I am not misunderstood. The final five minutes feel like a rally, which is always worrying.
Richard and I do an hour-long live interview with a Yorkshire radio station, to try and defuse the controversy before the show plays York later this month. Afterwards we realise how emboldened we both feel by the show's touring success so far, and it is a pleasure to be able to speak from a position of strength and confidence again, rather than to be on the back foot apologising, often for things that aren't even in the opera. For the record, there aren't 8,000 swear words. There are 174. And Jesus isn't in a nappy. OK?
I arrive in Birmingham, my old home town, for the press night at the Hippodrome where, as a child, I saw Dexy's Midnight Runners, the Smiths and Rod Hull and Emu. The show plays to 1,400, its biggest ever crowd, and goes down a storm. Local papers are going through a now predictable cycle of outraged editorials and letters pages, followed by praise and articles saying how absurd the negative reaction is when the piece is clearly about love, tolerance and forgiveness. And opera singers swearing, of course.
Outside, a bedraggled protestor hands me a leaflet complaining that the show calls God "the fascist tyrant on high". The line appears in the show on a note written by Satan and is derived from Milton's Paradise Lost. Have any of these protesters actually seen the opera?
We do a day of interviews and it's brilliant to talk to people who have actually seen the show and know what's in it, rather than to people who haven't and don't. I lost my temper with a Leicester journalist telling me about a coalition of local vicars trying to stop the opera playing a publicly funded venue there. "Public-funded art is for everyone, not just some stupid vicars." Word of mouth in Birmingham, where I once saw sausages thrown into the face of Morrissey, the vegetarian lead singer of the Smiths, is good. At night, my old English teacher comes to see the show. "I expect he's very proud," says a cast member, sarcastically. Tomorrow there's a public debate in York, and more in Leicester at the weekend, but having spent a year in the news, Jerry Springer - the Opera is finally becoming art again.
· Jerry Springer - the Opera is at the Hippodrome, Birmingham (0870 730 1234), until Saturday, then tours.


text:
Stereosonic 2014
Stereosonic's Co-Founder Is Over The Festival's Roided-Up "Muscle Culture"
"We are sick of the charged up violence you bring…"
WATCH: Karl Stefanovic Loves Getting "Absolutely Peking Duk'd"
Some Stereosonic festival goers were lucky enough to bask in the digital presence of Channel Nine Today show host Karl Stefanovic over the past few weeks. We're not talking holograms, as glorious as that would be. We're talking a Karl-fronted hype video for electronic duo Peking Duk, which was played before their sets at the
Hundreds Of Drug-Related Arrests At Stereosonic This Weekend
Almost 250 punters were collectively charged at various Stereosonic festivals held in Brisbane, Melbourne and Adelaide this weekend with the majority of offences being drug related. On top of the reported 120 Melbourne festival-goers that were busted by Victorian police, another 103 were arrested on 111 charges by Queensland police, according to the Brisbane Times,
Over 120 Fans Busted On Drug-Related Charges At Stereosonic Melbourne
More unwelcome news for fans attending Australian music festival Stereosonic, with over 120 Melbourne festival-goers busted by Victorian police in procession of illegal drugs. 9News reports that those caught by police were most commonly carrying ecstasy, while LSD and ice were also found. Police patrolled inside the Melbourne Showgrounds and positioned sniffer dogs at the
EXCLUSIVE: New Footage Shows Full Extent Of Massive Stereosonic Brawl
"It was too big to contain. When you see it, you wouldn't want to be in it."
This Video Will Make You Grateful You Avoided Stereosonic
UPDATE: NEW FOOTAGE SHOWS FULL EXTENT OF MASSIVE "ALL-IN BRAWL" AT STEREOSONIC Footage of an all-out brawl at the Sydney leg of Stereosonic has surfaced online. The footage (below), captured at Sydney Olympic Park over the weekend, shows a large group of festival-goers awkwardly battling it out for a number of minutes, before security personnel
Watch A Fake Steve Aoki Troll Punters At Stereosonic
Jarrad Seng has out-trolled the lot of us.
Hundreds Charged With Drug Offences At Stereosonic
NSW Police are "disappointed" after 221 Stereosonic festivalgoers were charged with drug offences in Sydney over the weekend, and say one man is lucky to be alive after collapsing at the festival. In a press release, NSW Police say that more than 830 of the roughly 81,000 people who attended the Sydney leg of Stereosonic
Travel To Stereosonic With Steve Aoki On Uber's Superyacht
Stereosonic 2014 is set to get underway this weekend, starting at Sydney Showground, and for those still finalising their commuting plans Uber just may have the perfect solution. The ridesharing service are offering app users the chance to board a superyacht and cruise on over to the festival in style, alongside Steve Aoki. The cake-throwing
Stereosonic 2014 Timetables And Maps Unveiled
With less than a week to go before things kick off, the official set times and venue maps for Stereosonic 2014 have been revealed. The national electronic music festival, which will host sets from big-name acts such as Calvin Harris, Tiesto, Diplo, Disclosure and dubstep heavyweight Skrillex, will move through Sydney, Perth, Brisbane, Melbourne and
Stereosonic 2014 Lineup Grows By ZHU
Stereosonic has announced the addition of mysterious house musician ZHU to the festival's 2014 lineup. Stereosonic made the announcement today, posting a 15-second clip to Facebook featuring ZHU's logo and writing that the festival is pleased to include ZHU to all Stereosonic shows. ZHU sure is showing Australia the love since hitting the scene earlier
Stereosonic 2014 One Day Tickets On Sale Wednesday
Stereosonic 2014 organisers have announced that one day tickets for this year's festival will be available from 10am (AEST) Wednesday, 1st October. This marks the first time that punters will be able to purchase tickets to one day of Stereo since organisers launched their well-received two-day format last year. If you're a dance and urban
Porter Robinson: "I'm Not Changing To Make A Million Dollars"
American producer Porter Robinson had already scaled the heights of EDM supremacy by the time he hit his twenties. As a staple of dance festival main stages across the globe, his meteoric rise was helped by hits like Language and Easy, with Mat Zo. At 22, with the release of his impressive debut album, Worlds,
Stereosonic 2014 Lineup
Calvin Harris, Tiesto, Disclosure and so much more!
Stereosonic 2014 Lineup Here Tonight 8pm
Full lineup drops soon!
Adelaide On The Defensive After Noise Restriction Uproar
The Adelaide City Council have issued a response to the wave of online criticism directed towards their new noise restriction initiatives. Yesterday, Music Feeds reported on a vote taken by councillors Tuesday to introduce new noise pollution management procedures to "high risk" events. According to a report published yesterday by The Advertiser, councillors voted in
Stereosonic 2014 Lineup Announce Date
UPDATE: The Stereosonic 2014 lineup has arrived! Full details here. It's a fact universally acknowledged that Australia's favourite dance festival, Stereosonic, returns stronger each year, so it's no wonder fans are already buzzing about the Stereosonic 2014 lineup. Those fans will have even more reason to buzz when the lineup is revealed at 8pm, Tuesday,
Stereosonic 2014 Dates Announced
UPDATE: The Stereosonic 2014 lineup has arrived! Full details here. Following the successful launch of a two-day format in 2013, organisers have now announced the dates for Stereosonic 2014, confirming what punters had hoped since December, with Sydney, Perth, Adelaide, Melbourne, and Brisbane each set to receive a double Stereo dose in 2014. In addition


This degree explores governance, nation-building, and other implementation issues facing indigenous peoples both in the Americas and around the globe. The plan grounds students in tribal histories and cultures, governmental policies, sustainable economic development, cultural co-opting, and contemporary conditions on native lands and reservations.
The Applied Indigenous Studies program emphasizes contemporary tribal management skills and respect for the knowledge, values, and beliefs of indigenous cultures. You will prepare to tackle challenges facing today Native communities by complementing contemporary scholarship with traditional tribal knowledge.
Gain critical skills in economic development, policy articulation, and environmental studies. Study tribal histories and cultures, federal Indian policies, and contemporary reservation conditions. You will be encouraged to pursue research, fieldwork, and teaching opportunities. You'll graduate with the tools you need to contribute to your community.


text:
Electro Optic Systems Holdings Limited
Garry Hounsell
Mr Hounsell is Chair of the Commonwealth Superannuation Corporation. He is Chair of Helloworld Travel Limited (since 2016) and Non-Executive Director and Chair of Wine Operations and Sustainability at Treasury Wine Estates Limited (since 2012). Mr Hounsell is also a Director of Findex (since January 2020), a member of Commencer Capital's (formally Investec Emerging Companies) Investment Committee (since 2019) and Director and Chair of HiroBrands Limited (since December 2021).
Mr Hounsell was previously the Chair of Myer Holdings Limited (2017-2020; Executive Chair Feb-Jun 2018), Chair and a Non-Executive Director of Spotless Group Holdings Limited (2014-2017), and Chair of Emitch Limited (2006-2008) and PanAust Limited (2008-2015). He was also previously an Advisory Board Member of PanAust Limited (2015-2017), Rothschild Australia Limited (2012-2017), and Investec Global Aircraft Fund (2007-2019). He was a Director at Orica Limited (2004-2013), Nufarm Limited (2004-2012), Qantas Airways Limited (2005-2015), Mitchell Communication Group Limited (2008-2010), Integral Diagnostics Limited (2015-2017), Dulux Group Limited (2010-2017) and Investec Aircraft Syndicate Limited (2012-2018). Mr Hounsell was a Senior Partner at Ernst & Young (2002-2004), CEO and Managing Partner of Arthur Andersen (2001-2002) and a Partner at Arthur Andersen (1989-2002).
Mr Hounsell has a Bachelor of Business (Accounting) from the Swinburne Institute of Technology (1975) and is a Fellow of Chartered Accountants Australia and New Zealand and a Fellow of the Australian Institute of Company Directors.
Founder, Head of Innovation
Dr Ben Greene developed and deployed laser space tracking capabilities and infrastructure across Australia. He was also the principal designer of the initial remote weapon systems programs for the US Army. Dr Greene is the founder of EOS and the company's Head of Innovation having previously served as the company's Group CEO until August 2022. He is widely published in science and technology, has authored numerous patents, and his work has been recognised by NASA and USAF awards. Dr Greene is a past member of Australia's Prime Ministers Science, Engineering and Innovation Council (PMSEIC), Director of the CRC for Space Environment Management and Deputy Chair of the Western Pacific Laser Tracking Network (WPLTN). Appointed to the Board on 11 April 2002.
David Black
Before retiring from the Deloitte in 2016, Mr Black spent 25 years working in the UK and Australia. During that time he worked with clients, including in the Defence, Manufacturing and Government sectors, on complex accounting, internal and external auditing, risk management, corporate governance and due diligence engagements. Mr Black previously served as the audit partner for the Company for the periods ending from June 2005 to December 2009 and June 2012 to June 2016. He is a Fellow of Chartered Accountants Australia and New Zealand, a Fellow of the Institute of Chartered Accountants in England and Wales, has a BA (Hons) in Economics, an MBA and is a Graduate of the Australian Institute of Company Directors. Mr Black is Chairman of the Audit and Risk Committee and a member of the Nominations and Remuneration Committee. Appointed to the Board on 1 January 2021
Kate Lundy
Having served as Senator in the Federal Parliament for nearly 20 years, Kate Lundy continues to focus her energy on technology and innovation. In 2017, the Australian National University awarded her a Doctor of Letters (honorary doctorate) for her "exceptional contributions to advocacy and policy for information communications and technology, for the ACT and nationally." During her time as Senator for the ACT in the Federal Parliament in both Government and Opposition, Ms Lundy held several front bench and Ministerial portfolios, including IT, Innovation, Digital Economy, Manufacturing, Sport and Multicultural Affairs. She is a member of the Audit and Risk Committee and a member of the Nominations and Remuneration Committee. Elected to the board on 23 March 2018.
Geoff Brown AO
Geoff Brown AO, AM retired from the Royal Australian Air Force in May 2015 as Air Marshall in the position of Chief of Air Force. Among his qualifications he holds a BEng (Mech), a Master of Arts (Strategic Studies), Fellow of the Institute of Engineering Australia and is a Fellow of the Royal Aeronautical Society. He is a Director of Lockheed Martin (Australia) Pty Limited, Chairman of the Sir Richard Williams Foundation and Chairman of the Advisory Board of CAE Asia Pacific. He is Chairman of the Nominations and Remuneration Committee and a member of the Audit and Risk Committee. Appointed to the Board on 21 April 2016.
Deena Shiff
Ms Deena Shiff BSc (Econ), BA (Law) FAICD has had a career in government, the law and as a senior executive. She was the founding CEO of Telstra's corporate venture capital arm, Telstra Ventures, Group Managing Director at Telstra, and was previously a partner in the leading law firm, Mallesons Stephen Jaques. Ms Shiff is currently the Chairman of the Supervisory Board of Marley Spoon AG (ASX:MMM) and is a Non-Executive Director on the board of Appen (ASX:APX), and a Non-Executive Director and Chair of the People and Culture Committees for ProMedicus (ASX:PME) and Opera Australia. She chairs the government's Australian Broadband Advisory Council, the International Advisory Board of the ARC Centre of Excellence for Automated Decisions and Society, and the Advisory Board of the Australian Centre for China in the World.
Robert Kaye SC is a barrister, mediator and professional Non-executive Director. Recognised for his strategic and commercially focused advice, Mr Kaye has acted for various commercial enterprises – both public and private – across media, retail, FMCG, property development, mining and engineering sectors. Drawing on his experience as a senior member of the NSW Bar, including serving on the Professional Conduct Committee and Equal Opportunity Committee, he has a strong emphasis on Board governance and is well versed in Board processes. Mr Kaye has significant cross-border experience, including corporate restructuring and M&A across North America, Europe, Asia, and the Australia and New Zealand region. In addition to his role as Non-executive Director of Electro Optic Systems Holdings Limited, he is Chairman and Non-executive Director of Collins Foods Limited, and a Non-executive Director of Magontec Limited, and FAR Limited. Mr Kaye was formerly Non-executive Chairman of Spicers Limited and Non-executive Director of UGL Limited, HT&E Limited and Blue Sky Alternative Investments Limited and the Chairman of the Macular Disease Foundation Australia.


Life in First Grade: Teachers hear all..or they can with this! HUGE GIVEAWAY!
Teachers hear all..or they can with this! HUGE GIVEAWAY!
It's seriously the neatest thing, y'all. You simply place it wherever you want to recorder and hit the red button. That's it! It records what the kids are saying so you can hear for yourself. To hear what was recorded, just plug it into your computer and click on the file. It has five speakers, so it really picks up the kids voices and allows you to hear exactly what is recorded. And the best part? NO BATTERIES. That's a huge plus in my book.
The kids would come to this area and sit with each other and discuss the decodable reader that we had just read. Each time we learned a new comprehension skill like character, main idea, setting, etc. they would have to discuss that skill. This center was close to my small group area, so I thought it would be easy to keep them on track and make sure they were talking about the book. But usually when the time came for the group to go to story chatter, I had to answer questions from the other groups or check awaiting center work. I never had time to truly listen to what they were saying. So I did away with the center the next year. How perfect will the HearALL recorder work here??? I can't wait to bring back Story Chatter and use the HearALL recorder at it!
I also have been reading Debbie Miller's Reading With Meaning and I love how she takes all the students' responses to certain questions and creates charts with them. This recorder would certainly come in handy to make sure all the responses were recorded accurately. You could even upload the recordings to your class website, blog, or wiki for parents to hear! This is just so much you can do with this neat little product!
Now here's the best part! Learning Resources is giving away one HearALL Assessment Recorder!
*Follow Life In First Grade and share how you would use the HearALL recorder in your classroom. Just comment below and leave email!
I would love to use this in centers in my classroom!
I would use this to monitor the fluency of my students!
I would SOOOO use this to control my little ones from talking when they should be working :o) hee! hee!! I bet it would only take once for me to play it back to "prove" some little ones were chatting during work time!
But, it would be fun for students to read or say a poem and playback. They would love to hear themselves!
I would love to use this for assesment purposes- i can never keep up with my kiddos and this would be a great way to listen in carefully!
I would use this during Daily 5 in the REad to Someone area. I'm not even sure I would tell students at first, so I could see if they were truly on task!
What an awesome tool! There are numerous ways to use this in the classroom. The students could read to it and then listen to it. It could be an extra set of ears to ensure the integrity of center activities, and so on!
I added this to my blog - please, please, please don't judge my blog. I just started one and I am very green at it! My blog address is http://hopscotch.edublogs.org/.
I would use it to check students' reading fluency!
That looks awesome! I would use it during literature circles! It's fun to hear their chatter!
I would use this to help students improve fluency!
I would use it to assess student fluency.
I think it would be great to use this for fluency, especially for a student to lhear him or herself read.
What a useful tool especially in workstations and daily 5. I would use this tool for both of those times throughout the day!! fingers crossed!!!
I cannot tell you how many times I've tried winning this!!!!
I would use it during Daily 5 for word work, listen to read, read to self...the whole lot!
I would definitely use this for assessments and to monitor fluency of my students!
I would love to win this for my classroom.
I currently do a complicated process to make CDs of my kids reading and send them home with books~this would make it so much easier! Thanks for this opportunity.
I would use it to record the students during centers.
I have been wanting this product for a while! I would love to use this with centers!
I have been eyeing this on Learning resources website. I would use it for work work, listen to reading, fluency practice, story telling, and on and on.
I think it would be helpful anywhere in the classroom!
I would use this for fluency checks.
I have a few ideas for center time and fluency. I think the kids would really be able to identify what we need to work on if they could hear themselves. I'd also love to use this during parent-teacher conferences.
This would be a great tool to use during a variety of situations throughout our day. I would love to use it to record students while they read to send to parents so they can hear them read at school.
The Hearall would be great to listen in at workstations to see if children are on task like you mentioned. I also think it would be great to record children and play back so that they can assess their own reading for building fluency. I think I could also use it for kids who are practicing a reader's theatre for presentation. Good readings could be saved for a portfolio or used in our listening center.
I would use it for student fluency. This would be awesome!
I would use it for assessment and to help build fluency.
I would use the HearALL for reading centers and fluency practice. I'd love to use it for parent teacher conferences too, just to give parents a better idea as to what they can work on at home.
I would use hearAll for fluency practice with my first graders!
I would love to use this in my fluency station. It's on the other side of the room and I would love to better monitor that station.
As a pre-k teacher I"m too busy teaching to document all that I am teaching but I must assess my students progress for their report cards. I could record out small group and go back and assess. Also I tell stories each day and could record them for my listening center. I like my listening center to only have an auditory story then my students must listen carefully! Please consider me for this give away.
I have been looking for something I can use to record stories for the kids to listen to. i think this would be perfect!
I would use this recorder to listen to small groups and for fluency practice.
I would use this for students to listen to themselves read to work on fluency. Very cool item!
I would use it for helping students practice fluency, and for listening in to groups during problem solving.
This recorder would be fabulous for fluency and and I am following you! Julie Gornall jg290@bellsouth.net Thank you so much for making this giveaway happen!
I just found your blog!! You have soooo many cute ideas! How have I not found you before?? Anyway...I would definitely use this little baby for fluency practice!
I would use this recorder with my special education students to increase their reading fluency!
Create a French Fry Notebook!


text:
India Law Library (Free)
Latest Cases
Act/Rule Search
Docid Search
India Law Library
State/Central Laws
Administration of Evacuee Property (Rajasthan) Rules, 1953
Published vide Notification Rajasthan Gazette, Part 4-B, dated 4.7.1953
In exercise of the power conferred by sub-section (3) of section 56 of the Administration of Evacuee Property Act, 1950 (XXXI of 1950), the Government of Rajasthan is pleased to make the following rules, namely:-
1. Short title—These rules may be called the Administration of Evacuee Property (Rajasthan) Rules, 1953.
2. Conditions of service of the Custodian and other officer—(1) The Custodian and all officers appointed by or under him shall, subject to any special contract to the contrary, by governed by the Rajasthan Service Rules applicable to the class of officers to which the Custodian or such officers belong.
(2) If any question arise as to which class of officers the Custodian or such officers, the decision of the State Government thereon shall be final.
2A. Special pay to Additional Deputy and Assistant Custodians—The Additional, Deputy and Assistant Custodian in the Evacuee Property Department shall, in addition to the normal emoluments to which they are entitled, be entitled to special pay as follows with effect from the 1st March 1954.
Special Pay
Officer of R.J.S., appointed as Deputy Custodian
Rs. 75/- pm.
Officers drawn for Tehsildar cadre of Naib-Tehsildar (Group 'A') appointed as Assistant Custodian
Rs. 30/- p.m.
3. Furnishing of Security—(1) The State Government or the Custodian may require the officers entrusted with the receipt disbursement or custody of money or property to furnish such security as may be considered adequate.
(2) Officers appointed as cashier or as Field Inspectors shall furnish security of not less than one thousand rupees either in the form of cash deposit or in such other form as the State Government may by general order or special order from time to time direct.
4. Administration charges—(1) As fee equivalent to ten percent of the gross realisations made from evacuee property shall be charged as administration charges from the date on which such property shall have been taken over by the Custodian.
(2) The fee referred to in sub-rule (1) shall be in addition to expenses incurred on maintenance and repairs and to other expenditure which may be incurred directly or indirectly on behalf of the evacuee.
(3) When any movable evacuee property is returned under section 16 or is otherwise realised, administration charges equivalent to 10 percent of the assessed value of the property shall be charged over and above any other charges which may have been actually incurred on maintenance, transport or storage of the same.