text:
Domaine des Lambrays, 2019 Release
"As we have discussed at length already, the best wines of this vintage have a balance of rare concentration and vitality. And the Clos itself is an orchestral masterpiece, conducted by a true maestro."
Home / En Primeur / Domaine des Lambrays, 2019 Release
In the spring of 2014, Burgundy was buzzing with rumours of an audacious purchase of Domaine des Lambrays and its historic eight-and-a-half-hectare Grand Cru, Clos des Lambrays. The jungle drums proved to be spot on, and it was soon announced that Bernard Arnault's LVMH group were the proud new owners of not just one of Morey-St-Denis' great vineyards, but one of the real treasures of the entire Côte de Nuits.
LVMH took their time to find the right man to reinvigorate the estate. Incumbent regisseur, the charming and lovely Thierry Brouin, had done a grand job since taking on the role back in 1980 but was ready for retirement. Then, in 2019, LVMH found their Pep Guardiola, the hugely talented and quietly ambitious, Jacques Devauges. With license to do whatever was needed, Jacques was the man chosen to take the estate to the heights history had proven it had the potential to reach.
Working organically (now biodynamically since the 2020 vintage), Jacques immediately sought a more parcellaire, deconstructed approach to the main wine, the virtual monopole of the Clos. Having tasted some startingly beautiful vintages from the first quarter of the 20th century, Jacques was convinced that the secret to making a great Clos des Lambrays was bringing together all the nuance and individual character from the distinctive lieu-dits within the Clos; mini plots that varied in height, exposition, soil make up, drainage, temperature and vine age. Here was the ultimate example of the whole being greater than the sum of the parts. Referencing its halcyon days, Jacques divided up the Clos into 12 different plots, all of which he vinified separately, allowing him to see the subtle variations that these plots could produce. And then, like an artisanal mechanic rebuilding a perfectly tuned engine, he pieced back together each crucial element to create a blend that would purr enticingly in the glass.
Jacques is not only a talented, creative visionary, but he was clearly also born under a lucky star. Only in his wildest dreams could he have imagined that he would be blessed with an inaugural vintage of such beautiful quality. Whilst frustratingly small in size, 2019 is a classic in the making. As we have discussed at length already, the best wines of this vintage have a balance of rare concentration and vitality. These are Pinots of depth, complexity, intensity and purity. And, quite simply, Jacques' contributions to this irresistible vintage are truly wonderful. And the Clos itself is an orchestral masterpiece, conducted by a true maestro.
We are both honoured and thrilled in equal measure to have been appointed the Domaine's Key Partner here in the UK. Obviously, allocating these wines is going to be a huge challenge, such is the likely demand in the face of such small volumes, but what an exciting challenge it will be, and we hope that we can find you the bottles you are after. This is very much the beginning of an enthralling new chapter at the domaine. We were one of the lucky few who found a big enough window in the 2020 lockdowns in both the UK and France to get to the domaine to assess the wines. We were genuinely blown away by what we tasted. Those critics who were also able to taste, seem to have had similar experiences. Praise has been heaped upon these 2019s and, at the risk of flirting with a little pretension, this feels very much like the start of a journey all Burgundy lovers will want to be on.
Place your order here
The cooler weather following an earlier than usual bud break at the beginning of April, resulted in a difficult flowering in June and really set the blueprint for the size of the harvest that would follow three months later. The beautiful weather into July was gorgeous for the tourists but stifled the maturation process slightly and kept the berries on the small side throughout their time on the vine. Rainfall in early August was welcome but very localised. Luckily, Morey enjoyed a decent watering, preventing any hydric stress, but thereafter warm weather and warming breezes dehydrated the grapes to the extent that their juice content became very limited. When the harvest began in Morey on 13th September this proved to be great for quality but somewhat challenging for volume! The Clos itself recorded just 15 hectolitres per hectare; less than half of what it had done the previous year. Even the 1er Cru and village plots fared little better, just scraping into the twenties.
In terms of vinification, Jacques was able to be very delicate, with colours and beautiful tannins coming easily, with little extra encouragement needed. He kept 80% of the stems in the Clos, adding freshness and structure, and of the few barrels he was able to fill (!) 60% were new. Elevage was extended to about 19 months (Thierry often used to bottle just before the harvest) allowing the various components of the wine to marry and integrate in the most complete fashion. The results are spectacular.
2019 Puligny-Montrachet 1er Cru Les Folatières
£630 IB · 6x75cl
This was one of two excellent Puligny 1er Cru parcels acquired back in 1993 from Domaine Charton. Folatières lies almost on the same plane as Chevalier and Montrachet in the central part of the appellation but stretches higher up the slope. Both vineyards were picked on 7th September, which was quite early for the vintage, resulting in both pH and alcohol readings remaining at sensible levels. This shows very well, with some appealing underlying reductive elements jostling for position with stony, salty flavours that are energized by a good level of dry extract. Intense, yet well marshalled. 20% new oak. Drink from 2022
2019 Puligny-Montrachet 1er Cru Clos du Caillerets
An undeniable step up, as one would expect from this virtual extension of Montrachet itself. Aromatically it is more intense and its evident concentration in the mouth is veiled somewhat by the delicious, chalky austerity that runs through its core. Stony and vibrant, with a lovely flow throughout and an impressive sense of classicism. As was the case for the Folatières, yields were, sadly, down around 40%. 20% new oak. Drink from 2023
2019 Morey-St Denis
This is a seriously good village wine. Jacques did not keep any stems on this cuvée and didn't do any pigeage at all, allowing the extraction to happen unforced. And as was so often the case in 2019, the wine gave up its heart with little sufferance. The malo finished quite quickly and was done by Christmas and the wine saw 20% new oak. It is such a well-proportioned wine, showing gorgeously intense fragrance on the nose and in the mouth. Mineral and energetic throughout with real harmony and balance. Quite delightful. Drink from 2025
2019 Morey-St-Denis 1er Cru Les Loups
This is a definitive Morey, bursting with spice, fragrance and seduction. It is a blend of the 1ers Crus of La Riotte and the confusingly-named Le Village with the addition of the young vines (around 20 years old) of Le Clos. It's impossible not to be taken in by its flirtatious character, enhanced by the use of 50% whole bunch. The fruits are quite dark, yet the flavours are lovely with hints of lifted blueberries ripened to perfection. The whole bunch adds a crack of peppery freshness that allows the perfumed florality to stretch its legs. Much to enjoy here. Drink from 2026
2019 Clos des Lambrays Grand Cru
It seems remarkable, given its geographically positioning sandwiched between the Morey Grands Crus of Clos de Tart, Clos St Denis and Clos de la Roche, that the Clos was only officially upgraded to a Grand Cru itself in 1981. Previously, it had had its heyday back in the 1920s and 30s when it produced a number of highly regarded vintages. But then, it subsequently suffered neglect under new ownership during and in the years following the Second World War. The turn around began in 1979 when the estate was sold, and Thierry Brouin was appointed regisseur. And now, here we are with the release of the 2019, potentially the finest post war vintage made at the domaine. We tasted through a number of different lieu-dits that Jacques had kept separate during the vinification and élevage processes, before tasting the final blend. Each component seems to have brought something unique and very special to the finished wine. Jacques kept around 80% of whole bunches and used a mix of 60% new oak and 40% one year old oak. It's a wine of great composure and refinement, the quality of tannins being particularly impressive; understated, silky and supportive. Notes from the individual plots were varied and exciting. 'Amazing florality', 'exotic spice', 'great purity', 'cool, ice cream fruit', 'controlled', 'structured', 'great depth', 'small berry intensity, 'power'. All these elements are in this wine so it's little wonder that it thrills the palate from start to finish. A very complete wine indeed. Bravo Jacques. Drink from 2029
'There is a serene weight to this with waves of detail… I am not going to say that Jacques has gone straightaway back to the great vintages of the 20s and 30s, but there is very considerable promise here.'
Jasper Morris, 93-97 pts
'This has an intense bouquet, initially very tightly wound and requiring aeration, gradually revealing predominantly black fruit, crushed limestone, graphite and pressed iris flower aromas. Very fine delineation but certainly aromatics that will require bottle age. The palate confirms this. It is very fresh on the entry with a subtle influence of the stems. This balletic, "Margot Fonteyne of Morey-Saint-Denis", will pirouette across your senses.'
Neal Martin, 95-97 pts
'This is very promising indeed, mingling scents of blood orange, wild berries and plums with notions of exotic spices, wilted rose petals, raw cocoa and loamy soil. Full bodied, velvety and layered, it's deep and multidimensional, with a concentrated, elegantly fleshy core, lively acids, largely concealed tannins and a precise perfumed finish.'
William Kelley, 94-96 pts


text:
Q: Automatically resize text widget's height to fit all text How can one automatically resize a text widget to fit a text widget's height

*

*There will not be any \n om the text widget, instead the text will wrap (whole word) around and continue down. wrap=WORD
How can this done?
My idea of approaching the problem statement: I was wondering if it was possible to count every time the text was wrapped around in the text widget, and by that given value somehow calculate the height of the text widget? - Just a thought .. I have no clue whether it's possible.
**WHY THIS IS NOT A DUPLICATE **
This is not a duplicate, link to the question you claim it is a duplicate of if you think so. They all have implemented a solution in which it check a '\n' in each keystroke in the text widget. My text widget won't have any '\n' in it at all. But instead wrap the words around !
This is NOT the solution I am looking for, since it is looking for '\n' and changes the height accordingly to how many of them it finds. Since I won't be using any '\n' but instead wrap the words around (Text(frame, wrap=WORDS)) no '\n' will not appeare making that solution USELESS!"
That is why this code, from the question people claim this is a duplicate of, WONT fix this question, this is NOT a duplicate.
wont fix my problem since it looks for '\n':
    import Tkinter

class TkExample(Tkinter.Frame):
   def __init__(self, parent):
      Tkinter.Frame.__init__(self, parent)
      self.init_ui()

   def init_ui(self):
      self.pack()
      text_box = Tkinter.Text(self)
      text_box.pack()
      text_box.bind("<Key>", self.update_size)

   def update_size(self, event):
      widget_width = 0
      widget_height = float(event.widget.index(Tkinter.END))
      for line in event.widget.get("1.0", Tkinter.END).split("\n"):
         if len(line) > widget_width:
            widget_width = len(line)+1
      event.widget.config(width=widget_width, height=widget_height)

if __name__ == '__main__':
    root = Tkinter.Tk()
    TkExample(root)
    root.mainloop()

edit example
This is the reason why I am not using message widgets, they doesn't rearrange the text to fill out the text widget.

A: The tkinter text widget isn't designed to grow or shrink to fit its contents like a label widget. If all you need is to display plain text with no need to interactively edit more text, a Label is probably a better choice than Text.
That being said, it's possible to get the number of displayed lines in a text widget, and with that information you can resize the widget.
Here's an example that shows how to cause it to resize when you insert text programatically. It won't handle resizing as you type, though it can be made to do it.
The trick is to know that internally the text widget has a count method which you can call to get the number of displayed lines. Unfortunately, this method isn't exposed at the tkinter layer and thus requires a bit of knowledge of how tkinter works internally.
class ExpandoText(tk.Text):
    def insert(self, *args, **kwargs):
        result = tk.Text.insert(self, *args, **kwargs)
        self.reset_height()
        return result

    def reset_height(self):
        height = self.tk.call((self._w, "count", "-update", "-displaylines", "1.0", "end"))
        self.configure(height=height)

Here is an example of how to use it:
root = tk.Tk()
text = ExpandoText(root, width=20, wrap="word")
text.pack(fill="both", expand=True)

root.update_idletasks()
text.insert("1.0", "This is a line of text that will initially be wrapped.")

root.after(5000, text.insert, "end", "This is more text")

root.mainloop()

When you run the code, you should see a window that looks like this:

If you don't manually resize the window, and wait 5 seconds, the window will grow to show the added text:

Unfortunately you must call update_idletasks before the insertion so that tkinter knows how wide the window will actually be. This might have visual side effects depending on how the rest of your code works (read: you might see a flash when the UI first starts up).

redpajama_set_name: RedPajamaStackExchange


Guyside: Who says prevention is worse than the cure?!
My partner in crime, Bob LeDrew is off paving his own preventive highway. He'll be back next week with another edition of Guyside. Meanwhile?
Just a thought to ponder on a Wednesday….
Did you catch last Friday's post about reaching deep to find the strength to ask for help? Cyma Shapiro, author of The Zen of Midlife Mothering, did and sent me a wonderful post about her own surgical experience in solidarity. Here it is, in its entirety; I hope that it inspires you as much as it did me.
I've been very lucky. In my lifetime, I've enjoyed good health, good friends and not a lot of unforeseen external circumstances. However, this recently changed when I needed surgery.
It's difficult to explain the (many) steps I took leading up to this decision, but as insignificant as it might have been, how monumental it all felt. And, while there are far more people struggling with far more serious illnesses, my recent foot surgery was so pivotal in my life that I'd like to share my short journey with you.
As an avid and passionate proponent of Eastern modalities, I've spent an entire lifetime focusing on healthy eating, healthy living and healthy practices. I believed that in doing all of this, I'd be spared more serious complications. So, when I broke my foot last year, I felt as if my world had shattered. I was literally stopped dead in my tracks – a difficult journey for someone as active as I am (rock climb, bike, hike, etc.). I had no choice but to heed the call. And, I needed to do just what the doctor ordered: stop.
So, for six months, I tried to smell the roses: I reflected on the state of my life and of my "mid-age." I thought long and hard about the things that I did and didn't accomplish, and of the….well….mortality of it all. Most importantly, I realized that my apparently well-ordered life was certainly not that – that many more things (than I'd ever considered or thought possible) were simply out of my control.
To me, having surgery felt like death – not only for the potential perils and outcome, but for what the circumstances suggested – that I simply was no longer as immortal as I believed.
And so, in counting down the months, then weeks, and then days before the surgery, I fervently kept up every practice I knew – praying, breathing, exercising, meditating, reading, etc. And, as the weeks became days, I nearly lay myself prostrate in asking for help, guidance and support during this period. I also did one more thing: I asked my closest friends to pray for me and send light and love.
Nearly immediately, I felt an energy shift in my body. And, as much as the panic threatened to overtake me, the internal support I felt helped propel me forward.
Today, I am healing. I am also doing fine. However, I have also changed – in my feelings about Western medicine, about how a higher power is truly in charge, in learning how tough and resilient I really am (despite my overwhelming fears otherwise), and how the power of others can support you in your life.
While I realize that some of you may scoff at this, believing this to be a minor blip in the journey of life, I believe that the success I've experienced here will translate into greater successes, should more serious things arise in my life. And, for this deeper understanding and in climbing another rung of life's many twists and turns, I am so very grateful.
Cyma Shapiro, 56, is the writer/creator of NURTURE: Stories of New Midlife Mothers (www.MidlifeMothers.org), the first art gallery show dedicated to women choosing motherhood over 40 (now traveling North America), and the subsequent blogsite, www.MotheringintheMiddle.com, for all-things midlife mothers. A speaker and writer for several sites including Huffington Post, whose work has been featured on NPR and on Psychology Today (online), Cyma is passionate about supporting women who choose later motherhood, and giving them a face, voice, and forum. She is the mother of 9 and 11-year-old children and 28 and 30-year-old stepchildren. She recently published The Zen of Midlife Mothering (essays from MotheringintheMiddle.com) – the only anthology on the market by and for midlife mothers (and fathers).
If you are as independent as I am, asking for help might be alien to you. Personally, I am getting better at it. But I still have the inclination to try to do something first on my own rather than rely on someone else to do for me, even if it may be detrimental.
I am having surgery today. I've been in significant discomfort for weeks now and that discomfort has been increasing daily. And I was going to drive myself to the procedure until my friends stepped in and took over. Don't you think that I would realize how silly that idea was?
When was the last time you asked for help? Better yet, how easily do you ask for and receive help?
Reading Karen Rosenthal Hilsberg's "Lessons in Living" and her struggle to make sense of a life unraveled as her husband dies, I can't help but reflect on a close friend who was ill several years ago. Despite a 'take no prisoners' attitude, he had trouble acknowledging the seriousness of his condition and even more trouble asking for support. Quite honestly, he doesn't do too well in that department and neither do I. However, like him, I readily offer assistance to those I love and care about, whenever I can.
So, why the divide between offering and taking?
As caretakers, many women often do not adapt well to being on the "receiving end." And yet, most of us are aware of the importance of social ties, friendships and support to our health and wellbeing, particularly as we age. So why do we find it so difficult to ask for and receive help? How do we acknowledge that be cared for does not equate to losing power or control but actually improves outlook, wellbeing, and ability to deal with any challenges that we might be facing, that allowing others to "do" empowers and does not 'de-power?' Is it fear of refusal? Or fear of letting go?
Mastering the art of asking for help is difficult. However, it behooves us to do so, not only for our wellbeing but for the wellbeing of those around us who wish to help.
My friend deserved the kind of care that he has provided to others in his life for most of his life.
Balance. I have it. Sometimes.
In my 20s, I used to work as studio director for a radio morning show. Often, I'd stay up, watch Late Night with David Letterman, and then hit the sack, only to get up and hit the road to be at the station at 5, bright-eyed and bushy-tailed with coffee for the gang. A little later on, I worked at a 24-hour news network, and my shifts were almost always 3 a.m.-11 a.m. or 4 a.m.-noon. I'd come home, do some other work, my partner would come home, and I'd almost always be in bed after 10 p.m. Five hours sleep was fine. In an magazine job, all-nighters were common as we got to production.
If I tried that now, I would implode in a week. And that isn't always the easiest thing for a man to admit. We're supposed to be invulnerable, aren't we? One of the things I've noticed as the years have gone on is I can still be as intense as I was in the past (I think!), but that I can't maintain that level of intensity for same length of time. I attend a music-industry conference each year where part of the deal is attending music sessions that go on until about four in the morning. I can do that, but inevitably there's a post-conference crash.
Combine the fact that my "energy well" isn't as deep as it used to be with the lifestyle of a self-employed consultant, where the pace can sometimes oscillate between frenetic and … what now? and you have a recipe for stress.
I have a few things I try to do to combat that stress. I try to keep my sleep habits as regular as I can. I'm lucky in that I rarely have insomnia, so it's easy for me to stay rested most of the time. That keeps the energy supply high.
If there's a frenetic period on the horizon, I will try to book downtime to recharge my batteries after the urgency subsides. Better to book it and keep it for myself than to carry on as if I didn't just complete a herculean task and end up crashing.
And I try to keep my regular appointments sacred. Yoga class, exercise, and the like can sometimes feel like a distraction that I "should" skip "just this once." But that has an impact down the road. Short-term gain for long-term pain.
It's not easy to stay energized all the time. But if you can learn — even attempt — to manage yourself a little better, you can perform at a higher level all the time, rather than some roller-coaster cycle of sprinting, and then collapsing.
What are your tips for managing energy levels? Tell me in the comments.


The wait is over. But does it deliver?
After a two-year wait and huge amounts of speculation, one of the most anticipated series returns. As much as many a viewer and fan enjoys the intricacy and humour of the series, the thing everyone wants the answer to is how Sherlock survived the fall. You'll be glad to know it's in no way swiftly swept under the carpet and is dealt thoroughly throughout the episode. How did he do it you ask? Well… I couldn't possibly tell you now could I! But Steven Moffat and Mark Gatiss have cleverly exploited the many theories that abound leading to many a comical moment and nods to the theorists.
So what has Sherlock been doing and why does he return? Picking up the threads from the series two finale, Sherlock has been spending his time trekking round the globe dismantling Jim Moriarty's criminal network. However, Sherlock is now needed back in London to foil and discover who's behind a recent threat of a huge terrorist attack on the city. There's just the minor issue of breaking the news to those who were closest to him that he is in fact very alive.
Sherlock may be a genius, but he's a socially inept one. Deciding the best way to spring the surprise on his old friend John Watson (Martin Freeman) in the style of a theatrical caper and in a public place at a very inopportune moment, from John's point of view adds insult to his already feeling of unjust. In his sociopathic mind Sherlock fails to see the implications of his actions of the past two years and how John will react.
So where does everyone else fit, Sherlock thinks Mycroft (Mark Gatiss) is in denial about his loneliness but never his intelligence. Both John and Molly (Louise Brealey) have got engaged and moved on – although Molly sticks to "type" with much hilarity; John is now engaged to Mary played by his real-life partner Amanda Abbington, who fans will be pleased to know bridges the gap between the two friends; Mrs Hudson (Una Stubbs), bless her, is still at 221b Baker Street and welcomes the return of Sherlock (as do we all), John is not quite so lucky.
The Empty Hearse is a fast-paced puzzle, however, some may be dissapointed at the lack of intricacy they're probably used to. Although the final scenes do hint that the story is perhaps more layered than first thought though.


text:
//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
//  distribute this software is granted provided this copyright notice appears
//  in all copies. This software is provided "as is" without express or implied
//  warranty, and with no claim as to its suitability for any purpose.
//
//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
//  producing this work.

#define BOOST_PYTHON_SOURCE

#include <boost/python/detail/call_object.hpp>
#include <boost/python/detail/types.hpp>
#include <boost/python/reference.hpp> // for handle_exception()
#include <boost/python/conversions.hpp>
#include <boost/python/module_builder.hpp>
#include <boost/python/detail/none.hpp>
#include <boost/python/detail/void_adaptor.hpp>
#include <cstring>
#include <vector>
#include <cstddef>
#include <stdexcept>
#include <boost/python/objects.hpp>
#include <boost/type_traits/alignment_traits.hpp>
#include <boost/bind.hpp>

namespace boost { namespace python {

namespace
{
  using detail::type_object_base;
  using detail::call_object;

  // Define a family of forwarding functions that can be called from a
  // PyTypeObject's slots. These functions dispatch through a (virtual) member
  // function pointer in the type_object_base, and handle exceptions in a
  // uniform way, preventing us from having to rewrite the dispatching code over
  // and over.

  // Given a function object f with signature
  //
  //    PyObject* f(PyTypeObject*,PyObject*)
  //
  // calls f inside of handle_exception, and returns the result. If an exception
  // is thrown by f, returns 0.
  template <class F>
  PyObject* obj_call(PyObject* obj, F f)
  {
      PyObject* result;
      return call_object(result, obj, f) ? 0 : result;
  }

  // Call the given integer-returning function object inside of
  // handle_exception, returning a value_holder. F is a function
  // object with "signature"
  //
  //     R F(PyTypeObject*, PyObject*)
  //
  // where R is an integer type.
  template <class R, class F>
  R int_call(PyObject* obj, F f, R* = 0)
  {
      R result;
      return call_object(result, obj, f) ? -1 : result;
  }

  // Implemented in terms of obj_call, above
  PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*) const)
  {
      return obj_call(obj, bind(f, _1, _2));
  }

  // Implemented in terms of int_call, above
  int call(PyObject* obj, int (type_object_base::*f)(PyObject*) const)
  {
      return int_call<int>(obj, bind(f, _1, _2));
  }

  template <class A1>
  PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*, A1) const, A1 a1)
  {
      return obj_call(obj, bind(f, _1, _2, a1));
  }

  template <class A1>
  int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1) const, A1 a1)
  {
      return int_call<int>(obj, bind(f, _1, _2, a1));
  }

  template <class A1, class A2>
  PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2)
  {
      return obj_call(obj, bind(f, _1, _2, a1, a2));
  }

  template <class A1, class A2>
  int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2)
  {
      return int_call<int>(obj, bind(f, _1, _2, a1, a2));
  }

  template <class A1, class A2, class A3>
  int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1, A2, A3) const, A1 a1, A2 a2, A3 a3)
  {
      return int_call<int>(obj, bind(f, _1, _2, a1, a2, a3));
  }

  int call_length_function(PyObject* obj, int (type_object_base::*f)(PyObject*) const)
  {
      int result;
      if (call_object(result, obj, bind(f, _1, _2)))
          return -1;

      if (result >= 0)
          return result;

      PyErr_SetString(PyExc_ValueError, "__len__() should return >= 0");
      return -1;
  }
}  // anonymous namespace

extern "C" {

//
// These functions actually go into the type object's slots, and dispatch to the
// "call" wrappers defined above.
//
static PyObject* do_instance_repr(PyObject* obj)
{
    return call(obj, &type_object_base::instance_repr);
}

static PyObject* do_instance_richcompare(PyObject* obj, PyObject* other, int d)
{
#if PYTHON_API_VERSION >= 1010
    switch(d)
    {
        case Py_LT:
          return call(obj, &type_object_base::instance_lt, other);
        case Py_LE:
          return call(obj, &type_object_base::instance_le, other);
        case Py_EQ:
          return call(obj, &type_object_base::instance_eq, other);
        case Py_NE:
          return call(obj, &type_object_base::instance_ne, other);
        case Py_GT:
          return call(obj, &type_object_base::instance_gt, other);
        case Py_GE:
          return call(obj, &type_object_base::instance_ge, other);
    }
#endif
    return 0;
}

static int do_instance_compare(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_compare, other);
}

static PyObject* do_instance_str(PyObject* obj)
{
    return call(obj, &type_object_base::instance_str);
}

static long do_instance_hash(PyObject* obj)
{
    return int_call<long>(obj, bind(&type_object_base::instance_hash, _1, _2));
}

static PyObject* do_instance_call(PyObject* obj, PyObject* args, PyObject* keywords)
{
    return call(obj, &type_object_base::instance_call, args, keywords);
}

static void do_instance_dealloc(PyObject* obj)
{
    if (handle_exception(
            bind(&type_object_base::instance_dealloc
                 , static_cast<type_object_base*>(obj->ob_type)
                 , obj))
        )
    {
        assert(!"exception during destruction!");
    }
}

static PyObject* do_instance_getattr(PyObject* obj, char* name)
{
    const char* name_ = name;
    return call(obj, &type_object_base::instance_getattr, name_);
}

static int do_instance_setattr(PyObject* obj, char* name, PyObject* value)
{
    const char* name_ = name;
    return call(obj, &type_object_base::instance_setattr, name_, value);
}

static int do_instance_mp_length(PyObject* obj)
{
    return call_length_function(obj, &type_object_base::instance_mapping_length);
}

static int do_instance_sq_length(PyObject* obj)
{
    return call_length_function(obj, &type_object_base::instance_sequence_length);
}

static PyObject* do_instance_mp_subscript(PyObject* obj, PyObject* index)
{
    return call(obj, &type_object_base::instance_mapping_subscript, index);
}

static PyObject* do_instance_sq_item(PyObject* obj, int index)
{
    // This is an extension to standard class behavior. If sequence_length
    // is implemented and n >= sequence_length(), raise an IndexError. That
    // keeps users from having to worry about raising it themselves
    const PyTypeObject* const type = obj->ob_type;
    if (type->tp_as_sequence != 0 && type->tp_as_sequence->sq_length != 0
        && index >= type->tp_as_sequence->sq_length(obj))
    {
        PyErr_SetString(PyExc_IndexError, type->tp_name);
        return 0;
    }

    return obj_call(
        obj
        , bind(&type_object_base::instance_sequence_item, _1, _2, index));
}

static int do_instance_mp_ass_subscript(PyObject* obj, PyObject* index, PyObject* value)
{
    return call(obj, &type_object_base::instance_mapping_ass_subscript, index, value);
}

static int do_instance_sq_ass_item(PyObject* obj, int index, PyObject* value)
{
    return call(obj, &type_object_base::instance_sequence_ass_item, index, value);
}

static PyObject* do_instance_sq_concat(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_sequence_concat, other);
}

static PyObject* do_instance_sq_repeat(PyObject* obj, int n)
{
    return call(obj, &type_object_base::instance_sequence_repeat, n);
}

static PyObject* do_instance_sq_slice(
    PyObject* obj, int start, int finish)
{
    return call(obj, &type_object_base::instance_sequence_slice, start, finish);
}

static int do_instance_sq_ass_slice(
    PyObject* obj, int start, int finish, PyObject* value)
{
    return call(obj, &type_object_base::instance_sequence_ass_slice, start, finish, value);
}

static PyObject* do_instance_nb_add(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_add, other);
}

static PyObject* do_instance_nb_subtract(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_subtract, other);
}

static PyObject* do_instance_nb_multiply(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_multiply, other);
}

static PyObject* do_instance_nb_divide(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_divide, other);
}

static PyObject* do_instance_nb_remainder(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_remainder, other);
}

static PyObject* do_instance_nb_divmod(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_divmod, other);
}

static PyObject* do_instance_nb_power(PyObject* obj, PyObject* exponent, PyObject* modulus)
{
    return call(obj, &type_object_base::instance_number_power, exponent, modulus);
}

static PyObject* do_instance_nb_negative(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_negative);
}

static PyObject* do_instance_nb_positive(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_positive);
}

static PyObject* do_instance_nb_absolute(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_absolute);
}

static int do_instance_nb_nonzero(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_nonzero);
}

static PyObject* do_instance_nb_invert(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_invert);
}

static PyObject* do_instance_nb_lshift(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_lshift, other);
}

static PyObject* do_instance_nb_rshift(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_rshift, other);
}

static PyObject* do_instance_nb_and(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_and, other);
}

static PyObject* do_instance_nb_xor(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_xor, other);
}

static PyObject* do_instance_nb_or(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_or, other);
}

static int do_instance_nb_coerce(PyObject**obj, PyObject**other)
{
    // no call() overload for this oddball function, so we'll do it manually
    return int_call<int>(
        *obj, bind(
            &type_object_base::instance_number_coerce, _1, _2, obj, other));
}
static PyObject* do_instance_nb_int(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_int);
}

static PyObject* do_instance_nb_long(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_long);
}

static PyObject* do_instance_nb_float(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_float);
}

static PyObject* do_instance_nb_oct(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_oct);
}

static PyObject* do_instance_nb_hex(PyObject* obj)
{
    return call(obj, &type_object_base::instance_number_hex);
}

static PyObject* do_instance_nb_inplace_add(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_add, other);
}

static PyObject* do_instance_nb_inplace_subtract(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_subtract, other);
}

static PyObject* do_instance_nb_inplace_multiply(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_multiply, other);
}

static PyObject* do_instance_nb_inplace_divide(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_divide, other);
}

static PyObject* do_instance_nb_inplace_remainder(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_remainder, other);
}

static PyObject* do_instance_nb_inplace_power(PyObject* obj, PyObject* exponent, PyObject* modulus)
{
    return call(obj, &type_object_base::instance_number_inplace_power, exponent, modulus);
}

static PyObject* do_instance_nb_inplace_lshift(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_lshift, other);
}

static PyObject* do_instance_nb_inplace_rshift(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_rshift, other);
}

static PyObject* do_instance_nb_inplace_and(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_and, other);
}

static PyObject* do_instance_nb_inplace_or(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_or, other);
}

static PyObject* do_instance_nb_inplace_xor(PyObject* obj, PyObject* other)
{
    return call(obj, &type_object_base::instance_number_inplace_xor, other);
}

} // extern "C"

namespace
{

#define ENABLE_GENERAL_CAPABILITY(field) \
    case type_object_base::field: \
        dest->tp_##field = &do_instance_##field; \
        return true

bool add_capability_general(type_object_base::capability capability, PyTypeObject* dest)
{
    assert(dest != 0);

    switch(capability)
    {
        ENABLE_GENERAL_CAPABILITY(hash);
        ENABLE_GENERAL_CAPABILITY(call);
        ENABLE_GENERAL_CAPABILITY(str);
        ENABLE_GENERAL_CAPABILITY(getattr);
        ENABLE_GENERAL_CAPABILITY(setattr);
        ENABLE_GENERAL_CAPABILITY(compare);
        ENABLE_GENERAL_CAPABILITY(repr);
        default:
            return false;
    }
}

template <class T>
void create_method_table_if_null(T*& table)
{
    if(table == 0)
    {
        detail::shared_pod_manager::create(table);
    }
    else
    {
        detail::shared_pod_manager::make_unique_copy(table);
    }
}

bool add_capability_richcompare(type_object_base::capability capability, PyTypeObject* dest)
{
    assert(dest != 0);
    if (capability == type_object_base::richcompare) {
#if PYTHON_API_VERSION >= 1010
      dest->tp_richcompare = &do_instance_richcompare;
      dest->tp_flags |= Py_TPFLAGS_HAVE_RICHCOMPARE;
#endif
      return true;
    }

    return false;
}

#define ENABLE_INPLACE_CAPABILITY(field) \
    case type_object_base::number_##field: \
        create_method_table_if_null(dest->tp_as_number); \
        dest->tp_as_number->nb_##field = &do_instance_nb_##field; \
        detail::shared_pod_manager::replace_if_equal(dest->tp_as_number); \
        dest->tp_flags |= Py_TPFLAGS_HAVE_INPLACEOPS; \
        return true

bool add_capability_inplace(type_object_base::capability capability, PyTypeObject* dest)
{
    assert(dest != 0);
    switch (capability)
    {
#if PYTHON_API_VERSION >= 1010
        ENABLE_INPLACE_CAPABILITY (inplace_add);
        ENABLE_INPLACE_CAPABILITY (inplace_subtract);
        ENABLE_INPLACE_CAPABILITY (inplace_multiply);
        ENABLE_INPLACE_CAPABILITY (inplace_divide);
        ENABLE_INPLACE_CAPABILITY (inplace_remainder);
        ENABLE_INPLACE_CAPABILITY (inplace_power);
        ENABLE_INPLACE_CAPABILITY (inplace_lshift);
        ENABLE_INPLACE_CAPABILITY (inplace_rshift);
        ENABLE_INPLACE_CAPABILITY (inplace_and);
        ENABLE_INPLACE_CAPABILITY (inplace_or);
        ENABLE_INPLACE_CAPABILITY (inplace_xor);
#endif
        default:
            return false;
    }
}

#define ENABLE_MAPPING_CAPABILITY(field) \
    case type_object_base::mapping_##field: \
        create_method_table_if_null(dest); \
        dest->mp_##field = &do_instance_mp_##field; \
        detail::shared_pod_manager::replace_if_equal(dest); \
        return true

bool add_capability_mapping(type_object_base::capability capability, PyMappingMethods*& dest)
{
    switch(capability)
    {
        ENABLE_MAPPING_CAPABILITY(length);
        ENABLE_MAPPING_CAPABILITY(subscript);
        ENABLE_MAPPING_CAPABILITY(ass_subscript);
        default:
            return false;
    }
}

#define ENABLE_SEQUENCE_CAPABILITY(field) \
    case type_object_base::sequence_##field: \
        create_method_table_if_null(dest); \
        dest->sq_##field = &do_instance_sq_##field; \
        detail::shared_pod_manager::replace_if_equal(dest); \
        return true

bool add_capability_sequence(type_object_base::capability capability, PySequenceMethods*& dest)
{
    switch(capability)
    {
        ENABLE_SEQUENCE_CAPABILITY(length);
        ENABLE_SEQUENCE_CAPABILITY(item);
        ENABLE_SEQUENCE_CAPABILITY(ass_item);
        ENABLE_SEQUENCE_CAPABILITY(concat);
        ENABLE_SEQUENCE_CAPABILITY(repeat);
        ENABLE_SEQUENCE_CAPABILITY(slice);
        ENABLE_SEQUENCE_CAPABILITY(ass_slice);
        default:
            return false;
    }
}

#define ENABLE_NUMBER_CAPABILITY(field) \
    case type_object_base::number_##field: \
        create_method_table_if_null(dest); \
        dest->nb_##field = &do_instance_nb_##field; \
        detail::shared_pod_manager::replace_if_equal(dest); \
        return true

bool add_capability_number(type_object_base::capability capability, PyNumberMethods*& dest)
{
    switch(capability)
    {
        ENABLE_NUMBER_CAPABILITY(add);
        ENABLE_NUMBER_CAPABILITY(subtract);
        ENABLE_NUMBER_CAPABILITY(multiply);
        ENABLE_NUMBER_CAPABILITY(divide);
        ENABLE_NUMBER_CAPABILITY(remainder);
        ENABLE_NUMBER_CAPABILITY(divmod);
        ENABLE_NUMBER_CAPABILITY(power);
        ENABLE_NUMBER_CAPABILITY(negative);
        ENABLE_NUMBER_CAPABILITY(positive);
        ENABLE_NUMBER_CAPABILITY(absolute);
        ENABLE_NUMBER_CAPABILITY(nonzero);
        ENABLE_NUMBER_CAPABILITY(invert);
        ENABLE_NUMBER_CAPABILITY(lshift);
        ENABLE_NUMBER_CAPABILITY(rshift);
        ENABLE_NUMBER_CAPABILITY(and);
        ENABLE_NUMBER_CAPABILITY(xor);
        ENABLE_NUMBER_CAPABILITY(or);
        ENABLE_NUMBER_CAPABILITY(coerce);
        ENABLE_NUMBER_CAPABILITY(int);
        ENABLE_NUMBER_CAPABILITY(long);
        ENABLE_NUMBER_CAPABILITY(float);
        ENABLE_NUMBER_CAPABILITY(oct);
        ENABLE_NUMBER_CAPABILITY(hex);
        default:
            return false;
    }
}

#define ENABLE_BUFFER_CAPABILITY(field) \
    case type_object_base::buffer_##field: \
        create_method_table_if_null(dest); \
        dest->bf_##field = &do_instance_bf_##field; \
        detail::shared_pod_manager::replace_if_equal(dest); \
        return true

bool add_capability_buffer(type_object_base::capability capability, PyBufferProcs*& dest)
{
    (void)dest; // suppress unused argument warning
    (void)capability; // likwise
#if 0
    switch(capability)
    {
        // nothing defined yet
        default:
            return false;
    }
#endif
    return false;
}

} // anonymous namespace

namespace detail  {

  void add_capability(
      type_object_base::capability capability,
      PyTypeObject* dest_)
  {
    if(add_capability_general(capability, dest_))
        return;
    if(add_capability_richcompare(capability, dest_))
        return;
    if(add_capability_inplace(capability, dest_))
        return;
    if(add_capability_mapping(capability, dest_->tp_as_mapping))
        return;
    if(add_capability_sequence(capability, dest_->tp_as_sequence))
        return;
    if(add_capability_number(capability, dest_->tp_as_number))
        return;
    if(add_capability_buffer(capability, dest_->tp_as_buffer))
        return;

    // no one recognized the capability
    throw std::runtime_error("py::detail::add_capability(): unknown capability");
  }
} // namespace detail

type_object_base::~type_object_base()
{
    detail::shared_pod_manager::dispose(tp_as_mapping);
    detail::shared_pod_manager::dispose(tp_as_sequence);
    detail::shared_pod_manager::dispose(tp_as_number);
    detail::shared_pod_manager::dispose(tp_as_buffer);
}

void type_object_base::enable(type_object_base::capability capability)
{
    detail::add_capability(capability, this);
}

type_object_base::type_object_base(PyTypeObject* t)
    : python_type(t)
{
    this->tp_dealloc = do_instance_dealloc;
}

namespace
{
  typedef long pod_refcount;

  inline pod_refcount pod_refcount_offset(std::size_t size)
  {
      const std::size_t alignment = boost::alignment_of<pod_refcount>::value;
      return (size + alignment - 1) / alignment * alignment;
  }

  inline pod_refcount* counted_pod_refcount(char* pod, std::size_t size)
  {
      if(pod == 0)
          return 0;

      return reinterpret_cast<pod_refcount*>(pod + pod_refcount_offset(size));
  }

  #ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
  int pod_instance_counter = 0;
  #endif

  inline pod_refcount counted_pod_getref(char* pod, std::size_t size)
  {
      pod_refcount* ref_count = counted_pod_refcount(pod, size);
      return ref_count == 0 ? -1 : *ref_count;
  }

  inline pod_refcount counted_pod_decref(char* pod, std::size_t size)
  {
      pod_refcount* const ref_count = counted_pod_refcount(pod, size);
      if (ref_count == 0)
          return -1;
      --(*ref_count);
      if (*ref_count <= 0)
      {
  #ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
          --pod_instance_counter;
  #endif
          ::operator delete(pod);
          return 0;
      }
      return *ref_count;
  }

  pod_refcount counted_pod_incref(char* pod, std::size_t size)
  {
      pod_refcount* ref_count = counted_pod_refcount(pod, size);
      return ref_count == 0 ? -1 : ++(*ref_count);
  }

} // anonymous namespace

namespace detail
{
  struct shared_pod_manager::compare
  {
      bool operator()(const std::pair<char*, std::size_t>& x1,
                      const std::pair<char*, std::size_t>& x2) const
      {
          const std::size_t n1 = x1.second;
          const std::size_t n2 = x2.second;
          return n1 < n2 || n1 == n2 && BOOST_CSTD_::memcmp(x1.first, x2.first, n1) < 0;
      }
  };

  struct shared_pod_manager::identical
  {
      identical(char* p) : pod(p) {}

      bool operator()(const std::pair<char*, std::size_t>& x) const
      {
          return pod == x.first;
      }

      char* pod;
  };

  shared_pod_manager& shared_pod_manager::obj()
  {
      static shared_pod_manager spm;
      return spm;
  }

  shared_pod_manager::~shared_pod_manager()
  {
  }

  void* shared_pod_manager::replace_if_equal(void* pod, std::size_t size)
  {
      if(pod == 0)
          return 0;

      const holder element(static_cast<char*>(pod), size);

      const storage::iterator found
          = std::lower_bound(m_storage.begin(), m_storage.end(), element, compare());

      if (found != m_storage.end() && pod == found->first)
      {
          // pod already in list => do nothing
          return pod;
      }
      else if (found != m_storage.end() && !compare()(element, *found))
      {
          // equal element in list => replace
          void* replacement = found->first;
          counted_pod_incref(found->first, size);
          dec_ref(element.first, size); // invalidates iterator 'found'
          return replacement;
      }
      else
      {
          // new element => insert
          m_storage.insert(found, element);
          return pod;
      }
  }

  void* shared_pod_manager::make_unique_copy(void* pod, std::size_t size)
  {
      if(pod == 0)
          return 0;
      if(counted_pod_getref(static_cast<char*>(pod), size) == 1)
      {
          erase_from_list(pod);
          return pod;
      }
      else
      {
          void* copy = create(size);
          memmove(copy, pod, size);
          dec_ref(pod, size);
          return copy;
      }
  }

  void* shared_pod_manager::create(std::size_t size)
  {
      std::size_t total_size = pod_refcount_offset(size) + sizeof(pod_refcount);
      char* pod = static_cast<char*>(::operator new(total_size));
  #ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
      ++pod_instance_counter;
  #endif
      memset(pod, 0, total_size);

      *counted_pod_refcount(pod, size) = 1;

      return pod;
  }

  void shared_pod_manager::dec_ref(void* pod, std::size_t size)
  {
      if(pod == 0)
          return;

      int ref_count = counted_pod_decref(static_cast<char*>(pod), size);

      if(ref_count <= 0)
          erase_from_list(pod);
  }

  void shared_pod_manager::erase_from_list(void* pod)
  {
      if(pod == 0)
          return;

      const storage::iterator found =
          std::find_if(m_storage.begin(), m_storage.end(),
          identical(static_cast<char*>(pod)));

      if(found != m_storage.end())
      {
          m_storage.erase(found);
      }
  }
} // namespace detail

namespace {
  struct error_type {
      operator PyObject*() const { return 0; }
      operator int() const { return -1; }
  };

  error_type unimplemented(const char* name)
  {
      assert(!"Control should never reach here");
      string s("Unimplemented ");
      s += string(name);
      PyErr_SetObject(PyExc_RuntimeError, s.get());
      return error_type();
  }
}

PyObject* type_object_base::instance_repr(PyObject*) const
{
    return unimplemented("instance_repr");
}

int type_object_base::instance_compare(PyObject*, PyObject*) const
{
    return unimplemented("instance_compare");
}

PyObject* type_object_base::instance_str(PyObject*) const
{
    return unimplemented("instance_str");
}

long type_object_base::instance_hash(PyObject* /* obj */) const
{
    return unimplemented("instance_hash");
}

PyObject* type_object_base::instance_call(PyObject* /*obj*/, PyObject* /*args*/, PyObject* /*kw*/) const
{
    return unimplemented("instance_call");
}

PyObject* type_object_base::instance_getattr(PyObject* /*obj*/, const char* /*name*/) const
{
    return unimplemented("instance_getattr");
}

int type_object_base::instance_setattr(PyObject* /*obj*/, const char* /*name*/, PyObject* /*value*/) const
{
    return unimplemented("instance_setattr");
}

int type_object_base::instance_mapping_length(PyObject*) const
{
    return unimplemented("instance_mapping_length");
}

int type_object_base::instance_sequence_length(PyObject*) const
{
    return unimplemented("instance_sequence_length");
}

PyObject* type_object_base::instance_mapping_subscript(PyObject*, PyObject*) const
{
    return unimplemented("instance_mapping_subscript");
}

PyObject* type_object_base::instance_sequence_item(PyObject*, int) const
{
    return unimplemented("instance_sequence_item");
}

int type_object_base::instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const
{
    return unimplemented("instance_mapping_ass_subscript");
}

int type_object_base::instance_sequence_ass_item(PyObject*, int, PyObject*) const
{
    return unimplemented("instance_sequence_ass_item");
}

PyObject* type_object_base::instance_sequence_concat(PyObject*, PyObject*) const
{
    return unimplemented("instance_sequence_concat");
}

PyObject* type_object_base::instance_sequence_repeat(PyObject*, int) const
{
    return unimplemented("instance_sequence_repeat");
}

PyObject* type_object_base::instance_sequence_slice(PyObject*, int, int) const
{
    return unimplemented("instance_sequence_slice");
}

int type_object_base::instance_sequence_ass_slice(PyObject*, int, int, PyObject*) const
{
    return unimplemented("instance_sequence_ass_slice");
}

PyObject* type_object_base::instance_number_add(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_add");
}

PyObject* type_object_base::instance_number_subtract(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_subtract");
}

PyObject* type_object_base::instance_number_multiply(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_multiply");
}

PyObject* type_object_base::instance_number_divide(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_divide");
}

PyObject* type_object_base::instance_number_remainder(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_remainder");
}

PyObject* type_object_base::instance_number_divmod(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_divmod");
}

PyObject* type_object_base::instance_number_power(PyObject*, PyObject*, PyObject*) const
{
    return unimplemented("instance_number_power");
}

PyObject* type_object_base::instance_number_negative(PyObject*) const
{
    return unimplemented("instance_number_negative");
}

PyObject* type_object_base::instance_number_positive(PyObject*) const
{
    return unimplemented("instance_number_positive");
}

PyObject* type_object_base::instance_number_absolute(PyObject*) const
{
    return unimplemented("instance_number_absolute");
}

int type_object_base::instance_number_nonzero(PyObject*) const
{
    return unimplemented("instance_number_nonzero");
}

PyObject* type_object_base::instance_number_invert(PyObject*) const
{
    return unimplemented("instance_number_invert");
}

PyObject* type_object_base::instance_number_lshift(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_lshift");
}

PyObject* type_object_base::instance_number_rshift(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_rshift");
}

PyObject* type_object_base::instance_number_and(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_and");
}

PyObject* type_object_base::instance_number_xor(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_xor");
}

PyObject* type_object_base::instance_number_or(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_or");
}

int type_object_base::instance_number_coerce(PyObject*, PyObject**, PyObject**) const
{
    return unimplemented("instance_number_coerce");
}

PyObject* type_object_base::instance_number_int(PyObject*) const
{
    return unimplemented("instance_number_int");
}

PyObject* type_object_base::instance_number_long(PyObject*) const
{
    return unimplemented("instance_number_long");
}

PyObject* type_object_base::instance_number_float(PyObject*) const
{
    return unimplemented("instance_number_float");
}

PyObject* type_object_base::instance_number_oct(PyObject*) const
{
    return unimplemented("instance_number_oct");
}

PyObject* type_object_base::instance_number_hex(PyObject*) const
{
    return unimplemented("instance_number_hex");
}

PyObject* type_object_base::instance_number_inplace_add(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_add");
}

PyObject* type_object_base::instance_number_inplace_subtract(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_subtract");
}

PyObject* type_object_base::instance_number_inplace_multiply(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_multiply");
}

PyObject* type_object_base::instance_number_inplace_divide(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_divide");
}

PyObject* type_object_base::instance_number_inplace_remainder(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_remainder");
}

PyObject* type_object_base::instance_number_inplace_power(PyObject*, PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_power");
}

PyObject* type_object_base::instance_number_inplace_lshift(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_lshift");
}

PyObject* type_object_base::instance_number_inplace_rshift(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_rshift");
}

PyObject* type_object_base::instance_number_inplace_and(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_and");
}

PyObject* type_object_base::instance_number_inplace_or(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_or");
}

PyObject* type_object_base::instance_number_inplace_xor(PyObject*, PyObject*) const
{
    return unimplemented("instance_number_inplace_xor");
}

PyObject* type_object_base::instance_lt(PyObject*, PyObject*) const
{
    return unimplemented("instance_lt");
}

PyObject* type_object_base::instance_le(PyObject*, PyObject*) const
{
    return unimplemented("instance_le");
}

PyObject* type_object_base::instance_eq(PyObject*, PyObject*) const
{
    return unimplemented("instance_eq");
}

PyObject* type_object_base::instance_ne(PyObject*, PyObject*) const
{
    return unimplemented("instance_ne");
}

PyObject* type_object_base::instance_gt(PyObject*, PyObject*) const
{
    return unimplemented("instance_gt");
}

PyObject* type_object_base::instance_ge(PyObject*, PyObject*) const
{
    return unimplemented("instance_ge");
}

}} // namespace boost::python

#ifdef TYPE_OBJECT_BASE_STANDALONE_TEST

struct TestTypeObject : boost::python::type_object_base
{
    TestTypeObject()
    : boost::python::type_object_base(Py_None->ob_type->ob_type)
    {}

    void instance_dealloc(PyObject*) const {}
};

struct POD1
{
    unsigned char data;
};

int main()
{
    boost::python::type_object_base *o1, *o2, *o3;

//    POD1 * pod1;
//    boost::python::detail::shared_pod_manager::create(pod1);

    o1 = new TestTypeObject;
    o2 = new TestTypeObject;
    o3 = new TestTypeObject;

    assert(boost::python::pod_instance_counter == 0);

    o1->enable(boost::python::type_object_base::number_add);
    o1->enable(boost::python::type_object_base::compare);

    o2->enable(boost::python::type_object_base::number_add);
    o2->enable(boost::python::type_object_base::mapping_length);

    o3->enable(boost::python::type_object_base::number_add);
    o3->enable(boost::python::type_object_base::sequence_length);

    assert(boost::python::pod_instance_counter == 3);
    assert(o1->tp_as_number && !o1->tp_as_mapping && !o1->tp_as_sequence);
    assert(o2->tp_as_number && o2->tp_as_mapping && !o2->tp_as_sequence);
    assert(o3->tp_as_number && !o3->tp_as_mapping && o3->tp_as_sequence);
    assert(o1->tp_as_number == o2->tp_as_number);
    assert(o1->tp_as_number == o3->tp_as_number);
    assert((void*)o2->tp_as_number != o2->tp_as_mapping);
    assert((void*)o2->tp_as_mapping != o3->tp_as_sequence);

    o1->enable(boost::python::type_object_base::number_subtract);

    assert(boost::python::pod_instance_counter == 4);
    assert(o1->tp_as_number != o2->tp_as_number);
    assert(o2->tp_as_number == o3->tp_as_number);

    o3->enable(boost::python::type_object_base::mapping_subscript);

    assert(boost::python::pod_instance_counter == 5);
    assert(o3->tp_as_number && o3->tp_as_mapping && o3->tp_as_sequence);
    assert(o2->tp_as_mapping != o3->tp_as_mapping);

    o2->enable(boost::python::type_object_base::mapping_subscript);
    o3->enable(boost::python::type_object_base::mapping_length);

    assert(boost::python::pod_instance_counter == 4);
    assert(o2->tp_as_number && o2->tp_as_mapping && !o2->tp_as_sequence);
    assert(o3->tp_as_number && o3->tp_as_mapping && o3->tp_as_sequence);
    assert(o2->tp_as_mapping == o3->tp_as_mapping);

    boost::python::type_object_base *o4 = new TestTypeObject;

    assert(boost::python::pod_instance_counter == 4);

    o4->enable(boost::python::type_object_base::number_add);

    assert(boost::python::pod_instance_counter == 4);
    assert(o4->tp_as_number && !o4->tp_as_mapping && !o4->tp_as_sequence);
    assert(o4->tp_as_number == o3->tp_as_number);

    delete o3;

    assert(boost::python::pod_instance_counter == 3);
    assert(o1->tp_as_number && !o1->tp_as_mapping && !o1->tp_as_sequence);
    assert(o2->tp_as_number && o2->tp_as_mapping && !o2->tp_as_sequence);
    assert(o4->tp_as_number && !o4->tp_as_mapping && !o4->tp_as_sequence);
    assert(o4->tp_as_number == o2->tp_as_number);

    o3 =  new TestTypeObject;

    assert(boost::python::pod_instance_counter == 3);

    o3->enable(boost::python::type_object_base::number_add);
    o3->enable(boost::python::type_object_base::sequence_length);

    assert(boost::python::pod_instance_counter == 4);
    assert(o3->tp_as_number && !o3->tp_as_mapping && o3->tp_as_sequence);
    assert(o1->tp_as_number != o3->tp_as_number);
    assert(o2->tp_as_number == o3->tp_as_number);

    delete o1;

    assert(boost::python::pod_instance_counter == 3);

    delete o4;

    assert(boost::python::pod_instance_counter == 3);

    delete o3;

    assert(boost::python::pod_instance_counter == 2);

    delete o2;

    assert(boost::python::pod_instance_counter == 0);

    assert(boost::python::detail::shared_pod_manager::obj().m_storage.size() == 0);
}

#endif

redpajama_set_name: RedPajamaGithub


text:
Conservation, Digital Production Center
Revealing Hidden Texts
March 4, 2016 Beth Doyle 1 Comment
For months a group of DUL staff including Mike Adamo and Molly Bragg from the Digital Production Center, Josh Sosin and Ryan Baumann from the Duke Collaboratory for Classics Computing, and myself have been discussing the potential use of multi-spectral imaging (MSI) in our work. This week, Mike Toth and Bill Christens-Berry of R.B. Toth Associates were on campus to facilitate two days of MSI imaging.
Day 1: An alternative to scanning mice eyes
Mr. Toth's sister, Dr. Cynthia Toth, is an ophthalmologist at the Duke Eye Center. She uses optical coherence tomography (OCT) to scan premature infants' eyes to detect neurological and visual problems. Dr. Toth and Mr. Toth coordinated time with Dr. Sina Farsiu and his graduate student Guorong Li to image a few papyri from the David M. Rubenstein Rare Book and Manuscript Library. Dr. Farsiu uses OCT in his research. When he isn't kindly imaging papyri, he is scanning mice eyes. Dr. Farsiu also coordinated time in Dr. Adam Wax's lab in the Biomedical Engineering Department where we used their OCT scanner to image the papyri using a slightly different set up. Dr. Wax's team is usually scanning rat esophagi and mice eyes, so a day with papyri was a bit out of their wheelhouse but everyone seemed to enjoy the collaboration. The Raleigh News & Observer was there as well and posted this story.
Mike Adamo from the DPC and I escorted the Rubenstein collection materials to the Duke Eye Center and the Biomedical Engineering lab. My role was to provide safe transportation across campus, and to handle the fragile items. Having researched OCT, I felt that this was a safe, non-destructive imaging technique for the papyri. It's hard to say what the outcome of the OCT scanning will be, but it has potential to reveal hidden media, which is exciting to think about.
(L to R) Dr. Cynthia Toth, Dr. Sina Farsiu, and Mike Toth look at preliminary scans at the Duke Eye Center.
(L to R) Dr. Farsiu, Guorong Li, and Mike Toth review preliminary scans at the Duke Eye Center.
Ryan Baumann, Josh Sosin, and two technicians from the Biomedical Engineering Department review preliminary scans.
Lasers have a lot of parts.
Day 2: MSI Scanning in DPC
On Wednesday, Toth and Christens-Berry set up their MSI equipment in the DUL Digital Production Center. Their system scans at a variety of UV and IR wavelengths. The Library was interested in testing a range of problems to see what this system could reveal. The materials we scanned included several papyri with obscured text, two early Hebrew manuscripts whose writing is almost completely obscured by the condition of the gevil, a bound book with a Latin manuscript paste-down that is obscured by a previously adhered bookplate, and a Greek manuscript that was scraped and written over. All of these items present common problems for researchers using ancient texts.
Bill Christens-Berry scans a papyrus fragment.
Bill Christens-Berry shows us preliminary results. You can clearly see writing underneath areas of gesso on this papyri.
DPC doesn't normally have this many people in their camera room. (Photo by Mark Zupan)
The work that we did on Tuesday and Wednesday was meant to provide "proof of concept" for the conversations that must happen regarding funding, staffing, training, workflows and service expectations if the Library were to develop an MSI scanning workflow.
Conservation is excited about MSI for its potential to discover more about the materials we work on. Having the ability to image in both UV and IR would expand our knowledge of the materials, expose information we can't see with the naked eye, and enable us to envision better treatments. I think we are all excited for its potential to provide access to materials that right now cannot be easily used or read, such as the Hebrew manuscripts and the hidden texts on the papyri cartonnage. We literally had a "Holy [Cow]" moment when we saw these materials give up their secrets. It gave me goosebumps.
Mike Adamo wrote a blog post for Bitstreams describing their side of this project.
See 'Ya Later Tedd
What Comes Out in the Wash
Learning Together: Leather Repair Tips and Tricks
digitizationearly manuscriptsmsi scanningoct scanninpapyri
Previous PostTool Time: Lifting and ScrapingNext PostSay Hello to Eddie Cameron
One thought on "Revealing Hidden Texts"
Mike Toth says:
Appreciate all the support of the entire Duke Libraries, Biomedical Engineering and Eye Center team, as part of our broader international collaboration to reveal texts on mummy cartonnage, championed by the Arcadia Fund. More on this at https://facesandvoices.wordpress.com/2015/10/28/making-the-mummies-talk-without-palmolive-soap/
Duke University Libraries Preservation
SOS: Save Our Stuff, How you can help preserve library collections (installed January 2023)
On display in Perkins Library, Lower Level 1, Room 023. Open during regular library hours.
We're Going to Need a Bigger Box
The Banana Book Returns!
The Library Uncovered: Behind the Scenes with Collections Services
Beth Doyle on The Library Uncovered: Behind the Scenes with Collections Services
Suhaim on A Tiny Press Calls for a Tiny Book
Peter Verheyen on Invasion of the Binding Snatchers
Search Preservation Underground
Categories Select Category 1091 Project Adopt-a-Book Adopt-a-Book Announcements Awards Boxing Day Brittle books Circulating collections care Circulating collections care Collaboration Conservation Covid-19 Digital Production Center Digitizing Disaster planning Disaster recovery Edible Book Festival Environment Events Exhibits Housing International materials job announcement Manuscript Day May Day News Preservation Preservation Week Quick Pic Readings Renovation Rubenstein Renovation Statistics Technology Tools and Equipment Training Uncategorized Videos What Others Say About us What We Find In Books What's In The Lab
Archives Select Month January 2023 (3) December 2022 (2) November 2022 (2) October 2022 (3) September 2022 (1) August 2022 (4) July 2022 (1) June 2022 (1) May 2022 (1) April 2022 (3) March 2022 (3) February 2022 (2) January 2022 (3) December 2021 (1) November 2021 (3) October 2021 (1) September 2021 (2) August 2021 (2) July 2021 (3) June 2021 (4) April 2021 (3) March 2021 (1) February 2021 (3) January 2021 (4) December 2020 (2) November 2020 (2) October 2020 (3) September 2020 (4) August 2020 (3) July 2020 (5) June 2020 (4) May 2020 (4) April 2020 (4) March 2020 (4) February 2020 (4) January 2020 (3) November 2019 (3) October 2019 (2) September 2019 (2) August 2019 (2) July 2019 (4) June 2019 (3) May 2019 (4) April 2019 (3) March 2019 (3) February 2019 (4) January 2019 (2) November 2018 (2) October 2018 (2) September 2018 (2) August 2018 (4) July 2018 (3) June 2018 (3) May 2018 (3) April 2018 (6) March 2018 (4) February 2018 (2) January 2018 (3) December 2017 (2) November 2017 (2) October 2017 (2) September 2017 (4) August 2017 (4) July 2017 (2) June 2017 (2) May 2017 (1) April 2017 (4) March 2017 (5) February 2017 (2) January 2017 (2) December 2016 (4) November 2016 (3) October 2016 (3) September 2016 (2) August 2016 (5) July 2016 (5) June 2016 (3) May 2016 (3) April 2016 (4) March 2016 (4) February 2016 (4) January 2016 (2) December 2015 (3) November 2015 (4) October 2015 (3) August 2015 (2) July 2015 (1) June 2015 (1) May 2015 (3) April 2015 (1) March 2015 (2) January 2015 (1) December 2014 (2) November 2014 (2) October 2014 (9) August 2014 (3) July 2014 (2) June 2014 (3) May 2014 (2) April 2014 (4) March 2014 (6) February 2014 (3) January 2014 (5) December 2013 (1) November 2013 (3) October 2013 (4) September 2013 (5) August 2013 (6) July 2013 (2) June 2013 (3) May 2013 (2) April 2013 (5) March 2013 (3) February 2013 (2) January 2013 (4) December 2012 (3) November 2012 (1) October 2012 (4) September 2012 (5) August 2012 (4) July 2012 (3) June 2012 (4) May 2012 (5) April 2012 (4) March 2012 (4) February 2012 (5) January 2012 (4) December 2011 (3) November 2011 (2) October 2011 (5) September 2011 (4) August 2011 (5) July 2011 (3) June 2011 (4) May 2011 (8) April 2011 (7) March 2011 (5) February 2011 (26) January 2011 (4) December 2010 (4) November 2010 (4) October 2010 (7) September 2010 (7) August 2010 (8) July 2010 (6) June 2010 (9) May 2010 (11) April 2010 (7) March 2010 (3) February 2010 (8) January 2010 (3) December 2009 (6) November 2009 (3)
Preservation & Conservation On The Web
Preservation website
Conservation website
Adopt-a-Book Program
Duke Libraries Magazine
Duke Libraries
Support Duke Libraries
AIC Blog
Devil's Tale (Rubenstein Library)
Duke Libraries Blog
Jeff Peachey
Library Preservation 2
Parks Library Preservation
PCAN (many more blog links)
Preservation Underground

redpajama_set_name: RedPajamaCommonCrawl


About Us Pension Appraisers Online, Inc.
PensionAppraisalDesk™ is owned by Pension Appraisers Online, Inc. which is a sister company of Pension Appraisers, Inc.. Pension Appraisers, Inc. is a national company specializing in valuing and distributing retirement benefits in cases of divorce. Established in 1989, Pension Appraisers, Inc. has valued over 30,000 defined benefit and defined contribution pension plans and assisted attorneys and individuals in drafting over 20,000 Qualified Domestic Relations Orders (QDRO) and Domestic Relations Orders (DRO).
With the development of our smart question/answer and documentation web-based technology and the intuitive participation from our pension analysts, we have been able to create a state-of-the-art, low-cost, and effective solution valuing retirement accounts for equitable distribution in divorce. We take as much pride in this innovative online approach as we do in delivering valuable and recognizable benefits to our customers with a focus on an end product that supersedes what is available anywhere else.
Need Your Retirement Account Spilt?


text:
Q: How to watch a DVD video with external subtitles in Linux? There are video players in Windows that can use external subtitles when playing a DVD movie, but are there in Linux too?
(MPC-HC and PotPlayer are the most obvious solutions for this in Windows. I was not able to instal them in Linux under Wine/Playonlinux.)
VLC does seem to work, but with some limitations. At least sometimes what happens is this: it loads the subtitle but from time to time during playback when they should appear they do so for too short a time or not at all; after seeking back or forth they disappear completely and adding them again doesn't work then, I have to restart the movie. So, the idea is to avoid seeking. Changing video output doesn't change this.
Kaffeine can play the DVD movie very well, but there is no obvious way to add an external subtitle to it. The same for Xine, KMPlayer, Dragon, Parole..

A: MPV has no menus for DVD, but it works very well. To start the DVD, access the DVD folders and drag&drop the VIDEO_TS folder onto the MPV's window. Then do the same with the subtitle file.

From my experience, in this case the main movie is started directly.
To do that with a command, use something like
mpv dvd://
or
mpv /media/username/*/VIDEO_TS
To get the correct path for that, mount the DVD, copy/paste the VIDEO_TS path and replace the variable DVD movie name with *, as indicated under this question.
That command can be used in a panel launcher, .desktop file or shortcut to start playing the DVD with one click.
An example of  .desktop launcher:
[Desktop Entry]
Actions=Help;Bindings;Scripts;About
Categories=AudioVideo;Audio;Video;Player;TV;
Exec=mpv /media/username/*/VIDEO_TS
Icon=/home/cip/MY/ico/mpv_dvd.png
MimeType=video/x-theora+ogg;video/x-theora+ogg;video/x-ogm+ogg;video/x-msvideo;video/x-msvideo;video/x-msvideo;video/x-ms-wmv;video/x-ms-asf;video/x-matroska;video/x-flv;video/x-flv;video/x-flic;video/webm;video/vnd.rn-realvideo;video/quicktime;video/ogg;video/mpeg;video/mpeg;video/mpeg;video/mp4;video/mp2t;audio/x-wavpack;audio/x-wav;audio/x-wav;audio/x-vorbis+ogg;audio/x-tta;audio/x-scpls;audio/x-musepack;audio/x-ms-wma;audio/x-ms-asx;audio/x-mpegurl;audio/x-ape;audio/vnd.rn-realaudio;audio/vnd.rn-realaudio;audio/mpeg;audio/mpeg;audio/mpeg;audio/mpeg;audio/mp4;audio/mp4;audio/mp2;audio/mp2;audio/flac;audio/flac;audio/AMR;audio/ac3;audio/aac;application/vnd.rn-realmedia;application/smil;application/sdp;application/ogg;application/ogg;
Name[en_US]=Play DVD in mpv Media Player
Name=Play DVD in mpv Media Player
StartupNotify=true
Terminal=false
Type=Application

Replace username with yours and the icon path. You can use this icon :)

or this

When the player is started with the command mpv /dev/sr0, it will play and seek through all included streams including menus as if in a single file (no DVD menu support).

SMPlayer

Does the job of adding external subtitles to DVDs. No DVD menus by default, although this can be enabled as an experimental feature under Options -Preferences - Drives. (DVD menus seem to work if mplayer is selected as multimedia engine but not with the more recent mpv.) When the menus are not enabled the main movie is shown in playlist as one separate entry and is easy to identify and add a subtitle to it.
So, start playing the item that corresponds to the movie and then add the external subtitle: it should work very well.

External dvd subtitles usually look better than the ones on the dvd.

A: Typically I use VLC for watching movies with external subtitle files. Occasionally the timings in the file are a little off, but it has always been an issue with the files, not VLC for me.
What to you mean with "loses it after a while"? The subtitles stop displaying, or they move out of sync with the video?


❶We partner with Say Media to deliver ad campaigns on our sites.
We collected the most unhacked and powerful ideas to turn the average piece of writing into a compelling research paper. Discover how to choose suitable and interesting research topics with our help. Or if you are a lazy student - use our essay writing service. If you are allowed to freely choose what to write an essay on your own, use the opportunity to create something unique. Write down the list of your interests and break down every idea into small certain topics.
A list will save you here again. If a topic is a backbone of your paper, then information is its essential body element. Before settling on the research topic ideas, you have to make sure there is enough information for you to model the main body of your paper. It is recommended to use textbooks both online and offline , articles and other sources don't forget to use plagiarism checker that deal with scientific explanations and review your topic from the most debatable side.
When writing a research paper on a psychology-related domain your aim is to make those complex ideas filled with specific terms, more accessible to the broad audience and, at the same time, add your own experience in the field.
It goes without saying that any fact or a new piece of info introduced in your paper has to be supported by evidence and when it comes to research papers, practice really does make it perfect. One thing that could help you with your task is learning how to write an abstract for your research paper. We will go through the basics of creating a psychology research paper and also a variety of topics you can choose for your next assignment. Composing such a paper is not such a draconic task as you may think.
But, just like anything in life, you should do some research of your own and make some guidelines to follow. Here are some of them:. When it comes to psychology research papers there are two main types. You can either go for an empirical paper for your assignment , or you can take the literature review approach instead. The difference is that empirical papers must have a lot of details on research, experiments and provable facts related to the paper.
Opposed to the empirical approach, the literature review method is often a tool you turn to rather summarize the empirical activity someone else. When your assignment is a literature review , you are usually indicated with the maximum studies you can include in your work. This number is anywhere around five or twenty studies. The title of your assignment automatically determines the research you will have to do in order to be able to write the paper.
Most of the students consider this part to be the most exciting one. You have to look all over the internet and your library to find reliable sources of inspiration and fact-checked examples you can include in the paper.
Jun 30, · Great Psychology Essay Topic ideas for papers, speeches or blogs. Includes research links to authoritative ivujoz.tks: 4. Psychology is a very vast field and offers a huge range of sub-fields, such as clinical psychology, developmental psychology, child psychology, industrial psychology and social psychology. If you are a student of psychology, you would be required to select a particular topic for the final research paper.
Writing a research paper in psychology involves a lot of reading as well as field work -- therefore, the topic chosen becomes utmost important. Most sub-fields of psychology are broad, like the main subject, and research on a vast topic can become problematic. Hence, it is necessary to opt for a topic that is narrow and concise. The purpose of a psychology research paper, just like any kind of scientific writing, is to get the audience up to date about developments in the psychology field. Anything from new theories, experiments, ideas or arguments can fit in such a paper.


Life has been very busy for me lately. The challenge has been to not revert to old habits. The good is I maintain every day thus far with the physical exercise. I am doing somewhat better with my actual food intake. I am not where I desire to be but getting closer.
I am able to maintain positive thoughts although I blog about current and political events. My family continues to be my greatest source of stress. As I work to get a new business of the ground. I continue to seek financing to get my house ready for habitation. Moving into my own home will reduce much of my environmental stress( my family).
One big piece of news that has made a huge difference in my life is a new bra. Confession session alert. I have been buying bras based on a measurement I got many years ago after the birth of my 13 year old. Reviewing some of the videos I have posted I had to ask myself, WTL!?!?? I noticed my midsection appeared larger than what I saw in the mirror. The problem turned out to be my mammary glands resting in my lap. My new measurement confirmed what I had denied for years, I have huge boobies. I am not the C cup of my dreams. However having the correct cup size makes a world of difference. I encourage every woman to have measurements taken at least once a year.
Ok I have a few more moments on the bike. More vids later.


text:
ARGUS CYCLE TOUR 2004
I was in Cape Town, South Africa again in March, to compete in the Argus Cycle Tour. It is traditionally held on the second Sunday in March, and is limited to 35 000 entrants. It is the world's largest individually timed Cycle race.
I'd competed in my first race in 1997 on a mountain bike, and managed to compete in every second event. Normally my preparation wasn't very good, usually getting on a bike about 2 weeks before! It's a fun event, although participants are seeded. The first group starts at 06h15, and consists of pros. A group of 6-700 competitors starts every 5 minutes thereafter, until 08h25, after which they start every 4 minutes until the last group starts at 10h21. The atmosphere is very jovial, and some people dress up in fancy dress similar to the London Marathon.
I was lucky to be starting at 07h35, which meant that I should be finished before midday, and the really hot part of the day. I was planning to finish the event in around 3 hours 30 min, although the route had changed, after a mountain pass has been reopened, which allowed the route to pass alone the scenic sea-side road of Chapman's' Peak.
Roads are fully closed for the event, and as the route causes parts of the city to be cut off to through-traffic, there are many thousands of residents watching the event along the route. The weather forecast predicted a gale-force south easterly again, which would have meant head winds along the first half of the route, however there was no more than a gentle breeze. Drafting is very important along the main road leading to Cape Point, and I managed to catch up to a few groups by some hard riding. I was fitter this year than any other, despite tapering for the race and flying to South Africa in the week before. The hills didn't seem so bad as a result, although the heat was a little debilitating. I was happy to finish in 3 hour 31 min. In position 5745 ! A friend finished 5 minutes after me, but was 920 places down. During that time, there was an average of 1000 people finishing every 5 minutes!!
The winner of the event was Antonio Salamone who finished in 2:32, while the person on the course the longest finished in 6:58, in position 30366. (as far as I could see, as the results are in alphabetical order, and take up 21 pages of the local broadsheet newspaper!) The first 875 finishers completed the course within 3 hours.
More information: www.cycletour.co.za


large datasets and provide realistic voice synthesis.
Vail Systems is looking for summer interns who are enrolled in a Ph.D. program in computer science, computer engineering, or related programs to work with us on some of these challenges. The student must be conducting research in NLP and should be able to understand, codify and extract meaning from multiple communication modalities (speech, text), and build new or improve existing models in affective computing using state of the art machine learning techniques. The student will work with a team of researchers to gain insight from trying new approaches, and will work with practitioners to transition the research to a proof-of-concept.


Many thanks for your hard work, persistence, patience, creativity, and a great end product.
We're working on this website for a remote, unfunded landcare group. They are doing an awesome job responding as a community to the onslaught of noxious weeds and unseasonal fires, but they needed a way to share GPS data and local know-how.
Online GPS mapping solutions can be expensive and difficult, but we put Umap, OSM and Cred Frontend Forms to work creating a simple solution for their unique needs. The site is kept private for the groups members, but you're welcome to get in touch if you're interested to see how we've done it.


text:
Home / News / Articles / When Immigration Becomes a Tool in Intimate Partner Violence
When Immigration Becomes a Tool in Intimate Partner Violence
Published by: Victoria Taylor
Many people are unaware that immigration abuse can be a tool of gender-based violence.
Imagine being 21, prohibited from legally working, pregnant, and about to be deported. What other choice did I have but to marry him?
I emigrated to the United States from the United Kingdom (a predominately white, wealthy country that the United States favors immigration from) at the age of 15. My family had no idea of the lengthy, exorbitant, unforgiving process we were going to go through over the next 23 years. To avoid deportation my siblings and I felt we needed to marry whomever we were dating at the age of 21.
Immigration Abuse is a term used in gender-based violence to describe the use of the immigration system as a tool of power and control over an intimate partner. An immigrant victim's immigration status is most often tied directly to their abusive partner's status. Typical tactics of immigration abuse can be anything from withholding information regarding the immigration status of a victim, threatening to cause deportation, threatening to deny access to seeing children, destroying or tampering with immigration documentation, and restricting access to finances to pay for costly immigration fees.
There are many avenues available for survivors to attain some form of immigration relief. They include the battered spouse waiver, self-petitioning under the Violence Against Women Act (VAWA), U-Visas, and T-Visas. The VAWA self-petition is one tool available to immigrant crime victims to decouple their immigration status from their abuser. Immigrants who are cooperating with the prosecution of the crime they experienced may apply for a U-Visa. The U-Visa has a cap of only 10,000 visas granted per year. This cap is quickly satisfied yearly and there is a lengthy waiting list.
During the U-Visa waiting period, victims often have little choice other than to stay with their abuser while they go through the immigration process. Lack of legal immigration status can limit access to public benefits, prohibit people from legally working (illegal work affects visa potential), disallow scholarship opportunities, and prohibit the ability to access a driver's license. The restriction of a person's independence through this process directly contributes to increased power and control from abusers.
In the United States, it takes an average of 10-20 years just to receive a Green Card. During that time there are heavy restrictions on what an immigrant is allowed to participate in as a non-citizen of this country. It was illegal for me to work, I was ineligible for any school scholarships, and I was unable to qualify for any student loans. I am white and English-speaking. Consider immigrants who do not speak the language or understand the legal system, who are undocumented, who are not a part of dominant culture and who are fleeing political or gang violence. Immigrant victims can be so restrained by the immigration system the prospect of leaving a violent relationship can be understandably unattainable.
Awareness of the barriers faced by immigrant survivors is crucial to supporting immigration reform that will be humane and effective. ASISTA advocates for justice and dignity for immigrant survivors of intimate partner violence (IPV). Kirsten Rambo, PhD. the Executive Director of ASISTA reminds us that "there are survivors in every group of immigrants, so when we take in news about immigration, we should apply a lens of focus on how this is impacting survivors of IPV to better understand the isolation and disempowerment they may be going through."
For ways to support policy and political efforts check out ImmigrantSurvivors.org
Visit ImmigrantSurvivors.org
BWJP stands with immigrant survivors and all survivors of gender-based violence.
#CelebrateImmigrants #immigrationabuse #domesticviolence
TAGS: #Immigrants #Protection Orders
Published by: Victoria Taylor Many people are unaware that immigration abuse can be a tool of gender-based violence. Imagine being…


text:
Особлива думка () — український радянський художній фільм 1967 року режисера Віктора Жиліна.

Сюжет
На березі моря знайдено труп чоловіка. Молодий слідчий Ковальов встановлює особу вбитого і його переслідувача — колишнього провокатора, який видав гітлерівцям групу підпільників. На одному з допитів злочинець впізнає в одному з працівників прокуратури колишнього обер-лейтенанта СС і починає його шантажувати…

У ролях

 Паулі Рінне
 Пантелеймон Кримов
 Юрій Дубровін
 Юхим Копелян
 Зінаїда Сорочинська
 Геннадій Кринкін
 Ельза Леждей
 Геннадій Воропаєв
 Євген Котов
 Лев Золотухін
 Михайло Пресняков

Творча група
 Сценарій: Іван Менджерицький
 Режисер: Віктор Жилін
 Оператор: Леонід Бурлака
 Композитор: Богдан Троцюк

Посилання
 Особлива думка (1967)

Фільми СРСР 1967
Фільми Одеської кіностудії
Фільми Української РСР
Фільми Віктора Жиліна
Детективні фільми СРСР

redpajama_set_name: RedPajamaWikipedia


text:
OES Directory
Title I Commitment
2020 Return to Learn Plan
2014 Bond & Mill Levy
Community In Action Parent Group (CIA)
Vision 2017-2022
District 49 Earns RMPEx Foothills Award
District 49 earned the Rocky Mountain Performance Excellence Foothills Award at the 2015 RMPEx Quest for Excellence conference May 18 in Denver.
RMPEx, one of more than 30 Baldrige state programs in the United States, helps organizations improve performance. The program works with leaders in businesses, schools, healthcare organizations, as well as government and nonprofit agencies.
"Receipt of the Foothills award serves as confirmation that District 49 has the foundational processes in place to successfully apply the Baldrige Framework as a path to achievement of performance excellence," said Jim Walker, RMPEx executive director.
The approaches used by RMPEx are based on the National Institute of Standards and Technology Baldrige Framework for Excellence. Nationally, the program recognizes best-in-class organizations and honors them with the only U.S. presidential award for performance excellence.
Peter Hilts, District 49 chief education officer says while the award is a symbol of hard work that has already been done, the district is better equipped for its journey ahead.
"By benchmarking our processes against high-performing enterprises in education and other industries, we can see more clearly where we are already excellent and where we have the most need to improve," Hilts said.
Overseen by the U.S. Department of Commerce, the Baldrige Framework is a proven best-practice program that evaluates organizations in seven areas: leadership; strategy; customers; measurement, analysis and knowledge management; workforce; operations; and results.
"Receipt of the RMPEx Foothills Award is a demonstration that District 49 has passed the first milestone on their journey to excellence," Walker said.
Future Work
"From the Board of Education to the students at their desks in the classroom, we are committed to continuous improvement through learning, working and leading," Hilts said. "Primary literacy and individualized academic pathways for secondary students are our educational focus."
"We're measuring the effectiveness of our budget and financial support processes," said Brett Ridgway, chief business officer. "We're refining them to maximize the investment our community has made in the education of the next generation, getting more money and decision making to the classroom."
"Our facilities, nutrition and transportation teams are using data to measure our efficiency like never before," said Jack Bay, chief operations officer. "Every member of the District 49 family is on this journey together."
"I am impressed with the approaches that District 49 is taking to address the varied needs of its students," Walker said. "I am excited that D49 has chosen to partner with RMPEx in its improvement efforts and am confident that students are already benefitting from the district's Baldrige journey."
Matt Meister
mmeister@d49.org
6275 Bridlespur Avenue


text:
Q: giving effects to buttons in vb.net
Image shows the buttons on my UI in vb.net
All these buttons are having background images. Now what i want is these buttons be shown as inactive when actions corresponding to them are not available so I am making them cmd.enable = false but still on UI there is no visual effect of this disabling them on these buttons. They keep looking same as in enabled mode. So how to give effect of disabled state to these buttons.
In the same way i want effect to be visible when mouse is hovered over these buttons and buttons are clicked

A: They don't look like buttons at all, it looks like a row of images.  Use a real Button or a ToolStrip with ToolStripButtons, set their Image property.  When you set their Enabled property to false then they automatically remove all color from the image, making it look disabled.


text:
Murau est une ville autrichienne, chef-lieu du district de Murau en Styrie.

Géographie

La ville est située dans la région de Haute-Styrie, dans la haute vallée de la rivière Mur séparant les Niedere Tauern au nord et les Alpes de Gurktal au sud. Dans le cadre de la réforme des communes de Styrie, avec effet au , le territoire communal comprend également les anciennes municipalités de Laßnitz, Stolzalpe et Triebendorf.

L'économie de Murau dépend en grande partie du tourisme, notamment dans les stations de ski voisines à Kreischberg et à Grebenzen.

Histoire
La vallée de la Mur était déjà peuplée à l'âge du bronze. On a supposé, sur la base des indications de la table de Peutinger, que c'est l'endroit de l'ancienne ville de Noreia, capitale du royaume celtique de Norique sur la voie de Virunum à Iuvavum (Salzbourg) ; néanmoins, il n'existait aucune preuve de cette thèse.

Le lieu de Murowe (« plaine sur la Mur »), situé dans le duché de Styrie, fut mentionné pour la première fois dans un acte de l'an 1250. Il a reçu sa reconnaissance officielle en tant que ville en 1298. Au , les domaines étaient entre les mains de la noble famille de Liechtenstein (qui n'est pas apparentée à la maison de Liechtenstein autrichienne), dont le chanteur et poète Ulrich von Liechtenstein († 1275). Il fit construire le château d'Obermurau au-dessus de la Mur ; le fort fut détruit pendant les luttes entre Rodolphe de Habsbourg et Ottokar II de Bohême en 1276-1278, puis reconstruit.

En 1617, le château, centre de la seigneurie de Murau s'étendant jusqu'aux limites de l'archevêché de Salzbourg à l'ouest, fut acquise par la maison de Schwarzenberg. La ville est également connue pour son défilé de Samson attesté depuis 1746.

Personnalités liées à la ville
 Willi Egger (1932-2008), coureur du combiné nordique et sauteur à ski ;
 Brunner & Brunner Karl (né en 1955) et Johann (né en 1958), duo de schlager ;
 Klaus Ofner (né en 1968), spécialiste du combiné nordique.

Jumelage

Références

Commune en Styrie
Site autrichien de compétition de combiné nordique


Miles before you reach this retired giant — you can see Big Brutus on the horizon south of West Mineral, Kansas. Standing beside it makes one aware of how fragile he or she is.
Bucyrus Erie model 1850B second largest electric shovel in the world 16 stories tall (160 feet) weight 11 million pounds boom 150 feet long dipper capacity 90 cu. yds. (by heaping, 150 tons — enough to fill three railroad cars.) maximum speed .22 MPH cost $6.5 million (in 1962) There is more to Big Brutus than cold steel and long shadows falling across the Mined Land Wildlife Area. Big Brutus is not just a symbol of the past, but an eternal tribute to the mining heritage of Southeast Kansas and to miners all across this nation who toiled to support their families.
The Center also houses comfort facilities, including hot showers to meet the needs of visitors and campers alike. Along with primitive camping and space for self-contained RV's, there are ten water/electrical hook-ups and a dump station. Picnic tables dot the grounds and a shelter is there for gatherings of all kinds.
There are exhibits, ever changing displays and photographs in both the Visitors Center and Big Brutus to enhance the colorful history and heritage of this region and this bucket wielding machine and don't miss a self-guided tour.
There have been weddings at Big Brutus as well as receptions, private parties, group tours, school field trips, picnics and family reunions.
Opportunities for wildlife activities like photography abound in this scenic gateway to Branson in the Northwest Ozarks. Excellent fishing for bass and other game fish in the well-stocked strip pits. And don't forget hunting for quail, turkey, small game and deer. The Mined Land Wildlife Areas (15,000 acres) offer grasslands, woodlots and waterways that will stir the senses and bring a tingling rush with each splash of water or flurry and flutter in the shadows and nodding grasses.