예제 #1
0
 def __init__(self, tag, value, type, parent):
     self.parent = parent
     self.endian = parent.endian
     self.id = self.endian == "II" and util.reverse(tag) or tag
     self.type = type
     self.bytes = self.typeMap[self.type]
     self.setValue(value)
예제 #2
0
 def parse_ifd(self, ifdOffset, context, next=None):
     """ Construct a modifiable Exif.
         
         Get nr of tags and parse each tag. If a pointer tags to other ifd is found, 
         recurse inside that ifd as well
     """
     ifd = self.tiff[ifdOffset:]
     nrTags = util.getNr(ifd[:2], self.endian)
     if DEBUG: 
         print self.ifdName(context), "nr tags", nrTags
     offset = 2  #position after nr tags bytes
     for i in range(nrTags):
         try:
             tag = Tag(ifd[offset : offset+12], self)
         except Exception, e:  #mainly unsuported tag types, etc
             # TODO: if a tag is buggy is it ok to just ignore it and go on or should we crash alltoghether
             if DEBUG: 
                 print "Can't create tag", str(e)
             offset += 12
             continue
         context.append(tag)
         if next is not None:   # and tag.value is not None:
             for ix in range(len(next)):
                 nxtId = next[ix][0]
                 if (tag.id == nxtId) or (self.endian=="II" and tag.id == util.reverse(nxtId)):
                     next[ix][1] = tag.value
         offset += 12
예제 #3
0
def isLychrelNumber(n):
    count = 0
    while(count < 50):
        n = n + reverse(n)
        if isPalindromic(n):
            return False
        count += 1
    return True
예제 #4
0
 def niceID(self):
     "return tag hex value and also a description if available"
     id = exif_tags_description.get(self.endian == "MM" and self.id or util.reverse(self.id), None)
     if id == None: 
         id = hex(util.getNr(self.id, self.endian))
     else:
         id = hex(util.getNr(self.id, self.endian)) + " - " + (type(id) == type(()) and id[0] or id)
     return id
예제 #5
0
 def dict(self):
     "return a dictionary {tag description: (ifd, tag id, value)} of all parsed tags"
     d = {}
     for ifd in self.ifds:
         for tag in ifd:
             id = exif_tags_description.get(self.endian == "MM" and tag.id or util.reverse(tag.id), repr(tag.id))
             id = type(id) == type(()) and id[0] or id
             d[id] = (self.ifdName(ifd), hex(util.getNr(tag.id, self.endian)), tag.value)
     return d
예제 #6
0
 def getValue(self, parse=True):
     "return tag value, if posible parsed to a nice representation"
     if not parse:
         return self.value
     tag = self.id
     if self.endian == "II":
         tag = util.reverse(tag)
     val =  exif_tags_description.get(tag, None)
     if val is None: 
         return self.value
     if type(val) == type(()):
         return val[1].get(self.value, self.value)
     return self.value
예제 #7
0
def load_model(device):
  word_map = torchfile.load(os.path.join(PARAM_DIR, 'word_map.th7'))
  word_map = [w.decode('utf-8') for w in word_map]
  word_to_idx = {w: i for i, w in enumerate(word_map)}
  word_freq = torchfile.load(os.path.join(os.path.join(PARAM_DIR, 'word_freq.th7')))
  mapto = torch.from_numpy(util.reverse(np.argsort(-word_freq))).long().to(device)

  with open(os.path.join(PARAM_DIR, 'lm.pt'), 'rb') as model_file:
    model = torch.load(model_file)
  model.full = True  # Use real softmax--important!
  model.to(device)
  model.eval()
  return QueryHandler(model, word_to_idx, mapto, device)
예제 #8
0
 def set(self, tag, value, targetIfd, type_):
     """ - Overwrite <tagID> tag with <value>.
         - If tag does not already exist, build it in the specified <targetIfd>.
         - The type (short, long, ascii, etc. as 3,4,2 etc.) need to be specified since this program will 
           probably never be aware of all posible tags and their specification. You may need to do some
           research with exif.org to find the right type
     """
     tagID = type(tag)==type(1) and util.setNr(tag)[2:] or tag   #nr to str
     for ifd in self.ifds:
         for tag in ifd:
             if tag.id == tagID or (self.endian == "II" and tag.id == util.reverse(tagID)):
                 tag.setValue(value)
                 return True
     
     tag = FirstTag(tagID, value, type_, self)    #don't have it yet, so create one
     targetIfd.append(tag)
예제 #9
0
        torch.cuda.set_device(args.gpu)
        torch.cuda.manual_seed(args.seed)

if not args.lm1b:
    with doing('Loading data'):
        corpus = corpus.Corpus(args.data, args.dic)
        ntokens = len(corpus.dictionary.idx2word)
        cutoffs = args.cutoffs + [ntokens]
else:
    ###############################################################################
    # Load data
    ###############################################################################

    # Torch
    word_freq = load_lua(os.path.join(args.data, 'word_freq.th7')).numpy()
    mapto = torch.from_numpy(util.reverse(np.argsort(-word_freq))).long()
    print("load word frequency mapping - complete")

    ntokens = len(word_freq)
    nsampled = 8192

    train_corpus = FastGBWDataset(args.data, 'train_data.th7', 'train_data.sid', mapto)
    print("load train data - complete")

    test_corpus = GBWDataset(args.data, 'test_data.th7', mapto)
    print("load test data - complete")

    cutoffs = args.cutoffs + [ntokens]


# with doing('Constructing model'):
예제 #10
0
from util import reverse

names = ['jesse', 'mike', 'joe', 'marco']

print "Names:"
print names

x = reverse(names)
print ""
print "Names Reversed: "
print x

x = sorted(x)
print ""
print "Sorted:"
print x

x = reverse(x)
print ""
print "Sorted Descending:"
print x

#sort in place
x.sort();
print ""
print "x.sort()"
print x

x = sorted(x, reverse=True)
print ""
print "Sorted in reverse"
예제 #11
0
파일: test_util.py 프로젝트: aschmied/notes
 def test_reverse_nonempty_list(self):
     self.assertListEqual(util.reverse(['blah', 'blerg']),
                          ['blerg', 'blah'])
예제 #12
0
파일: test_util.py 프로젝트: aschmied/notes
 def test_reverse_none(self):
     with self.assertRaises(TypeError):
         util.reverse(None)
예제 #13
0
파일: test_util.py 프로젝트: aschmied/notes
 def test_reverse_empty_list(self):
     self.assertListEqual(util.reverse([]), [])
예제 #14
0
from util import (reverse, x)

y = reverse('fernando')

print y

myX = x(1,2)

print myX.y 
print myX.z