text:
'''Large number arithmetic optimized for KS cores.'''

from __future__ import division  # Use // for integer division.
import os     # Used for os.environ.
import sys    # Used to smooth over the range / xrange issue.
# Python 3 doesn't have xrange, and range behaves like xrange.
if sys.version_info >= (3,):
    xrange = range

if os.environ.get('KS_DEBUG') and os.environ.get('KS_DEBUG') != 'false':
  from ks_primitives import *
else:
  from ks_primitives_unchecked import *

class BigNum(object):
  '''Large number implemented as a little-endian array of Bytes.'''

  def __init__(self, digits, size = None, no_copy = False):
    '''Creates a BigNum from a sequence of digits.

    Args:
      digits: the Bytes used to populate the BigNum
      size: if set, the BigNum will only use the first "size" elements of digits
      no_copy: uses the "digits" argument as the backing store for BigNum, if
               appropriate (meant for internal use inside BigNum)
    '''
    if size is None:
      size = len(digits)
    elif size < 0:
      raise ValueError('BigNums cannot hold a negative amount of digits')
    if size == 0:
      size = 1
    if no_copy and len(digits) == size:
      self.d = digits
    else:
      self.d = digits[0:size]
    while len(self.d) < size:
      self.d.append(Byte.zero())

    # Used by the Newton-Raphson division code.
    self.__inverse = None
    self.__inverse_precision = None

  @staticmethod
  def zero(size = 1):
    '''BigNum representing the number 0 (zero).'''
    return BigNum([Byte.zero()] * size, size, True)

  @staticmethod
  def one(size = 1):
    '''BigNum representing the number 1 (one).'''
    digits = [Byte.zero()] * size
    digits[0] = Byte.one()
    return BigNum(digits, size, True)

  @staticmethod
  def from_hex(hex_string):
    '''BigNum representing the given hexadecimal number.

    Args:
      hex_string: string containing the desired number in hexadecimal; the
                  allowed digits are 0-9, A-F, a-f
    '''
    digits = []
    for i in xrange(len(hex_string), 0, -2):
      if i == 1:
        byte_string = '0' + hex_string[0]
      else:
        byte_string = hex_string[(i - 2):i]
      digits.append(Byte.from_hex(byte_string))
    return BigNum(digits)

  @staticmethod
  def h(hex_string):
    '''Shorthand for from_hex(hex_string).'''
    return BigNum.from_hex(hex_string)

  def hex(self):
    '''Hexadecimal string representing this BigNum.

    This method does not normalize the BigNum, because it is used during
    debugging.
    '''
    start = len(self.d) - 1
    while start > 0 and self.d[start] == Byte.zero():
      start -= 1
    return ''.join([self.d[i].hex() for i in xrange(start, -1, -1)])

  def __eq__(self, other):
    '''== for BigNums.

    Comparing BigNums normalizes them.'''
    if not isinstance(other, BigNum):
      return False

    self.normalize()
    other.normalize()
    return self.d == other.d

  def __ne__(self, other):
    '''!= for BigNums.

    Comparing BigNums normalizes them.'''
    if not isinstance(other, BigNum):
      return True

    self.normalize()
    other.normalize()
    return self.d != other.d

  def __lt__(self, other):
    '''< for BigNums.

    Comparing BigNums normalizes them.'''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be compared to other BigNums.

    self.normalize()
    other.normalize()
    if len(self.d) != len(other.d):
      return len(self.d) < len(other.d)

    for i in xrange(len(self.d) - 1, -1, -1):
      if self.d[i] != other.d[i]:
        return self.d[i] < other.d[i]
    return False

  def __le__(self, other):
    '''<= for BigNums.

    Comparing BigNums normalizes them.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be compared to other BigNums.

    self.normalize()
    other.normalize()
    if len(self.d) != len(other.d):
      return len(self.d) < len(other.d)

    for i in xrange(len(self.d) - 1, -1, -1):
      if self.d[i] != other.d[i]:
        return self.d[i] < other.d[i]
    return True

  def __gt__(self, other):
    '''> for BigNums.

    Comparing BigNums normalizes them.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be compared to other BigNums.
    return not self.__le__(other)

  def __ge__(self, other):
    '''>= for BigNums.

    Comparing BigNums normalizes them.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be compared to other BigNums.
    return not self.__lt__(other)

  def __lshift__(self, digits):
    '''This BigNum, with "digits" 0 digits appended at the end.

    Shifting to the left multiplies the BigNum by 256^digits.
    '''
    new_digits = [Byte.zero()] * digits
    new_digits.extend(self.d)
    return BigNum(new_digits, None, True)

  def __rshift__(self, digits):
    '''This BigNum, without the last "digits" digits.

    Shifting to the right divides the BigNum by 256^digits.
    '''
    if digits >= len(self.d):
      return BigNum.zero()
    return BigNum(self.d[digits:], None, True)

  def __add__(self, other):
    '''+ for BigNums.

    Shifting to the left has the effect of multiplying the BigNum by 256^digits.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be added to BigNums.

    # One would think that it'd be faster to have a for loop for the digits
    # between 0 and min(len(self.d), len(other.d)), and another loop between
    # min(...) and max(...), so the ifs would be eliminated.
    # Turns out pypy's JITter can eliminate the range checks on list accesses
    # for the code below, so this method ends up being significantly faster than
    # the one mentioned above, which intuitively seems better.

    result = BigNum.zero(1 + max(len(self.d), len(other.d)))
    carry = Byte.zero()
    for i in xrange(0, len(result.d)):
      if i < len(self.d):
        a = self.d[i] + carry
      else:
        a = carry.word()
      if i < len(other.d):
        b = other.d[i].word()
      else:
        b = Word.zero()
      word = a + b
      result.d[i] = word.lsb()
      carry = word.msb()
    return result.normalize()

  def __sub__(self, other):
    '''- for BigNums.

    Subtraction is done using 2s complement.

    Subtracting numbers does not normalize them. However, the result is
    normalized.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be subtracted from BigNums.
    result = BigNum.zero(max(len(self.d), len(other.d)))
    carry = Byte.zero()
    for i in xrange(0, len(result.d)):
      if i < len(self.d):
        a = self.d[i].word()
      else:
        a = Word.zero()
      if i < len(other.d):
        b = other.d[i] + carry
      else:
        b = carry.word()
      word = a - b
      result.d[i] = word.lsb()
      if a < b:
        carry = Byte.one()
      else:
        carry = Byte.zero()
    return result.normalize()

  def __mul__(self, other):
    '''* for BigNums.

    Multiplying numbers does not normalize them. However, the result is
    normalized.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be multiplied by BigNums.
    if len(self.d) <= 64 or len(other.d) <= 64:
      return self.slow_mul(other)
    return self.fast_mul(other)

  def slow_mul(self, other):
    '''
    Slow method for multiplying two numbers w/ good constant factors.
    '''
    return self.fast_mul(other)

  def fast_mul(self, other):
    '''
    Asymptotically fast method for multiplying two numbers.
    '''
    in_digits = max(len(self.d), len(other.d))
    if in_digits == 1:
      product = self.d[0] * other.d[0]
      return BigNum([product.lsb(), product.msb()], 2, True)
    split = in_digits // 2
    self_low = BigNum(self.d[:split], None, True)
    self_high = BigNum(self.d[split:], None, True)
    other_low = BigNum(other.d[:split], None, True)
    other_high = BigNum(other.d[split:], None, True)

    result_high_high = self_high * other_high
    result_low = self_low * other_low
    result_high = (self_low + self_high) * (other_low + other_high) - \
                  (result_high_high + result_low)
    return ((result_high_high << (2 * split)) + (result_high << split) +
            result_low).normalize()

  def __floordiv__(self, other):
    '''/ for BigNums.

    Dividing numbers normalizes them. The result is also normalized.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be divided by other BigNums.
    return self.__divmod__(other)[0]

  def __mod__(self, other):
    '''% for BigNums.

    Multiplying numbers does not normalize them. However, the result is
    normalized.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be divided by other BigNums.
    return self.__divmod__(other)[1]

  def __divmod__(self, other):
    '''divmod() for BigNums.

    Dividing numbers normalizes them. The result is also normalized.
    '''
    if not isinstance(other, BigNum):
      return NotImplemented  # BigNums can only be divided by other BigNums.
    self.normalize()
    other.normalize()
    if len(self.d) <= 256 or len(other.d) <= 256:
      return self.slow_divmod(other)
    return self.fast_divmod(other)

  def slow_divmod(self, other):
    '''
    Slow method for dividing two numbers w/ good constant factors.
    '''
    return self.fast_divmod(other)

  def fast_divmod(self, other):
    '''
    Asymptotically fast method for dividing two numbers.
    '''
    # Special-case 1 so we don't have to deal with its inverse.
    if len(other.d) == 1 and other.d[0] == Byte.one():
      return (self, BigNum.zero())

    if other.__inverse is None:
      # First approximation: the inverse of the first digit in the divisor + 1,
      # because 1 / 2xx is <= 1/200 and > 1/300.
      base = Word.from_bytes(Byte.one(), Byte.zero())
      msb_plus = (other.d[-1] + Byte.one()).lsb()
      if msb_plus == Byte.zero():
        msb_inverse = (base - Word.one()).lsb()
        other.__inverse_precision = len(other.d) + 1
      else:
        msb_inverse = base // msb_plus
        other.__inverse_precision = len(other.d)
      other.__inverse = BigNum([msb_inverse], 1, True)

    bn_one = BigNum.one()

    while True:
      # Division using other's multiplicative inverse.
      quotient = (self * other.__inverse) >> other.__inverse_precision
      product = other * quotient
      if product > self:
        product -= other
        quotient -= bn_one
      if product <= self:
        remainder = self - product
        if remainder >= other:
          remainder -= other
          quotient += bn_one
        if remainder < other:
          return (quotient, remainder)

      # other needs a better multiplicative inverse approximation.
      old_inverse = other.__inverse
      old_precision = other.__inverse_precision
      other.__inverse = ((old_inverse + old_inverse) << old_precision) - \
          (other * old_inverse * old_inverse)
      other.__inverse.normalize()
      other.__inverse_precision *= 2
      # Trim zero digits at the end, they don't help.
      zero_digits = 0
      while other.__inverse.d[zero_digits] == Byte.zero():
        zero_digits += 1
      if zero_digits > 0:
        other.__inverse = other.__inverse >> zero_digits
        other.__inverse_precision -= zero_digits

  def powmod(self, exponent, modulus):
    '''Modular ^.

    Args:
      exponent: the exponent that this number will be raised to
      modulus: the modulus

    Returns (self ^ exponent) mod modulus.
    '''
    multiplier = BigNum(self.d)
    result = BigNum.one()
    exp = BigNum(exponent.d)
    exp.normalize()
    two = (Byte.one() + Byte.one()).lsb()
    for i in xrange(len(exp.d)):
      mask = Byte.one()
      for j in xrange(0, 8):
        if (exp.d[i] & mask) != Byte.zero():
          result = (result * multiplier) % modulus
        mask = (mask * two).lsb()
        multiplier = (multiplier * multiplier) % modulus
    return result

  def __str__(self):
    '''Debugging help: returns the BigNum formatted as "0x????...".'''
    return '0x' + self.hex()

  def __repr__(self):
    '''Debugging help: returns an expression that can create this BigNum.'''
    return 'BigNum.h("' + self.hex() + '", ' + str(len(self.d)) + ')'

  def normalize(self):
    '''Removes all the trailing 0 (zero) digits in this number.

    Returns self, for easy call chaining.
    '''
    while len(self.d) > 1 and self.d[-1] == Byte.zero():
      self.d.pop()
    return self

  def is_normalized(self):
    '''False if the number has at least one trailing 0 (zero) digit.'''
    return len(self.d) == 1 or self.d[-1] != Byte.zero()

redpajama_set_name: RedPajamaGithub


text:
Jamaicans for Justice ist eine jamaikanische Nichtregierungsorganisation mit Sitz in Kingston, die sich für die Stärkung der Bürger- und Menschenrechte in Jamaika einsetzt. Sie wurde 1999 von der Ärztin Carolyn Gomes gegründet und gilt als Jamaikas größte Menschenrechtsorganisation.

Ziele und Arbeitsweise
Jamaicans for Justice beruft sich auf die Allgemeine Erklärung der Menschenrechte. Ihre zentralen Forderungen sind die Gleichbehandlung aller Bürger vor jamaikanischen Gerichten, der Abbau von Korruption, die Eindämmung von unrechtmäßiger Polizeigewalt und die Beseitigung von Diskriminierung. Eine zentrale Rolle spielen dabei die Gleichberechtigung von Mann und Frau und die Entkriminalisierung von Homosexualität.

Jamaicans for Justice bietet eine Rechtsberatung und gerichtlichen Beistand für Opfer von staatlicher Gewalt oder Ungerechtigkeit wie unrechtmäßigen Festnahmen, unfairen Gerichtsprozessen und gewalttätigen Übergriffen durch Sicherheitskräfte an. Durch ein Bildungsprogramm an Schulen will die Organisation das Bewusstsein für Menschenrechte stärken. Ein spezielles Training bietet sie für Anwärter auf den Polizeidienst an. Außerdem klärt sie mit dem wöchentlichen Radioprogramm The Community Lawyer über Bürgerrechtsfragen auf. Jamaicans for Justice betreibt außerdem Lobbyarbeit bei der jamaikanischen Regierung.

Die Vereinigung arbeitet mit internationalen Organisationen zusammen, darunter Amnesty International und der Interamerikanischen Kommission für Menschenrechte.

Zur Förderung eines gesellschaftlichen Bewusstseins für Menschenrechte in Jamaika, schloss die Organisation am 12. April 2012 mit der Bundesrepublik Deutschland, vertreten durch den damaligen deutschen Botschafter Josef Beck, einen Zuwendungsvertrag für das Projekt "Human Rights Awareness Marketing and Promotionals Campaign", an dem sich Deutschland mit einem Zuschuss von 62.000 Dollar beteiligte.

Auszeichnungen
Jamaicans for Justice wurde mit mehreren internationalen Preisen ausgezeichnet. 2002 erhielt die Organisation den Menschenrechtspreis der Stadt Weimar. Die Gründerin Carolyn Gomes wurde 2008 mit dem Menschenrechtspreis der Vereinten Nationen geehrt.

Weblinks
 Offizielle Website (englisch)
 Kanal von Jamaicans for Justice bei YouTube

Einzelnachweise

Polizeigewalt
Menschenrechtsorganisation
Bürgerrechtsorganisation
Menschenrechte in Jamaika
Politik (Jamaika)
Gegründet 1999
Organisation (Kingston, Jamaika)

redpajama_set_name: RedPajamaWikipedia


BrownWinick continued its charitable giving efforts during September 2017 by collecting items and raising money for Furry Friends Refuge.
BrownWinick attorneys and staff donated items and financial support for Furry Friends Refuge. The firm held a raffle drawing to celebrate the success of these efforts, and the lucky raffle winners received a pick from three (3) gift baskets.
Furry Friends Refuge is a non-profit, no-kill animal shelter with locations in Des Moines and West Des Moines. In addition to its shelter services, Furry Friends Refuge seeks to assist all animals with a variety of programs, including adoption, spray and neuter, community outreach and education. More information about Furry Friends Refuge can be found at their website – http://furryfriendsrefuge.org/.


Looking for Traditional Crowns in Madison? For an appointment at Plaza Boulevard Dental call our office today at 256-464-3556 or make an appointment today.
Your dentist at Plaza Boulevard Dental will evaluate whether a traditional crown is a good option for you. Call us at 256-464-3556.


By using a total scientific high-quality administration method, good quality and good faith, we gain good track record and occupied this subject for Little David Case Sealer , little david case sealer , siat case sealer , We're always looking forward to forming successful business relationships with new purchasers round the earth.
"The key to our success is ""Good Product Excellent, Reasonable Rate and Efficient Service"" for Little David Case Sealer , little david case sealer , siat case sealer , We are fully aware of our customer's needs. We provide high quality products competitive prices and the first class service. We would like to establish good business relationships as well as friendship with you in the near future.


A broken heater can mean misery for you and your family—especially during a chilly night or cold storm. If your heater breaks unexpectedly, don't worry. Ace Maintenance and Repair offers emergency services, so we'll come to help, no matter what time it is.
Visit the Reviews page to read what our clients have said about us. You'll see why people across Johnston, SC and all of the CSRA area choose Ace Maintenance and Repair to perform their heating repairs.
Your unit stops blowing warm air, even though the heat is on.
You hear strange noises coming from your heater, such as rumbling or clanking.
Your energy bill is unusually high or low.
Call Ace Maintenance and Repair today to get your heater fixed fast. We offer cleaning and maintenance plans to keep your warm air flowing whenever you need it.
Copyright © 2019 Ace Maintenance and Repair, all rights reserved.


The construction and layout of your luxury home can be planned out to a T so to speak. Every aspect of the design of your home is up to you, and of course, you're going to have an architect and team of contractors at your disposal. A general contractor is going to be in charge of carrying out your plans, but you are the boss. Keep that in mind as you work your budget and come up with the dream design for your new luxury home.
Innovation in architecture is what you're striving for overall. And when it comes to all of those luxury features you want to be included in the design, it doesn't mean you have to waste space. Maximizing the use of the space you have is going to help you afford those luxuries you desire. To bring this to fruition, you're going to need a team of design professionals that look at the construction of your home from many different angles.
There are always going to be options, and those options represent choices you have to make. Remember, you want the buck to stop with you. Be sure that you are always kept in the loop. To be clear, a solid plan and layout of your home, including all features, should be drawn up prior to anyone breaking ground, too. That being said, there are going to be tweaks that you make along the way.
You have to be a little flexible. You also want to be original. This is your dream luxury home you're talking about. So while you are looking at ideas based on other homes that have been constructed, be sure to personalize when it counts. It does need to count, however, as in terms of value. Too much personalization in terms of building a home can actually detract from the value of the property.
You want to look for those decisions that add value to your home in more than one way. In other words, you want your home to increase in value, and you want to find those features that are a value in terms of your budget and bank account. At the same time, you're talking luxury amenities, and that also means you need the best builders working for you.
Never forget that these builders are working for you. They are building your dream home, and that means you need to put them to the test before they ever lift a finger. Also, just like you need to be flexible, so do the home builders you choose. There might be changes you want to make along the way, and the contractors you're working with need to be accommodating.
There will be many contractors working for you, but there will be one general contractor in charge as mentioned. To be sure that everything is orchestrated properly in terms of the building of your dream home, but sure you know who your main contact is for sure. This is your source for any and all information, and this person is who you speak to when you have any questions or concerns yourself. A great place to go to find a top quality builder is https://gotohomebuilders.com, they will connect you with a top luxury home builder in your area. People tend to easily find them on Google, and they do their due diligence to connect you with the best of the best in your area, so you can feel comfortable when planning your dream home.
Building a luxury home is a big deal. While you have to get serious and down to business, you also want to have fun with this project. It's something you might only do once in a lifetime. You can't wait for the move-in day. Enjoy the ride, and take it one step at a time. Taking into account the tips that were mentioned will make for the best experience. From start to finish, you want a team of contractors that will make the right decisions and work efficiently, building your dream home on time and on budget.
Welcome to our blog, the Luxury Home Directory. This is going to be more of an information style website from everything like showcasing luxury homes to getting into detail of how they are designed and built. It won't be a place where you can browse luxury homes that are on the market.
We hope to bring you some valuable information and are open to your ideas of what to include. There's a lot of information out there and our goal is to make things very concise and to the point. Hope you like it here!


Kepware Technologies, a software development company focused on communications for automation, today announced the opening of its Tokyo, Japan office. While the company has a solid foothold in more than 100 countries through channel partners, this marks the first international location for Kepware.
For additional information about the Tokyo office, please visit www.kepware.com/japan.


text:
ORIGINAL FILMS
Mutt's Character Arc
We go on a crazy journey in the film, Indiana Jones and the Kingdom of the Crystal Skull, and so do the characters. One character that stands out to me the most is Henry "Mutt" Jones III.
Mutt is a fresh addition. He and Indiana support each other very well, just like two complimentary colors. A well-oiled wise man with a lot to offer and a strong-headed young man with intelligence, charm and potential. A professor paired with a school drop-out... a perfect match. They provide growth for each other, and their unfolding relationship is enjoyable and relatable.
Image via IMDb
As they interact in the story, we learn more about the likable Mutt. A very evident trait is that he carries a lot of bitterness. Much of it, I believe, being rooted in the fact that he didn't have a strong biological father figure growing up. Mutt tells Indy that Ox helped Marion raise him. And while that certainly was a benefit, it still doesn't fill the void of Mutt's absent "blood" father. We also learn that his stepfather, who Marion married early in Mutt's life, died in WWII when he was still a child. So, it's safe to say that he's had some ups and downs when it comes to male influentials.
I believe all this is partly tied to why he dropped out of so many schools and is now walking around with a tough guy mentality. The personal issues going on in his life started to affect how he saw the world. And now his choices have led to tension between Mutt and Marion. What better way to help fix this than to pair him with his actual father and go on a high-stakes journey across the world. Which leads me to my next point.
A little over halfway through the film, Mutt and Indy learn that they are father and son. That explains why they bonded so well in the first place, and why they can be at each other's necks sometimes. Mutt doesn't take the news too well at first. He acts in a bit of denial, resenting the fact that a "school teacher" is his father. Indy, though, quickly accepts it.
Clip via Movieclips
Clip via Jaegar Heathman
Regardless of this newfound revelation, the main plot still calls for their cooperation. Throughout the story, Mutt and Indiana continue to go through highs and lows together. You can't help but grow with someone when your lives are continually at stake. And when your life is continually at stake, you learn to trust the ones who have your back. The same goes for Indy and Mutt.
Let me provide an example of this. After the jungle chase, the characters crash into a wide nesting ground of huge, menacing ants. As Indy, Mutt, Ox and Mac run to the river to avoid attack by the ants, one of the enemy soldiers tackles Indy and Ox. This leads to a fist fight between the soldier and Indy. Mutt turns around to go help, but Indy yells, "Get to the river!".
This is a simple and effective portrayal of their growing bond. Indy and Ox are in trouble. Mutt turns to help. Indy cares too much about Mutt for him to get caught up in his current situation. Therefore, he tells him to continue on. BOOM... pretty straight forward. Mutt has also been with Indy long enough now to know that he can hold his own in a fight. So, he easily continues on knowing that they'll meet back up. And they do.
Clip via YouTube Duck Channel 120
What's really funny is how Mutt reacts to Indiana and Marion's rekindled love. It takes some getting used to, which is completely understandable. Indy and Marion have so much history, but it's all still pretty new to Mutt. And the way he deals with it is hilarious at times.
At one point, Indy, Mutt, Marion, Ox and Mac recompose themselves after falling into a watery pit. Indy helps Marion up and they hug. This stops Mutt in his tracks as he observes with a close eye. After hugging, Indy and Marion lean in to kiss each other. And right before they do, the intervening Mutt abruptly comes in between the two and gives Indy a skeleton to hold for no other reason than to stop the kiss. Classic, haha. Even though Indy and Mutt have been through a lot together, Mutt is still learning to navigate this whole "father" thing. And it plays out very comical at times. Just look at Mutt's reaction to Indy and Marion's wedding kiss at the end of the film. It's priceless.
Movie Clip via ChenJ
After time, Mutt begins to accept this new truth. And it changes him for the better.
As much as this is a film about artifacts and good agendas versus evil agendas, it is very much a film about family. And the crystal skull is merely a MacGuffin used to unify a broken and distant one. And through that unity, a young man named Henry "Mutt" Jones III manages to step into more of his true identity. He doesn't even have to say anything for us to realize he's changed. From his growing eagerness of leadership throughout their journey to his collective and bright spirit at the wedding. His whole countenance is different.
He even mistakenly answers to his real name at the wedding as Ox yells out, "Well done Henry!" to Indiana. The old Mutt probably wouldn't have responded so kindly.
You can also see it in how he leaves the church. With his jacket slung over his shoulder, he walks out with a newfound respect and confidence in himself.
Cover Image via IMDb
I do not own the rights to any characters or material in this blog. All rights reserved to rightful owners. I hold right to my original ideas and thesis. Thank You.

redpajama_set_name: RedPajamaCommonCrawl


text:
Q: Validating FlaskForm (Flask-WTForms) SelectField Populated with AJAX I'm having some trouble submitting a form that includes a SelectField populated by AJAX. Don't mind the letters in front of the variable names, they are there to set their order because the forms are generated automatically:
class CreateEmployeeForm(FlaskForm):
    code = StringField(
        'Employee Code', validators=[DataRequired(), Length(max=16)]
        )
    a__first_name = StringField(
        'First Name', validators=[DataRequired(), Length(max=128)]
        )
    aa__last_name = StringField(
        'Last Name', validators=[DataRequired(), Length(max=128)]
        )
    email = StringField(
        'Email', validators=[DataRequired(), Email(), Length(max=128)]
        )
    start_date = DateField(
        'Start Date', format='%Y-%m-%d', validators=[Optional()]
        )
    phone = StringField(
        'Telephone', validators=[DataRequired(), Length(min=10, max=16)]
        )
    type_id = SelectField(
        'Employee Type', choices=[], coerce=int,
        validators=[not_blank, v_employee_type],
        render_kw={'class': 'dropdown_pop', 'id': 'Employee_type:name'}
        )
    z__password = PasswordField(
        'Password', validators=[DataRequired(), Length(min=8)]
        )
    z__password2 = PasswordField(
        'Repeat Password', validators=[DataRequired(), EqualTo('z__password')]
        )
    zzzz__submit = SubmitField(
        'Create Employee', render_kw={'class': 'submit_btn'}
        )

    def validate_code(self, code):
        user = Employee.query.filter_by(code=code.data).first()
        if user is not None:
            raise ValidationError('This employee id is already taken.')

    def validate_email(self, email):
        user = Employee.query.filter_by(email=email.data).first()
        if user is not None:
            raise ValidationError('Please use a different email address.')

The issue in question is with type_id which is populated upon rendering with the choices pulled from the DB by a jQuery call to an API.
If I try to submit the form as-is, type_id will not validate and I will get the standard Not a valid choice error.
I read somewhere else that if I set a custom validation function for this field it will override the regular FlaskForm validation.
Unfortunately, Flask-WTF uses underscores to detect what needs to be validated and as soon as I add the validate_type_id function the application crashes.
I don't think the error is relevant since it is something coming from how FlaskForms is built.
I need to find a way around.
So I tried creating an external validation function and calling it in the validators=[...] within the field inside the form. Didn't work, still got the invalid choice error message.
I'm trying to validate the field by checking that the option selected for that field exists in the DB. Or, is there a way to disable validation for that field with out using validate_fieldName(...) ?
I'm stuck between a rock and a hard place, I cannot change the field name to exclude the underscore because of the way that this is used to create the entry in the DB. From what I've read, I can only use letters, numbers and underscore as variable names in Python, so from that point of view, I'm screwed.
Any ideas?

A: You can try the QuerySelectField extension to do this.
https://wtforms.readthedocs.io/en/2.3.x/ext/#wtforms.ext.sqlalchemy.fields.QuerySelectField
That way Submitting a choice which is not in the query will result in a validation error.
Also, you can take a look at the example provided here on how to fill a WTForm via Ajax:

https://github.com/saltycrane/flask-jquery-ajax-example

It updates the select field on obtaining a successful response from the Ajax request.

redpajama_set_name: RedPajamaStackExchange


text:
Challenge Description
The U.S. Department of Education (ED) Reach Higher Career App Challenge (the Challenge) calls upon app developers, educators, and data mavens to submit mobile solutions that help students navigate education and career paths, and increase the capacity of career counselors to serve students. The Challenge seeks solutions that include integrated tools to assess user skills and interests, and offer users accessible information on occupations, education options, credentials, and career-seeking skills.
These Official Rules, Terms & Conditions apply to the Reach Higher Career App Challenge. Please read these Rules, Terms & Conditions carefully before submitting to the Reach Higher Career App Challenge. These Official Rules, Terms & Conditions also appear in the Federal Register notice announcing the Challenge.
The Challenge will be conducted in four phases: 1) Challenge launch and open submissions; 2) Judging of submissions and selection of finalists; 3) Virtual Accelerator (inclusive of finalist mentorship, Innovator's Boot Camp, and Demonstration Day (Demo Day)); and 4) Final judging and selection of winner(s). Up to five finalists will be selected from the open submission pool. The total prize pool is $225,000. Finalists will be awarded $25,000 for their submission based on a review by the judging panel using the criteria listed below. Finalists will be encouraged to use their winnings to improve upon their submissions, and are required to participate in the Virtual Accelerator phase, and to attend the Innovator's Boot Camp and Demo Day. After the Virtual Accelerator, Demo Day, and final judging, the winner(s) will be selected by ED and receive the remainder of the prize money.
Virtual Accelerator Description
The Virtual Accelerator begins on the date finalists are announced and concludes on Demo Day, which is the day when finalists present their submissions to the judging panel. During this period, the finalists will iterate and improve upon their submissions in preparation for Demo Day. On Demo Day, the finalists will be required to present their concept and demonstrate a final prototype.
General Elements of the Virtual Accelerator Phase
Mentorship: Finalists will have access to subject matter experts (SMEs) who will act throughout the Virtual Accelerator as mentors, helping the finalists to iterate and improve their submissions.
Innovator's Boot Camp: Finalists will be required to participate in the Innovator's Boot Camp, which will either be a live event in the greater New York City metropolitan area or a virtual event. Finalists will receive guidance through teaching modules, which may include hands-on activities, with SMEs and Luminary Labs, LLC (Luminary Labs) staff. While the agenda has yet to be finalized, major themes will likely include user testing and interface development along with instructions on how to best iterate and improve finalists' submissions, potentially including various design and innovation methodologies that would improve CTE programs and virtual accessibility for everyone, including individuals with disabilities.
Demo Day Presentation Support: After the Innovator's Boot Camp and prior to Demo Day, all finalists will have the opportunity to practice their presentations and receive feedback from Luminary Labs on how to improve their Demo Day presentations.
Following Demo Day, a judging panel will provide recommendations to ED on the selection of one or more winners from the pool of finalists who will receive the remainder of the prize money.
Eligible entrants must be:
Individuals at least 18 years of age and a citizen or permanent resident of the United States (defined as The 50 States of the United States, the District of Columbia, the Commonwealth of Puerto Rico, and the outlying areas of the United States Virgin Islands, Guam, American Samoa, the Commonwealth of the Northern Mariana Islands, and the Republic of Palau);
Teams of individuals that (i) Are all at least 18 years of age, (ii) Include at least one citizen or permanent resident of the United States, and (iii) May also include foreign citizens who affirm at the time of submission of an entry for the Challenge that they are foreign citizens, who are not permanent residents; or
An entity registered or incorporated in accordance with applicable State and local laws, and maintaining a primary place of business in the United States. The entity may include foreign citizens participating as employees of the entity.
Ineligible entrants include:
A foreign citizen unless participating as part of an eligible team or entity;
A Federal entity;
A Federal employee acting within the scope of his or her employment; and
All employees of ED, Luminary Labs, Challenge sponsors, and/or any other individual or entity associated with the development or administration of the Challenge, as well as members of such persons' immediate families (spouses, children, siblings, parents), and persons living in the same household as such persons, whether or not related.
Entrants must:
Register on the Luminary LightboxTM platform (see "Additional Terms that are Part of the Official Rules, Terms & Conditions");
Enter a submission on www.reachhigherchallenge.com, (the Challenge website) according to these Official Rules, Terms & Conditions;
Comply with all requirements;
Provide affirmation upon submission of an entry for the Challenge that an entrant is eligible according to these Official Rules, Terms & Conditions. If selected as a finalist, entrants must provide documentation to demonstrate their eligibility at that time; and
Assume any and all risks and waive claims against the Federal government and its related entities, except in the case of willful misconduct, for any injury, death, damage, or loss of property, revenue, or profits, whether direct, indirect, or consequential, arising from their participation in the Challenge, whether the injury, death, damage, or loss of property, revenue, or profits, whether direct, indirect, or consequential, arises through negligence or otherwise.
Indemnify the Federal government against third party claims for damages arising from, or related to, competition, patents, copyrights, and trademark infringements; and
Comply with and abide by these Official Rules, Terms & Conditions and the decisions of ED, which shall be final and binding in all respects.
Entrants are not required to obtain liability insurance or demonstrate financial responsibility in order to participate in the Challenge.
The total prize pool for the Challenge is $225,000. From the $225,000 Challenge prize pool funds, up to five finalist teams will be awarded $25,000 each following the judging of open submissions. Finalists will improve and iterate upon their submissions during the Virtual Accelerator in preparation for Demo Day. After Demo Day, a judging panel will provide recommendations to ED on the selection of one or more winners from the pool of finalists to receive the remainder of the prize money.
Prizes awarded under this competition will be paid by electronic funds transfer. Winners are responsible for any applicable local, State, and Federal taxes and reporting that may be required under applicable tax laws.
Finalist and Winner Selection/Evaluation Criteria
Based on their individual expertise, judges will recommend up to five finalists to be selected by ED from the pool of eligible entries. Once ED has selected a group of finalists based on the recommendations of the judges consistent with the selection criteria, the finalists will then refine their submissions during the Virtual Accelerator phase and present their submissions on Demo Day.
Entries will be scored by the judges based on the quality of each entry according to the criteria below. Each of the following five selection criteria may be assigned up to 20 points during the judging of open submissions in order to select finalists (for a total of up to 100 points):
Finalist evaluation criteria
Actionable Outcomes. Demonstrates seamless career choice decision-making through the integration of (i) An interactive tool that assesses user skills and interests; (ii) Up-to-date occupational data; (iii) Educational options, including career and technical education (CTE) programs, technical skill credentials, and postsecondary certificate and degree programs; and (iv) Career-seeking skills, which may include, e.g., resume writing skills, interviewing skills, etc.
Target Audience. Provides support for educational and career path decision-making across a broad cross-section of students including students with disabilities, English Learners, and students in CTE programs. Provides support for a counselor and/or teacher interactions with students, or plans for accessible features that will provide this support as the app is further developed.
Scalability. Offers viable plan for full development of features, including the integration of comprehensive employment data, effective communication for English Learners and individuals with disabilities, and virtual accessibility in a form that meets a government or industry-recognized standard for accessibility. Details how local data and application programming interfaces (APIs) will enable the prototype to be customized to offer local educational and employment information.
Market Differentiation. Demonstrates clear differentiation from current market offerings.
Team Commitment. Illustrates commitment and ability of submitting team to develop the prototype into a fully functional app.
Winner selection criteria
When judging the finalist submissions, judges will recommend to ED the winner or winners from the pool of the finalists. From the pool of finalists, the winner(s) will be selected based on the five criteria above and the two additional criteria below. Each of the seven criteria may be assigned up to 20 points during the judging of the finalist submissions (for a total of up to 140 points). These two additional criteria are:
Demonstration of the finalist's ability to effectively iterate and improve their concept over the course of the Virtual Accelerator; and
Perceived ability of the finalist and their prototype to materially transform career and education decision-making for students.
The evaluation criteria are to be applied in the sole discretion of ED and the individual judges and are subject to modification by ED. By participating in the Challenge, each entrant into the Challenge acknowledges and agrees that such evaluations may differ from person to person and agrees to be bound by and not challenge the final decisions of ED.
The judging scores will not be posted. Feedback will not be provided to entrants that are not selected as finalists.
Go to the Challenge website and complete all required fields of the Challenge submission form before the close of open submissions on December 7, 2015 at 11:59:59 pm EST. Each entrant must complete all of the required fields in the Challenge submission form in accordance with these Official Rules, Terms & Conditions.
All entrants are required to provide consent to these Official Rules, Terms & Conditions upon submitting an entry. Submissions must be received during the open submissions period of the Challenge to be eligible. Open submissions officially begins after publication of a Federal Register notice announcing the Challenge. Open submissions will last from Challenge launch through the close of open submissions, currently scheduled for December 7, 2015 at 11:59:59 PM EST. Luminary Labs is the official timekeeper for the Challenge. Once submitted, a submission may not be altered during open submissions. ED reserves the right to disqualify any submission that ED deems inappropriate.
During the Virtual Accelerator phase, the finalists will be required to give their Demo Day presentation and demonstrate a final prototype.
Entrants may enter individually or as part of a team, and teams are strongly encouraged. Each team member must be clearly identified on the team's submission form for the team to be eligible. Teams must designate a primary contact to serve as the team lead (Team Lead) and manage the distribution of any awarded prizes. In the event a dispute regarding the identity of the entrant who actually submitted the entry cannot be resolved to ED's satisfaction, the affected entry will be deemed ineligible.
All entry information submitted on the Challenge website and all materials, including any copy of the submission, becomes property of ED and will not be acknowledged or returned by Luminary Labs or ED. However, entrants retain ownership of their concepts, including any software, research, or other intellectual property (IP) that they develop in connection therewith, subject to the license granted to ED to use submissions as set forth in "Intellectual Property of Solutions" below. Proof of submission is not considered proof of delivery to or receipt of such entry. Furthermore, ED and Luminary Labs shall have no liability for any submission that is lost, intercepted, or not received by ED and/or Luminary Labs. ED and Luminary Labs assume no liability or responsibility for any error, omission, interruption, deletion, theft, destruction, or unauthorized access to, or alteration of, submissions.
Open submissions closes at 11:59:59 PM EST on December 7, 2015. Entrants should submit at least one hour before the deadline to ensure the completed submission is received. If you submit an application after the deadline date because you experienced a technical problem with the Challenge website system, you must immediately contact hello@reachhigherchallenge.com, and provide an explanation of the technical problem experienced on the Challenge website system. ED will accept your application if ED can confirm that a technical problem occurred with the Challenge website system and that the technical problem affected your ability to submit an application by 11:59:59 PM EST, on the entry deadline date. ED will contact you after a determination is made on whether the application will be accepted.
Note: These extensions apply only to the unavailability of, or technical problems with, the Challenge website system. ED will not grant an entrant an extension if the entrant failed to submit an application in the system by the application deadline date and time, or if the technical problem experienced is unrelated to the Challenge website system.
Individuals with disabilities who need an accommodation or auxiliary aid in connection with the application process should contact: Albert Palacios, U.S. Department of Education, 550 12th Street SW., room 11-086, Washington, DC 20202 or by email: albert.palacios@ed.gov. If you use a TDD or a TTY, call the FRS, toll free, at 1-800-877-8339. If ED provides an accommodation or auxiliary aid to an individual with a disability in connection with the entry submission process, the entry remains subject to all other requirements and limitations in this notice.
Representations and Warranties/Indemnification
By participating in the Challenge, each entrant represents, warrants, and covenants as follows:
The entrants are the sole authors, creators, and owners of the submission;
The entrant's submission:
Is not the subject of any actual or threatened litigation or claim;
Does not, and will not, violate or infringe upon the intellectual property rights, privacy rights, publicity rights, or other legal rights of any third party;
Does not, and will not, contain any harmful computer code (sometimes referred to as "malware," "viruses," or "worms"); and
The submission, and entrants' use of the submission, does not, and will not, violate any applicable laws or regulations of the United States.
If the submission includes the work of any third party (such as third party content or open source code), the entrant must be able to provide, upon the request of ED and/or Luminary Labs, documentation of all appropriate licenses and releases for such third party works. If the entrant cannot provide documentation of all required licenses and releases, ED reserves the right, in its sole discretion, to disqualify the applicable submission, or direct the entrant to secure the licenses and releases for ED's benefit within three (3) days of notification of the missing documentation and allow the applicable submission to remain in the Challenge. In addition, ED reserves all rights to pursue an entrant for claims based on damages incurred by the entrant's failure to obtain such licenses and releases.
Entrants will indemnify, defend, and hold harmless ED and Luminary Labs from and against all third party claims, actions, or proceedings of any kind and from any and all damages, liabilities, costs, and expenses relating to, or arising from, the entrant's submission or any breach or alleged breach of any of the representations, warranties, and covenants of the entrant hereunder.
ED reserves the right to disqualify any submission that ED, in its discretion, deems to violate these Official Rules, Terms & Conditions.
Submission License
Each entrant retains title to, and full ownership of, its submission. The entrant expressly reserves all intellectual property rights not expressly granted under this agreement. By participating in the Challenge, each entrant hereby irrevocably grants a license to ED and Luminary Labs to store and access submissions in perpetuity that may be reproduced or distributed in the future. Please refer to "Intellectual Property of Solutions" below for further information regarding rights to solutions.
Publicity Release
By participating in the Challenge, each entrant hereby irrevocably grants to ED and Luminary Labs the right to use such entrant's name, likeness, image, and biographical information in any and all media for advertising and promotional purposes relating to the Challenge, and otherwise, as stated above in "Submission License".
Disqualification
ED reserves the right in its sole discretion to disqualify any entrant who is found to be tampering with the entry process or the operation of the Challenge, Challenge website, or other Challenge-related websites; to be acting in violation of these Official Rules, Terms & Conditions; or to be acting in an unsportsmanlike or disruptive manner, or with the intent to disrupt or undermine the legitimate operation of the Challenge; or to annoy, abuse, threaten, or harass any other person; and ED reserves the right to seek damages and other remedies from any such person to the fullest extent permitted by law.
Links to Third-Party Websites
The Challenge website may contain links to third-party websites that are not owned or controlled by Luminary Labs or ED. Luminary Labs and ED do not endorse or assume any responsibility for any such third-party sites. If you access a third-party website from the Challenge website, you do so at your own risk and expressly relieve Luminary Labs and/or ED from any and all liability arising from use of any third-party website content.
The Challenge website contains information and resources from public and private organizations that may be useful to the reader. Inclusion of this information does not constitute an endorsement by the ED or Luminary Labs of any products or services offered or views expressed. Blog articles do not endorse any educational product, service, curriculum or pedagogy.
The Challenge website also contains hyperlinks and URLs created and maintained by outside organizations, which are provided for the reader's convenience. ED and Luminary Labs are not responsible for the accuracy of the information contained therein.
Notice to Finalists/Winner(s)
Attempts to notify finalists and winner(s) will be made using the email address associated with the Team Lead's Luminary Lightbox account. ED and Luminary Labs are not responsible for email or other communication problems of any kind.
If, despite reasonable efforts, an entrant does not respond within three (3) days of the first notification attempt regarding selection as a finalist (or a shorter time as exigencies may require), or if the notification is returned as undeliverable to such entrant, that entrant may the entrant's finalist status and associated prizes, and an alternate finalist may be selected.
If, despite reasonable efforts, a potential winner does not respond within three (3) days of the first notification attempt (or a shorter time as exigencies may require), or if the notification of prize or the prize itself is returned as unclaimed or undeliverable to such participant, that participant may forfeit the participant's winner status and associated prizes, and an alternate winner may be selected.
If any potential prize winner is found to be ineligible, has not complied with these Official Rules, Terms & Conditions, or declines the applicable prize for any reason prior to award, such potential prize winner will be disqualified. An alternate winner may be selected, or the applicable prize may go unawarded.
To maintain eligibility, finalists are required to participate in Challenge activities organized by ED and Luminary Labs, which include the Virtual Accelerator, webinars, Innovator's Boot Camp and Demo Day. If a finalist is unable to participate in any mandatory activities, the finalist will not be eligible to win the Challenge. Finalists and winner(s) are required to attend these events at their own expense.
Intellectual Property (IP) of Solutions
Entrants retain ownership of their submission, including any software, research or other IP that they develop in connection therewith, subject to the license granted to ED to use submissions as set forth herein.
Entrants retain all rights to the submission and any invention or work, including any software, submitted as part of the submission, subject to the following:
If the submission wins, ED retains a nonexclusive, nontransferable, irrevocable, paid-up world-wide license to any such invention or work of the submission throughout the world, in perpetuity, to reproduce, publish or otherwise use the work for Federal purposes and authorize others to do so.
Please refer to "Submission License" above for further information regarding rights to submissions.
Program Authority
The goals, purposes, and activities related to the Challenge are authorized by section 114(c)(1) of Perkins IV, 20 U.S.C. 2324(c)(1). Under this section, the Secretary of the U. S. Department of Education is authorized to carry out research, development, dissemination, evaluation and assessment, capacity building, and technical assistance with regard to CTE programs under Perkins IV. Following the RHCAC, submissions selected as finalists will be made available to the public to improve access to information on CTE programs and career guidance strategies that can be adapted and implemented in local areas thereby building local capacity to counsel students regarding CTE programs.
ED reserves the right to modify any dates or deadlines set forth in these Official Rules, Terms & Conditions or otherwise governing the Challenge.
Challenge Termination
ED reserves the right to suspend, postpone, cease, terminate or otherwise modify this Challenge, or any entrant's participation in the Challenge, at any time at ED's discretion.
General Liability Release
By participating in the Challenge, each entrant hereby agrees that:
ED and Luminary Labs shall not be responsible or liable for any losses, damages, or injuries of any kind (including death) resulting from participation in the Challenge or any Challenge-related activity, or from an entrants' acceptance, receipt, possession, use, or misuse of any prize; and
The entrant will indemnify, defend, and hold harmless ED and Luminary Labs from and against all third party claims, actions, or proceedings of any kind and from any and all damages, liabilities, costs, and expenses relating to, or arising from, the entrant's participation in the Challenge.
Without limiting the generality of the foregoing, ED and Luminary Labs are not responsible for incomplete, illegible, misdirected, misprinted, late, lost, postage-due, damaged, or stolen entries or prize notifications; or for lost, interrupted, inaccessible, or unavailable networks, servers, satellites, Internet Service Providers, websites, or other connections; or for miscommunications, failed, jumbled, scrambled, delayed, or misdirected computer, telephone, cable transmissions or other communications; or for any technical malfunctions, failures, difficulties, or other errors of any kind or nature; or for the incorrect or inaccurate capture of information, or the failure to capture any information.
These Official Rules, Terms & Conditions cannot be modified except by ED in its sole and absolute discretion. The invalidity or unenforceability of any provision of these Official Rules, Terms & Conditions shall not affect the validity or enforceability of any other provision. In the event that any provision is determined to be invalid or otherwise unenforceable or illegal, these Official Rules, Terms & Conditions shall otherwise remain in effect and shall be construed in accordance with their terms as if the invalid or illegal provision were not contained herein.
The failure of ED to exercise or enforce any right or provision of these Official Rules, Terms & Conditions shall not constitute a waiver of such right or provision.
All issues and questions concerning the construction, validity, interpretation, and enforceability of these Official Rules, Terms & Conditions shall be governed by and construed in accordance with U.S. Federal law as applied in the Federal courts of the District of Columbia if a complaint is filed by any party against ED, and the laws of the State of New York as applied in the New York state courts in New York City if a complaint is filed by any party against Luminary Labs.
By participating in the Challenge, each entrant hereby agrees that occasionally, ED and Luminary Labs may also use the entrant's information to contact the entrant about Federal Challenge and innovation related activities, and acknowledges that the entrant has read and accepted the privacy policy at: www.reachhigherchallenge.com/privacy.
Additional Terms that are Part of the Official Rules, Terms & Conditions
Please review the Luminary Lightbox Terms of Service at www.luminarylightbox.com/terms for additional rules that apply to your participation in the Challenge and more generally your use of the Challenge Website. Such Terms of Service are incorporated by reference into these Official Rules, Terms & Conditions. If there is a conflict between the Terms of Service and these Official Rules, Terms & Conditions, the latter terms shall control with respect to this Challenge only.
Participation in the Challenge constitutes the entrant's full and unconditional agreement to these Official Rules, Terms & Conditions. By entering, an entrant agrees that all decisions related to the Challenge that are made pursuant to these Official Rules, Terms & Conditions are final and binding, and that all such decisions are at the sole discretion of ED and/or Luminary Labs.
Luminary Labs collects personal information from entrants to the Challenge. The information collected is subject to the privacy policy located here: www.luminarylightbox.com/privacy.
Winners List/Official Rules/Contact
To obtain a list of finalists and winner(s) (after the conclusion of the Challenge) or a copy of these Official Rules, Terms & Conditions, send a self-addressed envelope with the proper postage affixed to: Luminary Labs, 30 West 22nd St., Floor 6, New York City, NY, 10010. Please specify "Winners List" or "Official Rules, Terms & Conditions" and the name of the specific Challenge in your request.
Please contact us at hello@reachhigherchallenge.com should you have any comments or questions about these Rules, Terms & Conditions.


Biggico at LiAC'18 and Crypto Games Conference!
Lisbon Affiliate Conference and Minsk Crypto Games Conference have ended!
Pleasant people were met, hands were shaken! We wish to thank organizers and all participants.
Take a look at some photos from these events!
More cool offers and improved conditions for existing offers are coming soon!
Besides that, Malta Blockchain Summit is coming! Stay tuned!