text:
import time
from aquests.athreads import socket_map
from aquests.athreads import trigger
from rs4.cbutil import tuple_cb
from aquests.client.asynconnect import AsynSSLConnect, AsynConnect
from aquests.dbapi.dbconnect import DBConnect
import threading
from aquests.protocols.http import request as http_request
from aquests.protocols.http import request_handler as http_request_handler
from aquests.protocols.http2 import request_handler as http2_request_handler
from aquests.protocols.grpc.request import GRPCRequest
from aquests.protocols.http import response as http_response
from aquests.protocols.ws import request_handler as ws_request_handler
from aquests.protocols.ws import request as ws_request
from . import rcache
from skitai import lifetime
from aquests import asyncore
import sys
import inspect
from skitai import exceptions
from skitai import REQFAIL, UNSENT, TIMEOUT, NETERR, NORMAL
from ...corequest import corequest, response
import sqlite3

try:
    import psycopg2
except ImportError:
    class PGIntegrityError (Exception):
        pass
else:
    PGIntegrityError = psycopg2.IntegrityError

DEFAULT_TIMEOUT = 10
WAIT_POLL = False

class OperationError (Exception):
    pass

class Result (response, rcache.Result):
    def __init__ (self, id, status, response, ident = None):
        rcache.Result.__init__ (self, status, ident)
        self.node = id
        self.__response = response

    def __getattr__ (self, attr):
        return getattr (self.__response, attr)

    def reraise (self):
        if self.status_code >= 300:
            try:
                self.__response.expt
            except AttributeError:
                # redircting to HTTPError
                raise exceptions.HTTPError ("%d %s" % (self.status_code, self.reason))
            else:
                self.__response.raise_for_status ()
        return self

    def close (self):
        self.__response = None

    def cache (self, timeout = 60, cache_if = (200,)):
        if not timeout:
            return
        if self.status != NORMAL or self.status_code not in cache_if:
            return
        rcache.Result.cache (self, timeout)
        return self

    def fetch (self, cache = None, cache_if = (200,), one = False):
        self.reraise ()
        self.cache (cache, cache_if)
        if one:
            if len (self.data) == 0:
                raise exceptions.HTTPError ("410 Partial Not Found")
            if len (self.data) != 1:
                raise exceptions.HTTPError ("409 Conflict")
            if isinstance (self.data, dict):
                return self.data.popitem () [1]
            return self.data [0]
        return self.data

    def one (self, cache = None, cache_if = (200,)):
        try:
            return self.fetch (cache, cache_if, True)
        except (PGIntegrityError, sqlite3.IntegrityError):
            # primary or unique index error
            raise exceptions.HTTPError ("409 Conflict")

    def commit (self):
        self.reraise ()

class Results (response, rcache.Result):
    def __init__ (self, results, ident = None):
        self.results = results
        self.status_code = [rs.status_code for rs in results]
        rcache.Result.__init__ (self, [rs.status for rs in self.results], ident)

    def __iter__ (self):
        return self.results.__iter__ ()

    @property
    def data (self):
        return [r.data for r in self.results]

    @property
    def text (self):
        return [r.text for r in self.results]

    def reraise (self):
        [r.reraise () for r in self.results]

    def cache (self, timeout = 60, cache_if = (200,)):
        if [_f for _f in [rs.status != NORMAL or rs.status_code not in cache_if for rs in self.results] if _f]:
            return
        rcache.Result.cache (self, timeout)
        return self

    def fetch (self, cache = None, cache_if = (200,)):
        self.cache (cache, cache_if)
        return [r.fetch () for r in self.results]

    def one (self, cache = None, cache_if = (200,)):
        self.cache (cache, cache_if)
        return [r.one () for r in self.results]

class Dispatcher:
    def __init__ (self, cv, id, ident = None, filterfunc = None, cachefs = None, callback = None):
        self._cv = cv
        self.id = id
        self.ident = ident
        self.filterfunc = filterfunc
        self.cachefs = cachefs
        self.callback = callback
        self.creation_time = time.time ()
        self.status = UNSENT
        self.result = None
        self.handler = None

    def get_id (self):
        return self.id

    def get_status (self):
        with self._cv:
            return self.status

    def request_failed (self):
        self.status = REQFAIL
        tuple_cb (self, self.callback)

    def set_status (self, code, result = None):
        with self._cv:
            self.status = code
            if result:
                self.result = result
        return code

    def get_result (self):
        if not self.result:
            if self.get_status () == REQFAIL:
                self.result = Result (self.id, REQFAIL, http_response.FailedResponse (731, "Request Failed"), self.ident)
            else:
                self.result = Result (self.id, TIMEOUT, http_response.FailedResponse (730, "Timeout"), self.ident)
        return self.result

    def do_filter (self):
        if self.filterfunc:
            self.filterfunc (self.result)

    def handle_cache (self, response):
        self.set_status (NORMAL, Result (self.id, status, response, self.ident))

    def handle_result (self, handler):
        if self.get_status () == TIMEOUT:
            # timeout, ignore
            return

        response = handler.response
        # DON'T do_filter here, it blocks select loop
        if response.code >= 700:
            if response.code == 702:
                status = TIMEOUT
            else:
                status = NETERR
        else:
            status = NORMAL

        result = Result (self.id, status, response, self.ident)

        cakey = response.request.get_cache_key ()
        if self.cachefs and cakey and response.max_age:
            self.cachefs.save (
                cakey,
                response.get_header ("content-type"), response.content,
                response.max_age, 0
            )

        handler.callback = None
        handler.response = None
        self.set_status (status, result)
        tuple_cb (self, self.callback)

class Task (corequest):
    DEFAULT_CACHE_TIMEOUT = 42
    proto_map = dict (
       rpc = http_request.XMLRPCRequest,
       xmlrpc = http_request.XMLRPCRequest,
       jsonrpc = http_request.JSONRPCRequest,
       grpc = GRPCRequest
    )
    def __init__ (self,
        cluster,
        uri,
        params = None,
        reqtype = "get",
        headers = None,
        auth = None,
        meta = None,
        use_cache = False,
        mapreduce = True,
        filter = None,
        callback = None,
        cache = None,
        timeout = 10,
        origin = None,
        cachefs = None,
        logger = None
        ):

        self._uri = uri
        self._params = params
        self._headers = headers
        self._reqtype = reqtype
        self._auth = auth
        self.set_defaults (cluster, meta, use_cache, mapreduce, filter, callback, cache, timeout, origin, logger, cachefs)

        if not self._reqtype.lower ().endswith ("rpc"):
            self._build_request ("", self._params)

    @classmethod
    def add_proto (cls, name, class_):
        cls.proto_map [name] = class_

    def set_defaults (self, cluster, meta, use_cache, mapreduce, filter, callback, cache, timeout, origin, logger, cachefs = None):
        self._cluster = cluster
        self._meta = meta or {}
        self._use_cache = use_cache
        self._mapreduce = mapreduce
        self._filter = filter
        self._callback = callback
        self._cache_timeout = cache
        self._timeout = timeout
        self._origin = origin
        self._cachefs = cachefs
        self._logger = logger
        self._requests = {}
        self._results = []
        self._canceled = False
        self._init_time = time.time ()
        self._cv = None
        self._retry = 0
        self._numnodes = 0
        self._cached_result = None
        self._cached_request_args = None
        self._request = None
        self._ccv = None

        if self._cluster:
            nodes = self._cluster.get_nodes ()
            self._numnodes = len (nodes)
            if self._mapreduce:
                self._nodes = nodes
            else: # anyone of nodes
                self._nodes = [None]

    def __del__ (self):
        self._cv = None
        self._results = []

    def _get_ident (self):
        cluster_name = self._cluster.get_name ()
        if cluster_name == "__socketpool__":
            _id = "%s/%s" % (self._uri, self._reqtype)
        else:
            _id = "%s/%s/%s" % (cluster_name, self._uri, self._reqtype)
        _id += "/%s/%s" % self._cached_request_args
        _id += "%s" % (
            self._mapreduce and "/M" or ""
            )
        return _id

    def _add_header (self, n, v):
        if self._headers is None:
            self._headers = {}
        self._headers [n] = v

    def _handle_request (self, request, rs, asyncon, handler):
        if self._cachefs:
            # IMP: mannual address setting
            request.set_address (asyncon.address)
            cakey = request.get_cache_key ()
            if cakey:
                cachable = self._cachefs.is_cachable (
                    request.get_header ("cache-control"),
                    request.get_header ("cookie") is not None,
                    request.get_header ("authorization") is not None,
                    request.get_header ("pragma")
                )

                if cachable:
                    hit, compressed, max_age, content_type, content = self._cachefs.get (cakey, undecompressible = 0)
                    if hit:
                        header = "HTTP/1.1 200 OK\r\nContent-Type: %s\r\nX-Skitaid-Cache-Lookup: %s" % (
                            content_type, hit == 1 and "MEM_HIT" or "HIT"
                        )
                        response = http_response.Response (request, header)
                        response.collect_incoming_data (content)
                        response.done ()
                        asyncon.set_active (False)
                        rs.handle_cache (response)
                        return 0

        r = handler (asyncon, request, rs.handle_result)
        if asyncon.get_proto () and asyncon.isconnected ():
            asyncon.handler.handle_request (r)
        else:
            r.handle_request ()

        return 1

    def _build_request (self, method, params):
        self._cached_request_args = (method, params) # backup for retry
        if self._use_cache and rcache.the_rcache:
            self._cached_result = rcache.the_rcache.get (self._get_ident (), self._use_cache)
            if self._cached_result is not None:
                self._cached_result.meta = self._meta
                self._callback and tuple_cb (self._cached_result, self._callback)
                return
            else:
                self._use_cache = False

        requests = 0
        while self._avails ():
            if self._cluster.get_name () != "__socketpool__":
                asyncon = self._get_connection (None)
            else:
                asyncon = self._get_connection (self._uri)

            self._auth = self._auth or asyncon.get_auth ()
            _reqtype = self._reqtype.lower ()
            rs = Dispatcher (
                self._cv, asyncon.address,
                ident = not self._mapreduce and self._get_ident () or None,
                filterfunc = self._filter, cachefs = self._cachefs,
                callback = self._collect
            )
            self._requests [rs] = asyncon
            args = (params, self._headers, self._auth, self._logger, self._meta)
            try:
                if _reqtype in ("ws", "wss"):
                    handler = ws_request_handler.RequestHandler
                    request = ws_request.Request (self._uri, *args)
                else:
                    if not self._use_cache:
                        self._add_header ("Cache-Control", "no-cache")
                    handler = http_request_handler.RequestHandler
                    try:
                        class_ = self.proto_map [_reqtype]
                    except KeyError:
                        if _reqtype == "upload":
                            request = http_request.HTTPMultipartRequest (self._uri, _reqtype, *args)
                        else:
                            request = http_request.HTTPRequest (self._uri, _reqtype, *args)
                    else:
                        request = class_ (self._uri, method, *args)
                requests += self._handle_request (request, rs, asyncon, handler)

            except:
                self._logger ("Request Creating Failed", "fail")
                self._logger.trace ()
                rs.request_failed ()
                asyncon.set_active (False)
                continue

        if requests:
            self._request = request # sample for unitest
            trigger.wakeup ()

        if _reqtype [-3:] == "rpc":
            return self

    def _avails (self):
        return len (self._nodes)

    def _get_connection (self, id = None):
        if id is None: id = self._nodes.pop ()
        else: self._nodes = []
        asyncon = self._cluster.get (id)
        self._setup (asyncon)
        return asyncon

    def _setup (self, asyncon):
        asyncon.set_timeout (self._timeout)
        if self._cv is None:
            self._cv = asyncon._cv

    def _cancel (self):
        with self._cv:
            self._canceled = True

    def _count (self):
        with self._cv:
            return len (self._requests)

    #---------------------------------------------------------
    def _fail_log (self, status):
        if self._origin:
            self._logger ("backend status is {}, {} at {} LINE {}: {}".format (
                status, self._origin [3], self._origin [1], self._origin [2], self._origin [4][0].strip ()
            ), "debug")

    def _collect (self, rs, failed = False):
        with self._cv:
            if not failed and self._canceled:
                return
            try:
                asyncon = self._requests.pop (rs)
            except KeyError:
                return

        status = rs.get_status ()
        if status == REQFAIL:
            with self._cv:
                self._results.append (rs)
            self._cluster.report (asyncon, True) # not asyncons' Fault

        elif status == TIMEOUT:
            with self._cv:
                self._results.append (rs)
            self._cluster.report (asyncon, False) # not asyncons' Fault

        elif not self._mapreduce and status == NETERR and self._retry < (self._numnodes - 1):
            self._logger ("cluster response error, switch to another...", "fail")
            self._cluster.report (asyncon, False) # exception occured
            with self._cv:
                self._retry += 1
                self._canceled = False
                self._nodes = [None]
            return self.rerequest ()

        elif status >= NETERR:
            with self._cv:
                self._results.append (rs)
            if status == NETERR:
                self._cluster.report (asyncon, False) # exception occured
            else:
                self._cluster.report (asyncon, True) # well-functioning
                rs.do_filter ()

        with self._cv:
            requests = self._requests
            callback, self._callback = self._callback, None

        if not requests:
            if callback:
                self._do_callback (callback)
            elif not failed:
                cv = self._ccv is not None and self._ccv or self._cv
                with cv:
                    cv.notify_all ()

    def _do_callback (self, callback):
        result = self.dispatch (wait = False)
        tuple_cb (result, callback)

    #-----------------------------------------------------------------
    def rerequest (self):
        self._build_request (*self._cached_request_args)

    def reset_timeout (self, timeout, ccv = None):
        with self._cv:
            self._timeout = timeout
            self._ccv = ccv
            asyncons = list (self._requests.values ())

        if timeout > 0:
            for asyncon in asyncons:
                asyncon.set_timeout (timeout)

    def set_callback (self, callback, reqid = None, timeout = None):
        if reqid is not None:
            self._meta ["__reqid"] = reqid

        if self._cv:
            with self._cv:
                requests = self._requests
                self._callback = callback
        else:
            # already finished or will use cache
            requests = self._requests
            self._callback = callback

        if not requests:
            return self._do_callback (callback)
        timeout and self.reset_timeout (timeout)

    # synchronous methods ----------------------------------------------
    def _wait (self, timeout = None):
        timeout and self.reset_timeout (timeout)
        remain = self._timeout - (time.time () - self._init_time)
        if remain > 0:
            with self._cv:
                if self._requests and not self._canceled:
                    self._cv.wait (remain)

        self._canceled = True
        requests = list (self._requests.items ())
        for rs, asyncon in requests:
            rs.set_status (TIMEOUT)
            asyncon.handle_abort () # abort imme
            self._collect (rs, failed = True)

    def dispatch (self, cache = None, cache_if = (200,), timeout = None, wait = True, reraise = False):
        if self._cached_result is not None:
            return self._cached_result
        wait and self._wait (timeout)
        rss = [rs.get_result () for rs in self._results]
        for rs in rss:
            if rs.status == NORMAL and rs.status_code < 300:
                continue
            self._fail_log (rs.status)
            reraise and rs.reraise ()

        if self._mapreduce:
            self._cached_result = Results (rss, ident = self._get_ident ())
        else:
            self._cached_result = rss [0]
        self.cache (cache, cache_if)
        return self._cached_result

    def dispatch_or_throw (self, cache = None, cache_if = (200,), timeout = None):
        return self.dispatch (cache, cache_if, reraise = True, timeout = timeout)

    def none_or_dispatch (self, cache = None, cache_if = (200,), timeout = None):
        r = self.dispatch (cache, cache_if, reraise = True, timeout = timeout)
        if r.data is not None:
          return r

    def wait (self, timeout = None, reraise = False):
        return self.dispatch (reraise = reraise, timeout = timeout)

    # direct access to data ----------------------------------------------

    def commit (self, timeout = None):
        return self.wait (timeout, True)
    wait_or_throw = commit

    def fetch (self, cache = None, cache_if = (200,), timeout = None):
        res = self._cached_result or self.dispatch (timeout = timeout, reraise = True)
        return res.fetch (cache or self._cache_timeout, cache_if)

    def one (self, cache = None, cache_if = (200,), timeout = None):
        try:
            res = self._cached_result or self.dispatch (timeout = timeout, reraise = True)
        except (PGIntegrityError, sqlite3.IntegrityError):
            raise exceptions.HTTPError ("409 Conflict")
        return res.one (cache or self._cache_timeout, cache_if)

    def then (self, func):
        from ..tasks import Future
        return Future (self, self._timeout, **self._meta).then (func)

    def cache (self, cache = 60, cache_if = (200,)):
        cache = cache or self._cache_timeout
        if not cache:
            return self
        if self._cached_result is None:
            raise ValueError("call dispatch first")
        self._cached_result.cache (cache, cache_if)
        return self
    getwait = getswait = dispatch # lower ver compat.
    getwait_or_throw = getswait_or_throw = dispatch_or_throw # lower ver compat.

# cluster base call ---------------------------------------
class _Method:
    def __init__(self, send, name):
        self.__send = send
        self.__name = name

    def __getattr__(self, name):
        return _Method(self.__send, "%s.%s" % (self.__name, name))

    def __call__(self, *args):
        return self.__send(self.__name, args)

class Proxy:
    def __init__ (self, __class, *args, **kargs):
        self.__class = __class
        self.__args = args
        self.__kargs = kargs

    def __enter__ (self):
        return self

    def __exit__ (self, type, value, tb):
        pass

    def __getattr__ (self, name):
        return _Method (self.__request, name)

    def __request (self, method, params):
        cdc = self.__class (*self.__args, **self.__kargs)
        cdc._build_request (method, params)
        return cdc

class TaskCreator:
    def __init__ (self, cluster, logger, cachesfs):
        self.cluster = cluster
        self.logger = logger
        self.cachesfs = cachesfs

    def __getattr__ (self, name):
        return getattr (self.cluster, name)

    def Server (self, uri, params = None, reqtype="rpc", headers = None, auth = None, meta = None, use_cache = True, mapreduce = False, filter = None, callback = None, cache = None, timeout = DEFAULT_TIMEOUT, caller = None):
        if type (headers) is list:
            h = {}
            for n, v in headers:
                h [n] = v
            headers = h

        if reqtype.endswith ("rpc"):
            return Proxy (Task, self.cluster, uri, params, reqtype, headers, auth, meta, use_cache, mapreduce, filter, callback, cache, timeout, caller, self.cachesfs, self.logger)
        else:
            return Task (self.cluster, uri, params, reqtype, headers, auth, meta, use_cache, mapreduce, filter, callback, cache, timeout, caller, self.cachesfs, self.logger)


Not only do we supply gooseneck and fifth wheel hitches for most vehicles, but we can also install them in our workshop, fitted by trade professionals. Please contact us to arrange a time to have your hitch fitted.
Any trailer over 4.5 tonnes requires towing by a vehicle with air brakes. At Fifth Wheelers Australia we can supply and install air brake kits to your vehicle. Please contact us to arrange a time to have your air brake kit fitted.


text:
Tuesday, Aug 14, 2018 04:12 PM
Training Camp Notebook: Donald Penn returns to practice, works primarily on right side
Eddie Paskal
Senior Writer/Editor
It must have been a trip for Derek Carr when the stepped to the line for the first time Tuesday.
The faces in the huddle were the ones he's grown accustomed to seeing, but when the team headed to the line, while they were indeed all familiar faces, they were in different places, particularly veteran tackle Donald Penn.
Penn, who has started 62 games as a Raider, all at left tackle, since he joined the Silver and Black in 2014, not only returned to practice Tuesday, but did so on the right side, flipping positions for the first time since a cameo appearance in 2016.
"Yeah, that was different," Carr said when asked about Penn playing right tackle. "I think he's only done it a few snaps in that one game, New Orleans. Yeah, so it was a little different, but that's why you have good players. That's why you add good players to your team, so that when things happen you can put guys in different spots, so that helps us."
With Kolton Miller on the left side, and the usual trio of Kelechi Osemele, Rodney Hudson, and Gabe Jackson manning the interior, the veteran tackle spent his first day back from the Physically/Unable to Perform list operating as the team's starting right tackle.
So, how did No. 72 fare on the right side in his first day back?
"I guess I'm like that fine wine, a seasoned vet," Penn joked after practice. "Nah, I'm just joking around. I don't know. One thing I was focused on today was just technique. A lot of times if I get in trouble in the game and stuff, I go back and rely on technique. So, today being in a new side, new position, I was just really trying to focus on my technique because I feel like if my technique is good, everything else, it'll make up for lost things. Not being out there. It was good to be out there. I need to get back in that good shape. I'm in shape, but I'm not in football shape if you understand what that means. Football shape is different."
Penn, who found out early Tuesday morning about the switch to the right side, was quick to say that he would do whatever it took for the team to win, but as of now, he wasn't sure if his foray to the right side was permanent, or just on a trial basis.
"They talked to me about it, about trying it out," Penn explained. "Seeing what it would do. Seeing how I feel over there and I told them I'm willing to do whatever it takes to help this team win. If you guys feel like this is going to be in the best interest of the team, I'll do it. Today it felt very awkward and rusty, but I need time to develop. I don't know if that's going to be a permanent thing or not yet, but it is something we're testing out. I told them I'm all for it."
While we don't know exactly where Penn will be lined up come Week 1 – or even this Saturday in the team's second preseason game – having No. 72 back in the mix is nothing but a net positive for Head Coach Jon Gruden and his staff.
First, Penn is a three-time Pro Bowler, and regardless of where he calls home on the offensive line, the eleven-year vet likely makes any unit he's a part of better.
Secondly, with Penn off the PUP list and back to work, he not only adds more depth to the one of the Raiders' strongest position groups, he also has a chance to continue coaching up the young guys on the offensive line, most importantly Miller and Brandon Parker.
Like we said earlier, Penn's exact job on the Raiders is yet to be finalized – the man is obviously a Pro Bowl left tackle, but playing him on the right side does create some intriguing possibilities for offensive line coach Tom Cable, a coach who No. 72 said is one of the best he's ever had.
"I've been lucky enough to play for some good O-Line coaches in Coach [Mike] Tice, Bill Muir back in my younger days with [Head Coach Jon] Gruden," Penn said. "But you know, Coach Cable he's up there. He's probably one of the top offensive line coaches. The coach's knowledge, the way he coaches his guys. If it's something for me, he's not going to change it. He's just going to be like, 'OK, that's what you do? I'm going to mold your game to that.' Some coaches try to change you. You got to do it this way, this way, this way. He'll find ways to make what you do right. That helps you being a player, especially helps me being a vet because I've been doing some stuff for so long that's different to him."
At the end of the day, whether it's on the left side, right side, or somewhere in between, Penn's return does nothing but solidify the Raiders' offensive line, a line that has the ability to be the best in the league.
And with a franchise quarterback like Derek Carr to protect, a good line is an absolutely necessity for the success of the Silver and Black in 2018.
Injury Report:
With Penn now activated off the PUP list, the only Raider currently with that designation is defensive tackle Eddie Vanderdoes, who as of yet hasn't made his Training Camp 2018 debut.
Wide receiver Seth Roberts was also unable to participate in the day's work, but after missing Monday's session, tight end Pharaoh Brown returned to the field.
Following a collision with cornerback Rashaan Melvin yesterday, Daryl Worley was forced to be a spectator for Tuesday's session as well.
Notable:
-The offensive line spent some time working on recovering fumbles at the start of the day's session. Now, if all goes to plan, they won't need to use this skill much this year, but hey, better safe than sorry.
-Linebacker Nicholas Morrow enjoyed a nice rep during the team's one-on-one periods, easily throwing an offensive player to the ground. Morrow has quietly gone about his business in Napa; I'll be excited to see how he produces over the final three preseason games.
-While we haven't had a chance to see the Derek Carr/Amari Cooper connection in a preseason game just yet, we've seen of plenty of it during practice. Per usual, Carr found No. 89 on the sideline Tuesday morning; I really can't wait to see what those guys have cooking once the regular season arrives.
-Rookie fullback Ryan Yurachek hasn't heard his named called a ton this training camp, but he certainly made his presence felt Tuesday, as he lowered his shoulder, and delivered one heck of a lead block during one of the team's 11-on-11 periods. The hit Yurachek laid was one where you look up, and go, wow, you don't hear that every day.
-After ceding the kicking responsibilities to Mike Nugent for a day, rookie Eddy Piñeiro once again was back in the saddle Tuesday, and No. 9 had a nice day at the office, connecting on 5 of 6 attempts on the skinny uprights.
Quotable:
"Gabe Jackson is probably the most underrated person in the NFL because of the other three. Now you have another first-round pick on the line, too. Poor Gabe is just left in the wind, but not by us. We know how special he is. We know how important he is. I will say this: every time I look at his Madden rating I get mad, though. It doesn't do him justice." – Derek Carr talking about guard Gabe Jackson.
FYI, I agree with D.C. 100 percent on this one; Big Gabe is so underrated it borders on criminal.
The Lighter Side:
Camp can be a grind, I don't think you'll find anyone who would disagree with that, so it was good to see some of the Raiders offensive linemen dancing to E-40's classic anthem, "Tell Me When To Go" Tuesday morning… The big fellas can bust a move, no doubt about that.
I can't believe it, but the Raiders only have two practices left at their Napa Valley Training Complex.
The team will return to the field tomorrow afternoon, then put a bow on training camp Thursday morning.
Antonio Brown and Tyrell Williams crack NFL.com's top duos list
Former Raider and NFL wide receiver James Jones released his top five wide receiver duos on NFL.com; take a look.
2019 Position Battle: Linebackers
The Oakland Raiders have searched for years now to find a core trio of linebackers they can hang their hat on, and in 2019 they may have found it.
Upon Further Review: Discussing Madden ratings, and defensive expectations in 2019
Just a week out from the start of Oakland Raiders 2019 Training Camp, the "Upon Further Review" crew discuss the defensive unit and rattle off a series of questions.

redpajama_set_name: RedPajamaCommonCrawl


text:
Rafael Benitez set to leave Newcastle
Newcastle manager Rafael Benitez is to leave the club when his contract expires at the end of the month. The Spaniard guided the Magpies to an instant return to the Premier League after relegation in 2016.
Fleetwood Town manager Joey Barton has been charged with actual bodily harm following an alleged incident during a match at Barnsley in April. Barton has "emphatically denied" accusations that he confronted Barnsley manager Daniel Stendel in the ...
Jennifer Lopez pole dances in new Hustlers trailer
Courtesy of STX Entertainment Trailer for the new movie 'Hustlers' has been released. The film stars Jennifer Lopez, Constance Wu, Julia Stiles, Keke Palmer, Lili Reinhart, Lizzo and Cardi B. Hustlers follows a crew of savvy former strip club empl...
US House votes to condemn Trump's tweets against congresswomen
Members of Congress in the House of Representatives have voted to condemn controversial tweets published by President Donald Trump. There was widespread condemnation when the US President told four congresswomen of colour to "go back" to their ho...


Provides cash advances against future credit card sales for small and midsize businesses with bad credit. Customers can increase the amount of the advance with each renewal to build up a healthy transaction history and eventually be eligible for more traditional business loans. Businesses typically use the advances to fund expansion, purchase equipment and inventory, increase advertising, manage unexpected expenses, and take advantage of seasonal opportunities.


The Magic Wall System™ is a basement wall system which was developed by engineers to ensure that the materials used were going to last when installed in below-grade conditions found in basements. Magic Wall can be painted, insulates your home, can hold up to 600lbs (flat screen TVs, bookcase, etc.) and cuts installation time to less than half of the traditional remodeling methods. For more details on The Basement Doctor's wall system of choice click here.
Now you can transform your unfinished basement into a healthy, comfortable living area in seven to ten days! Our solid surface state-of-the-art system offers more features for less money making. Count on us for the best basement finishing services in Columbus and central Ohio.
Basement finishing from The Basement Doctor economically adds livable space!
Walls can be painted, wallpapered, or pre-finished, providing you with more decorating options.
Dependable construction allows mounting of large pictures, shelves or a HDTV.
Entire system installs quickly and easily without dust and debris throughout the house.
Magic Wall withstands daily use without rips, tears, puckering or other surface damage.
Acoustic panels prevent noise from traveling to other areas of your home.
Once the walls are installed, it's time to dress them up with paint, trim and molding. Your Basement Doctor expert will provide all of these options during your estimate.


text:
Sigma bakeries evolved through various different stages. It began from our great-grandfather, an artisan of bread making who mastered and passed the technique to our grandfather, his son, George. George started his first bakery in Limassol in 1922; he then moved to Famagusta in the late 50's. He then passed his know-how, enthusiasm and love for artisan bread to his son Savvas who became a master baker. Savvas and his wife Andriana, both worked hard and managed to advance and prosper with one old bakery shop at Leondiou street, old hospital road in Limassol.
In the late 70s the children of the family, entered the business bringing a fresh level of approach. A new philosophy, vision and culture was established under the name of SIGMA. The brand name Sigma was derived from the initials of all the family members' names.
Being together, united as a family, with almost no capital to invest, Sigma family members had a difficult task ahead; to create a leading trusted brand! Creating a leading organisational group of professionals, who want to move forward through hard work, vision and trust, the Company has evolved to become a leading chain of bakeries and among the very best performing companies in the food sector in Cyprus today.


text:
Grob Tea Co Chart Analysis Peers Quarters Profit & Loss Balance Sheet Cash Flow Ratios Investors Documents
The Grob Tea Co Ltd
₹ 838 3.36%
Company website NSE : GROBTEA
Incorporated in 1895, TGTCL produces black tea of crush, tear and curl (CTC) variety, which it sells in the domestic market through a mix of auction and private sales. The company was taken over by the current management – the Rawalwasia Group in May 2009.
The company has six tea gardens located in upper Assam and Cachar district. The gardens are spread over 5,676 hectares, of which around 46% is under tea cultivation. These gardens have the capacity to produce around 47 Lacs kg of premium Assam tea. Three of the company's gardens are now Trustea certified by the Government/ Tea Board.
In FY2019, the company ventured into supply, installation and maintenance of LED lights to various Government entities/ departments.
Website NSE
High / Low ₹ 1,235 / 710
Stock P/E 11.7
Book Value ₹ 838
ROCE 6.78 %
ROE 5.37 %
Stock is trading at 1.00 times its book value
Company has delivered good profit growth of 20.1% CAGR over last 5 years
The company has delivered a poor sales growth of 4.57% over past five years.
Earnings include an other income of Rs.3.11 Cr.
Sector: Plantation & Plantation Products Industry: Tea
Figures in Rs. Crores
30 24 12 14 51 28 16 11 37 36 9 18 44
Operating Profit 14 2 -13 4 33 6 -14 1 15 3 -13 3 16
OPM % 47% 9% -106% 29% 65% 23% -85% 6% 39% 10% -145% 17% 36%
Interest 0 0 0 0 0 0 0 0 0 0 0 0 0
Depreciation 1 1 1 1 1 1 1 1 1 1 1 1 1
Profit before tax 13 2 -14 3 33 6 -14 1 14 3 -13 3 16
Tax % 0% 0% -8% 0% 0% 0% 0% 0% 0% 0% -7% 0% 0%
Net Profit 13 2 -15 3 33 6 -14 1 14 3 -14 3 16
EPS in Rs 110.99 14.28 -130.69 29.77 281.25 52.48 -122.34 4.39 122.17 27.88 -118.73 24.18 138.35
51 50 59 60 61 77 74 77 80 82 110 93 107
Operating Profit 10 8 7 6 4 10 6 5 4 6 30 6 9
OPM % 19% 16% 13% 10% 7% 14% 8% 7% 5% 7% 27% 7% 9%
Profit before tax 9 7 10 5 1 6 2 3 2 3 28 5 9
Tax % 14% 24% 12% 16% 34% 24% 10% 29% 23% 42% -0% 17%
Net Profit 8 5 8 4 1 5 2 2 1 2 28 4 8
EPS in Rs 64.96 45.94 73.13 32.87 8.26 40.35 14.54 15.92 12.05 14.20 241.07 35.71 71.68
Dividend Payout % 2% 3% 3% 6% 24% 5% 14% 13% 17% 14% 1% 6%
10 Years: 6%
5 Years: 5%
10 Years: -3%
Last Year: 5%
Reserves 10 15 24 27 30 36 38 40 43 46 74 77 96
4 4 7 2 14 8 3 4 6 10 3 3 10
9 8 9 9 11 13 13 15 19 15 14 17 16
Total Liabilities 24 28 41 40 57 58 55 61 69 72 93 99 124
CWIP 1 2 0 0 0 0 2 3 3 4 5 6 6
Investments 0 0 0 0 0 2 1 7 7 2 2 5 5
Total Assets 24 28 41 40 57 58 55 61 69 72 93 99 124
9 6 11 6 5 6 5 9 -2 -7 25 12
-3 -5 -15 -0 -12 -2 1 -10 1 5 -17 -11
-5 -1 3 -6 11 -8 -6 1 1 2 -8 -1
Net Cash Flow -0 -0 -1 -0 4 -3 -0 -0 1 -0 -0 0
Debtor Days 5 5 6 2 4 4 3 7 21 13 9 7
Inventory Days
Cash Conversion Cycle 5 5 6 2 4 4 3 7 21 13 9 7
Working Capital Days -25 -20 -10 -11 -8 0 1 -5 24 75 75 84
ROCE % 69% 43% 24% 17% 6% 15% 6% 7% 5% 8% 42% 7%
Shareholding pattern is currently not available for this company.
Loss of Share Certificates Jan. 10, 2023
Certificate under SEBI (Depositories and Participants) Regulations, 2018 Jan. 7, 2023
Trading Window Dec. 28, 2022
Related Party Transaction Nov. 22, 2022
Loss of share certificate Nov. 16, 2022
from nse
Rating update
28 Apr 2022 from icra
4 Feb 2021 from icra
26 Feb 2020 from icra
7 Mar 2019 from icra
16 Jan 2017 from icra


text:
Extra Stuff
Last Updated: Wednesday November 12 2008 11:49 GMT
Crash survivors talk to Maddy
Cannot play media. Sorry, this media is not available in your territory.
Jackson tells Maddy what happened on the day of the crash
Five months ago, Arron Peak, 10, and his 8-year-old brother Ben were killed in a motorway crash involving footballer Luke McCormick.
Newsround's Maddy was the first reporter to speak to Ben's best friend Jackson, 8, who was also in the car and survived the accident.
Now, he's campaigning to get drivers to think more about road safety.
"Jackson was sprawled on the sofa giggling when we arrived at his house just outside Manchester.
Maddy couldn't keep up with Jackson on the computer games
He was excited to have the afternoon off school and to be chatting to Newsround.
And he was desperate to show me his skills playing computer games! He was definitely much better than me!
But as soon as he got talking about his best friend Ben and the accident they were both in, his smiles disappeared.
He started fidgeting with his sweatshirt and staring down at the carpet. Sometimes you could see tears welling up in his eyes.
"Me and Ben used to do everything together," he told me. "We'd stay over at each other's houses, listen to cds, do drawing."
'Devastated'
Along with their two dads and their brothers they were on their way to a dream day out at the Silverstone race track in June when they were involved in a motorway crash.
Jackson was best friends with Arron and Ben
Their car was hit by 25-year-old footballer Luke McCormick who had been driving drunk, and too fast on his way home from a wedding.
Jackson wasn't hurt. But Ben and his brother Arron were killed, and their dad Phil hurt his back so badly he still has to use a wheelchair.
Jackson said he was devastated when he found out his friends hadn't survived: "There were tears streaming down my face when they told me... I was heartbroken."
He says he still thinks about Ben every single day. They used to be best friends, neighbours and even sat on the same table at school.
Even though he loves driving as fast as he can in computer games, he reckons anyone who speeds on roads in real life is "just an idiot... They shouldn't do it".
Luke McCormick was ordered to spend up to seven years in prison. But Jackson reckons that's not long enough.
Drive safely
We also spoke to Jackson's sister Sophie, who's 11. She was supposed to be having a girly trip out with her mum, sister and Arron and Ben's mum, on the day all the boys left for Silverstone.
Sophie was good friends with Arron
Instead, she woke up to the news they had been in an accident. Later, her mum told her Arron and Ben had died.
"I just screamed and screamed... Now I miss them so much," she said.
Sophie was really good friends with Arron. He'd promised to look after her when they both started high school in September, but Sophie ended up having to go there without him.
I thought it was really brave of Sophie and Jackson to speak to us. It can be difficult or upsetting to talk about people dying.
But they both wanted to explain how sad Ben and Arron's deaths have made them feel, to try to make sure adults drive more safely in future, and something like this never happens again."
Do you stay safe?
Quiz: Safe cycling
Facts and tips
Why you should be careful
Hints for keeping safe
Do shock ads affect you?
My brother died on the road
Do you worry about your safety in cars?
Campaign to stop kids' road fears
Player jailed over boys' deaths
BBC Homepage >> | CBBC Homepage >>
Meet the Team | Help | Contact Us | News sources | Privacy & Cookies Policy


Get an introduction to Unity and C#, program inputs to control your sprites and their movements.
Learn how 2D and 3D animations works in Unity and create your own.
Learn about user interfaces (i.e. Unity Canvas, buttons, images, etc) and their importance in game design.
Use Unity3D to create a 3D environment/game that we will bring into Oculus VR.