示例#1
0
 def _extract_base_headers(self, post_vars):
   data = {
       'frontend': post_vars.getvalue('frontend', '').replace('"', '"'),
       'reply': post_vars.getvalue('reply', '').replace('"', '"'),
       'board': post_vars.getvalue('board', '').replace('"', '"'),
       'target': post_vars.getvalue('target', '').replace('"', '"'),
       'name': post_vars.getvalue('name', '').replace('"', '"'),
       'email': post_vars.getvalue('email', '').replace('"', '"'),
       'subject': post_vars.getvalue('subject', '').replace('"', '"')
   }
   data['custom_headers'] = self._custom_headers_to_html(self._get_custom_headers(post_vars, data['frontend']))
   if post_vars.getvalue('hash', '') != '':
     data['comment'] = post_vars.getvalue('comment', '').replace('"', '"')
     data['file_name'] = post_vars.getvalue('file_name', '').replace('"', '"')
     data['file_ct'] = post_vars.getvalue('file_ct', '').replace('"', '"')
     data['file_b64'] = post_vars.getvalue('file_b64', '').replace('"', '"')
   else:
     data['comment'] = base64.encodestring(post_vars.getvalue('comment', ''))
     data['file_name'], data['file_ct'], data['file_b64'] = '', '', ''
     if 'allowed_files' in self.origin.frontends[data['frontend']]:
       try:
         data['file_name'] = post_vars['file'].filename.replace('"', '"')
       except KeyError:
         pass
       if data['file_name']:
         data['file_ct'] = post_vars['file'].type.replace('"', '"')
         f = io.StringIO()
         base64.encode(post_vars['file'].file, f)
         data['file_b64'] = f.getvalue()
         f.close()
   return data
示例#2
0
def CreateBase64HNAPRequest(file, actionName, elementName):

    # Add the request header
    content = StringIO.StringIO()
    content.write('''\
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" soap:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<soap:Body>
<%s xmlns="http://purenetworks.com/HNAP1/">
<%s>
''' % (actionName, elementName))

    # Base64 encode the firmware file
    fh = open(file, "rb")
    try:
        base64.encode(fh, content)
    except:
        fh.close()
        raise
    fh.close()

    # Add the footer
    content.write('''\
</%s>
</%s>
</soap:Body>
</soap:Envelope>''' % (elementName, actionName))

    # Return the request
    soapAction = "http://purenetworks.com/HNAP1/%s" % actionName
    return (soapAction, content.getvalue())
示例#3
0
def dump(elm, out=sys.stdout, indent=0, depth=0, suppress=False):

    if indent and not suppress:
        out.write(" " * depth)

    if isinstance(elm, dict):
        out.write(u"<dict>")
        if indent:
            out.write(u"\n")
        for key, val in elm.iteritems():
            if indent:
                out.write(" " * (depth + indent))
            out.write(u"<key>%s</key>" % key)
            dump(val, out, indent, depth+indent, suppress=True)
        if indent:
            out.write(" " * depth)
        out.write(u"</dict>")

    elif isinstance(elm, (list, tuple)):
        out.write(u"<array>")
        if indent:
            out.write(u"\n")
        for item in elm:
            dump(item, out, indent, depth+indent)
        if indent:
            out.write(" " * depth)
        out.write(u"</array>")

    elif isinstance(elm, basestring):
        out.write(u"<string>%s</string>" % escape(elm))

    elif isinstance(elm, bool):
        if elm:
            out.write(u"<true/>")
        else:
            out.write(u"<false/>")

    elif isinstance(elm, (int, long)):
        out.write(u"<integer>%d</integer>" % elm)

    elif isinstance(elm, float):
        out.write(u"<real>%f</real>" % elm)

    elif elm is None:
        out.write(u"<null/>")

    elif isinstance(elm, Data):
        out.write(u"<data>")
        base64.encode(StringIO(elm), out)
        out.write(u"</data>")

    elif isinstance(elm, datetime.datetime):
        raise Exception("not implemented")

    else:
        raise Exception("unknown data type '%s' for value '%s'" %
                        (str(type(elm)), str(elm)))

    if indent:
        out.write(u"\n")
示例#4
0
    def _save_to_qiniu(self):
        import qiniu
        output = BytesIO()
        self._source.seek(0)
        base64.encode(self._source, output)
        self._source.seek(0)
        output.seek(0)
        hex_octet = lambda: hex(int(0x10000 * (1 + random.random())))[-4:]
        key = ''.join(hex_octet() for _ in range_type(4))
        key = '{0}.{1}'.format(key, self.extension)
        data = {
            'name': self._name,
            'key': key,
            'ACL': self._acl,
            'mime_type': self._type,
            'metaData': self._metadata,
        }
        response = client.post('/qiniu', data)
        content = response.json()
        self.id = content['objectId']
        self._url = content['url']
        uptoken = content['token']
        ret, info = qiniu.put_data(uptoken, key, self._source)

        if info.status_code != 200:
            raise LeanCloudError(1, 'the file is not saved, qiniu status code: {0}'.format(info.status_code))
示例#5
0
def base64_encodefile(fname):
    '''
    Read a file from the file system and return as a base64 encoded string

    .. versionadded:: Boron

    Pillar example:

    .. code-block:: yaml

        path:
          to:
            data: |
              {{ salt.hashutil.base64_encodefile('/path/to/binary_file') | indent(6) }}

    The :py:func:`file.decode <salt.states.file.decode>` state function can be
    used to decode this data and write it to disk.

    CLI Example:

    .. code-block:: bash

        salt '*' hashutil.base64_encodefile /path/to/binary_file
    '''
    encoded_f = StringIO.StringIO()

    with open(fname, 'rb') as f:
        base64.encode(f, encoded_f)

    encoded_f.seek(0)
    return encoded_f.read()
示例#6
0
def upload_file(upload_file_name,
                temp_file_name='encoded.csv',
                split_file_format="{orig_file}_{id}.{orig_ext}",
                parent_folder_id='0B46HJMu9Db4xTUxhQ0x4WHpfVmM'):
    file_name = os.path.basename(upload_file_name)

    # Encode file.
    base64.encode(open(upload_file_name), open(temp_file_name, 'w+'))

    # Split file.
    num_split_files, file_names = splitfile(temp_file_name, SPLIT_SIZE, split_file_format)

    # Start upload threads.
    start = time.time()
    file_id = uuid.uuid1()
    thread_pool = ThreadPoolExecutor(max_workers=MAX_DOWNLOADS)

    for i in range(num_split_files):
        current_file_name = file_names[i]
        up_t = upload_worker.UploadWorker(index=i + 1,
                                          file_id=file_id,
                                          filename=file_name,
                                          parent_folder_id=parent_folder_id,
                                          total_file_num=num_split_files,
                                          upload_file_name=current_file_name)
        future = thread_pool.submit(up_t.run)

    # Wait for completion.
    thread_pool.shutdown()

    end = time.time()
    m, s = divmod(end - start, 60)
    print "Overall time taken: ", m, "m ", s, "s"
    return file_id
示例#7
0
文件: __init__.py 项目: evka1410/publ
    def _complexOutput(self, output, complexOutput):
        
        #Checks for the correct output and logs 
        self.checkMimeTypeOutput(output)
       
        complexOutput["mimetype"] = output.format["mimetype"]
        complexOutput["encoding"] = output.format["encoding"]
        complexOutput["schema"] = output.format["schema"]
       
        if output.format["mimetype"] is not None:
        # CDATA section in output
            #attention to application/xml
            if output.format["mimetype"].find("text") < 0 and output.format["mimetype"].find("xml")<0:
            #complexOutput["cdata"] = 1
                os.rename(output.value, output.value+".binary")
                base64.encode(open(output.value+".binary"),open(output.value,"w"))
            
        
        # set output value
        complexOutput["complexdata"] = open(output.value,"r").read()

        # remove <?xml version= ... part from beginning of some xml
        # documents
        #Better <?xml search due to problems with \n
        if output.format["mimetype"] is not None:
            if output.format["mimetype"].find("xml") > -1:
                beginXMLidx=complexOutput["complexdata"].find("?>")
                #All <?xml..?> will be beginXMLidx + 2 
                
                #beginXml = complexOutput["complexdata"].split("\n")[0]
                if beginXMLidx > -1:
                    complexOutput["complexdata"] = complexOutput["complexdata"].replace(complexOutput["complexdata"][:(beginXMLidx+2)],"")

        return complexOutput
示例#8
0
def submit(request):
    if request.method == 'POST':
        form = SubmitArticle(request.POST)
        if form.is_valid():
            newart = Article(name=request.POST['name'], writer=request.POST['writer'], short_text=request.POST['short_text'], text=request.POST['text'], date=timezone.now(), views=0)
            newart.save()
            numberofimages = int(request.POST['articlefakeimage_set-TOTAL_FORMS'])
            for number in range(numberofimages):
                if 'articlefakeimage_set-' + str(number) + '-image' in request.FILES:
                    newimagetosave = ArticleImages()
                    newimagetosave.article = newart
                    d = StringIO.StringIO()
                    filee = request.FILES['articlefakeimage_set-' + str(number) + '-image']
                    base64.encode(filee, d)
                    s = d.getvalue()
                    newimagetosave.image = "data:%s;base64,%s" % (filee.content_type, s)
                    newimagetosave.save()

            template_name = 'news/submit.html'
            context = {'user_form': form, 'err': '', 'suc': True}
            return render(request, template_name, context)
        else:
            template_name = 'news/submit.html'
            context = {'user_form': form, 'err': 'Please fill in all the fields'}
            return render(request, template_name, context)
    else:
        template_name = 'news/submit.html'
        form = SubmitArticle()
        context = {'user_form': form, 'err': ''}
        return render(request, template_name, context)
示例#9
0
文件: blobber.py 项目: hellais/APAF
def create_blobbone(directory, filename="blobbone.py"):
    tar_obj = StringIO.StringIO()
    tar = tarfile.open(mode='w:gz', fileobj=tar_obj)
    tar.add(directory)
    tar.close()
    tar_obj.seek(0)

    header_code = "import tarfile, base64, os, StringIO\n"
    uncompacting_code = (
    "encoded_obj = StringIO.StringIO()\n"
    "tar_obj = StringIO.StringIO()\n"
    "encoded_obj.write(blob)\n"
    "encoded_obj.seek(0)\n"
    "base64.decode(encoded_obj, tar_obj)\n"
    "tar_obj.seek(0)\n"
    "tar = tarfile.open('r:gz', fileobj=tar_obj)\n"
    "tar.extractall()\n"
    "tar.close()\n")

    f2 = open(filename, 'wb')
    f2.write(header_code)
    f2.write('blob = r"""')
    base64.encode(tar_obj, f2)
    f2.write('"""\n')
    f2.write(uncompacting_code)
    f2.close()
    print "Blobbone created. Run python %s to decompress it." % filename
def createTmpBase64(rLayer):
  try:
#      tmpFile = tempfile.NamedTemporaryFile(prefix="base64", delete=False)
#      infile = open(unicode(rLayer.source()))
#      tmpFileName = tmpFile.name
#      outfile = open(tmpFileName, 'w')
#      base64.encode(infile,outfile)
#      outfile.close()
#      outfile =  open(tmpFileName, 'r')
#      base64String = outfile.read()
#      outfile.close()
#      os.remove(tmpFile.name)

        tmpFile = tempfile.NamedTemporaryFile(prefix="base64", delete=False)
        infile = open(rLayer.source())
        tmpFileName = tmpFile.name
        outfile = tmpFile #open(tmpFileName, 'w')
        base64.encode(infile,outfile)
        outfile.close()
        infile.close()
        outfile =  open(tmpFileName, 'r')
        base64String = outfile.read()
        outfile.close()
        os.remove(tmpFileName)

  except:
      QMessageBox.critical(None, QApplication.translate("QgsWps","Error"), QApplication.translate("QgsWps","Unable to create temporal file: ") + filename + QApplication.translate("QgsWps"," for base64 encoding") ) 
  return base64String
示例#11
0
    def to_xml(cls, value, tns, parent_elt, name='retval'):
        '''
        This class method takes the data from the attachment and
        base64 encodes it as the text of an Element. An attachment can
        specify a file_name and if no data is given, it will read the data
        from the file
        '''

        assert isinstance(value, cls)

        element = etree.SubElement(parent_elt, '{%s}%s' % (tns,name))
        if value.data:
            # the data has already been loaded, just encode
            # and return the element
            element.text = base64.encodestring(value.data)

        elif value.file_name:
            # the data hasn't been loaded, but a file has been
            # specified
            data_string = cStringIO.StringIO()

            file_name = value.file_name
            file = open(file_name, 'rb')
            base64.encode(file, data_string)
            file.close()

            # go back to the begining of the data
            data_string.seek(0)
            element.text = str(data_string.read())

        else:
            raise Exception("Neither data nor a file_name has been specified")
    def _encode_img(self, file_path):
        """Returns image base64 string representation and makes a cache file"""
        filename   = file_path.rpartition(os.sep)[2]
        need_cache = True
        content    = ""

        cache_file = "%s_cache" % os.path.join(CACHE_DIR, filename)

        try:
            with open(cache_file, 'r') as cached_file:
                content = cached_file.read()
            need_cache = False
        except IOError:
            pass

        if need_cache:
            try:
                image = open(file_path, 'r')
                out   = StringIO()
                base64.encode(image, out)
                content = out.getvalue().replace('\n', '')
            except IOError:
                pass
            else:
                try:
                    with open(cache_file, 'w+') as cached_file:
                        cached_file.write(content)
                except IOError:
                    pass
        return content
示例#13
0
def send_mail(server, port, sender, recipient, subject, message, username = '', password = '', attachment = '', mime_type = ''):
    from StringIO import StringIO
    from smtplib import SMTP
    from MimeWriter import MimeWriter
    import base64

    # Build the message header.
    message_obj = StringIO()
    writer = MimeWriter(message_obj)
    writer.addheader('Subject', subject)
    writer.startmultipartbody('mixed')
    part = writer.nextpart()
    
    # Add the message body.
    body = part.startbody('text/plain')
    body.write(message)
    
    # And (optionally) the attachment.
    if attachment != '':
        part = writer.nextpart()
        part.addheader('Content-Transfer-Encoding', 'base64')
        body = part.startbody(mime_type) 
        base64.encode(StringIO(attachment), body)
    
    # Finish the message.
    writer.lastpart()
    
    # Send the mail (and authenticate if necessary).
    smtp = SMTP(server, port)
    if username != '':
        smtp.login(username, password)
    smtp.sendmail(sender, recipient, message_obj.getvalue())
    smtp.quit()
    return True
示例#14
0
    def get_image(self, size=DISPLAY_SIZE, page=DEFAULT_PAGE_NUMBER, zoom=DEFAULT_ZOOM_LEVEL, rotation=DEFAULT_ROTATION, as_base64=False, version=None):
        if zoom < ZOOM_MIN_LEVEL:
            zoom = ZOOM_MIN_LEVEL

        if zoom > ZOOM_MAX_LEVEL:
            zoom = ZOOM_MAX_LEVEL

        rotation = rotation % 360

        try:
            file_path = self.get_valid_image(size=size, page=page, zoom=zoom, rotation=rotation, version=version)
        except UnknownFileFormat:
            file_path = get_icon_file_path(self.file_mimetype)
        except UnkownConvertError:
            file_path = get_error_icon_file_path()
        except:
            file_path = get_error_icon_file_path()

        if as_base64:
            image = open(file_path, 'r')
            out = StringIO()
            base64.encode(image, out)
            return u'data:%s;base64,%s' % (get_mimetype(open(file_path, 'r'), file_path, mimetype_only=True)[0], out.getvalue().replace('\n', ''))
        else:
            return file_path
示例#15
0
    def read_file(self, filename, resource_name):
        if self.valid_extensions and os.path.splitext(filename)[1][1:] not in self.valid_extensions:
            print "Skipping:", filename
            return ''

        resource_name = resource_name.replace('\\', '/')
        print "Reading: '%s' --> '%s'" % (filename, resource_name)

        mimetype = mimetypes.guess_type(filename)[0]

        is_code = (mimetype in CODE_MIMETYPES)
        is_text = (mimetype in TEXT_MIMETYPES)
        is_image = (mimetype.split('/')[0] == 'image')

        data = StringIO()

        if is_code:
            file_code = codecs.open(filename, 'r', encoding='utf-8').read()
            file_code = self.parse_supers(file_code)
            code = CODE_RESOURCE_TEMPLATE % (resource_name, mimetype, file_code)
        elif is_text:
            code = TEXT_RESOURCE_TEMPLATE % (resource_name, mimetype, json.dumps(open(filename, 'r').read()))
        elif is_image:
            base64.encode(open(filename, 'rb'), data)
            code = IMAGE_RESOURCE_TEMPLATE % (resource_name, mimetype, mimetype, data.getvalue().replace('\n', '').replace('\r', ''))
        else: # Binaries
            base64.encode(open(filename, 'rb'), data)
            code = BINARY_RESOURCE_TEMPLATE % (resource_name, mimetype, data.getvalue().replace('\n', '').replace('\r', ''))

        return code
示例#16
0
    def save(self):
        if self._source:
            output = cStringIO.StringIO()
            self._source.seek(0)
            base64.encode(self._source, output)
            self._source.seek(0)
            data = {
                'base64': output.getvalue(),
                '_ContentType': self._type,
                'mime_type': self._type,
                'metaData': self._metadata,
            }
        elif self._url and self.metadata['__source'] == 'external':
            data = {
                'name': self._name,
                'ACL': self._acl,
                'metaData': self._metadata,
                'mime_type': self._type,
                'url': self._url,
            }
        else:
            raise ValueError

        response = client.post('/files/{0}'.format(self._name), data)
        content = utils.response_to_json(response)

        self._name = content['name']
        self._url = content['url']
        self.id = content['objectId']
        if 'size' in content:
            self._metadata['size'] = content['size']

        return self
示例#17
0
文件: binary.py 项目: edevil/soaplib
    def to_xml(cls, value, name='retval', nsmap=ns):
        '''This class method takes the data from the attachment and
        base64 encodes it as the text of an Element. An attachment can
        specify a filename and if no data is given, it will read the data
        from the file
        '''
        if value.__class__ is not Attachment:
            raise Exception("Do not know how to serialize class %s" %
                type(value))

        element = create_xml_element(name, nsmap)
        if value.data:
            # the data has already been loaded, just encode
            # and return the element
            element.text = base64.encodestring(value.data)
        elif value.fileName:
            # the data hasn't been loaded, but a file has been
            # specified
            data_string = cStringIO.StringIO()

            fileName = value.fileName
            file = open(fileName, 'rb')
            base64.encode(file, data_string)
            file.close()

            # go back to the begining of the data
            data_string.seek(0)
            element.text = str(data_string.read())
        else:
            raise Exception("Neither data nor a filename has been specified")

        return element
示例#18
0
def binary_diff(old_filename, old_lines, new_filename, new_lines, to_file):
    temp = StringIO()
    internal_diff(old_filename, old_lines, new_filename, new_lines, temp,
                  allow_binary=True)
    temp.seek(0)
    base64.encode(temp, to_file)
    to_file.write('\n')
示例#19
0
    def __shell(self):
        #self.cliente.setblocking(0)
        self.cliente.settimeout(50)
 
        while True:
            cmd = raw_input(V + "root@root-PC:~$ " + C)
 
            if cmd == "salir":
                break
 
            # Encodeamos y pickleamos
            try:
                cmd = dumps(encode(cmd))
            except Exception as e:
                print R + " [!]" + N + " Error al codificar: " + C + str(e) + B
                continue
 
            # Enviamos
            try:
                self.cliente.send(cmd)
            except socket.error as e:
                print R + " [!]" + N + " Error al enviar: " + C + str(e) + B
                continue
 
            # Recibimos
            stdout, stderr = self.__recibir()
 
            if stdout:
                print stdout[:-1]
 
            if stderr is not None:
                print stderr
 
        self.cliente.send(dumps(encode("salir")))
        self.__salir()
def createTmpBase64(rLayer):
    tmpFile = tempfile.NamedTemporaryFile(prefix="base64", delete=False) 
    tmpFileName = tmpFile.name
#    try:
#      tmpFile = tempfile.NamedTemporaryFile(prefix="base64", delete=False)
#      infile = open(unicode(rLayer.source()))
#      tmpFileName = tmpFile.name
#      outfile = open(tmpFileName, 'w')
#      base64.encode(infile,outfile)
#      outfile.close()
#      outfile =  open(tmpFileName, 'r')
#      base64String = outfile.read()
#      outfile.close()
#      os.remove(tmpFile.name)
    if rLayer.dataProvider().name() == 'ogr' or rLayer.dataProvider().name() == 'gdal':
        infile = open(rLayer.source())
        outfile = tmpFile #open(tmpFileName, 'w')
        base64.encode(infile,outfile)
        outfile.close()
        infile.close()
        outfile =  open(tmpFileName, 'r')
        base64String = outfile.read()
        outfile.close()
        os.remove(tmpFileName)
        return base64String
    else:
        QMessageBox.critical(None, QApplication.translate("QgsWps",'Error'),  QApplication.translate("QgsWps",'Datatype %s of layer %s is not supported!' % (rLayer.dataProvider().name(),  rLayer.name())))
        return ''
示例#21
0
文件: Messaging.py 项目: rbe/dmerce
 def AddAttachment(self):
     attach = self.__m.nextpart()
     attach.addheader("Content-Transfer-Encoding", "base64")
     attach.addheader("Content-Disposition", 'attachment; filename="%s"' % filename)
     f = attach.startbody('application/octet-stream; name="%s"' % filename)
     attach.flushheaders()
     base64.encode(open(path + filename, "r"), f)
示例#22
0
def generateResponse(msg,outputList):
	doc = xml.dom.minidom.parseString(msg)
	job=doc.getElementsByTagName("job")[0]
	id=job.getAttribute("id")
	owner=job.getAttribute("owner")
	f= '<job id="' + id + '" owner="' + owner + '">'
	previousPath=""
	numOutputs = 0
	for file in outputList:
		if not os.path.isfile(file):
			continue
		numOutputs += 1
		parts= file.split("/")
		path="/".join(parts[:-1])
		out=open(file+'.64','w')
		base64.encode(open(file,'r'),out)
		out.flush()
		out.close()
		out=open(file+'.64','r')
		encoded=out.read().strip()
		out.close()
		if (path != previousPath):
			if (previousPath !=""):	f+="</folder>"
			f += '\t<folder path="' + path  + '">\n'
		f += '\t\t<output filename="'+parts[-1]+'">'+encoded +'</output>\n'
	if numOutputs > 0:
		f+='</folder>\n'
	f+='</job>'
	return f
示例#23
0
def create_blobbone(directory, filename):
    """
    Create an autoextracting python executable containing the given data.
    Tested with files up to 20 MB !
    :param directory: the directory to compress
    :param filename: the target filename for the compressed data.
    """
    tar_obj = StringIO.StringIO()
    tar = tarfile.open(mode='w:gz', fileobj=tar_obj)
    tar.add(directory, arcname='')
    tar.close()
    tar_obj.seek(0)

    header_code = "import tarfile, base64, os, StringIO\n"
    uncompacting_code = (
    "encoded_obj = StringIO.StringIO()\n"
    "tar_obj = StringIO.StringIO()\n"
    "encoded_obj.write(blob)\n"
    "encoded_obj.seek(0)\n"
    "base64.decode(encoded_obj, tar_obj)\n"
    "tar_obj.seek(0)\n"
    "tar = tarfile.open('r:gz', fileobj=tar_obj)\n"
    "tar.extractall(path='%s')\n"
    "tar.close()\n" % os.path.join('.', os.path.basename(directory)))

    with open(filename, 'wb') as f:
        f.write(header_code)
        f.write('blob = r"""')
        base64.encode(tar_obj, f)
        f.write('"""\n')
        f.write(uncompacting_code)
示例#24
0
def base64Enc(inf,outf):
    inf=open(inf,"r")
    outf=open(outf,"wb")
    base64.encode(inf,outf)
    #for l in inf:
    #    outf.write(base64.b64encode(l)+"\n")
    outf.close()
    inf.close()
示例#25
0
    def emailAttachment(self,subject):
        """
        It uses the MIMEWriter,StringIO and base64 module for creating the subject of the mail,
        also defining the body of the mail and attaching the file and encoding the mail with
        base64 encrytion technique for security reasons
        """
        message = StringIO.StringIO()
        writer = MimeWriter.MimeWriter(message)
        writer.addheader('Subject', subject)
        writer.startmultipartbody('mixed')

        # start off with a text/plain part
        try :
            part = writer.nextpart()
            body = part.startbody('text/plain')
            body.write('\n\rThe Result is stored at the path %s\n\rRegards, \n\rNextone-SIT' %self.path)
        except :
            self.log.error("Exception : Error in the subject part of the mail to be sent")
            raise EmailAttachError("Exception :Error in the subject part of the mail ")

        # now add an Attachment
        try :
            part = writer.nextpart()
            part.addheader('Content-Transfer-Encoding', 'base64')
            part.addheader('Content-Disposition', 'attachment; filename %s' % self.path)
            body = part.startbody('application/Octet-Stream; name=%s' % self.path)
            base64.encode(open(self.path, 'r'), body)
        except :
            self.log.error("Exception : Error in the body part of the mail to be sent")
            raise EmailAttachError("Exception :Error in the body part of the mail ")
          

        # finish off
        writer.lastpart()
        # send the mail
        try :
            s_toaddrs = string.join(self.toaddrs,",")
            # For Ticket 34247
            message_getvalue = message.getvalue() + s_toaddrs
        except :
            self.log.error("Error : The to-address %s is errorneous" %self.toaddrs)
            raise EmailAttachError("Exception : The toaddress is errorneous")

        smtp = smtplib.SMTP("%s" %self.mailserver)
        # Added for ticket 34247
        try :
            smtp.login(self.login,self.passwd)
        except :
            self.log.error("Error: The login function is not able to Authenticate Login or password")
            raise EmailAttachError("Exception :The value assigned to login %s or passwd %s is errorneous" %(self.login,self.passwd))
            
        try :
            smtp.sendmail(self.fromaddr,self.toaddrs,message_getvalue)
        except :
            self.log.error("Exception : The value assigned to to-addressess %s and from-address %s is errorneous" %(self.toaddrs,self.fromaddr))
            raise EmailAttachError("Exception :The value assigned to to-addressess %s and from-address %s is errorneous" %(s_toaddrs,self.fromaddr))

        smtp.quit()
 def get_file(self, filename):
     """Retrive file from test data"""
     path = addons.get_module_resource('async_move_line_importer',
                                       'tests', 'data', filename)
     with open(path) as test_data:
         with tempfile.TemporaryFile() as out:
             base64.encode(test_data, out)
             out.seek(0)
             return out.read()
示例#27
0
def make_base64():
    input  = open('ant.tar.gz', mode='rb')
    output = open('ant.tar.gz.base64', 'wb')

    try:
        base64.encode(input, output)
    finally:
        input.close()
        output.close()
示例#28
0
 def encode_file(email_filename, file_path):
     if fake:
         email_filename += FAKE_EXTENSION
     maintype, encoding = mimetypes.guess_type(email_filename)
     if not maintype:
         maintype = 'application/octet-stream'
     fhmail.write(sub_header % {'maintype':maintype, 'filename':email_filename})
     if verbose: print 'Converting+writing base64 to "%s" ...' % temp_email_file
     base64.encode(file(file_path,'rb'),fhmail)
示例#29
0
def dump_manager_deployment():
    name = 'manager'
    file_obj = BytesIO()
    output = StringIO()
    with tarfile.open(fileobj=file_obj, mode='w:gz') as tar:
        tar.add(os.path.join(_workdir(), name),
                arcname=name)
    file_obj.seek(0)
    base64.encode(file_obj, output)
    return output.getvalue()
示例#30
0
 def _get_original(self, image_path):
     try:
         with open(image_path, 'rb') as f:
             buffer = StringIO()
             base64.encode(f, buffer)
     except Exception:
         return {'code':500, 'json':{'error':True, 'reason':"Failed to get image"}}
     else:
         headers = {'Content-Type':"application/octet-stream"}
         return {'code':200, 'headers':headers, 'base64':buffer.getvalue()}
示例#31
0
def encode_password(shortcode, passkey, timestamp):
    """Generate and return a base64 encoded password for online access.
    """
    return base64.encode(shortcode + passkey + timestamp)
示例#32
0
 def convert_img(self, path):
     stream = BytesIO()
     base64.encode(self.zf.open('word/' + path), stream)
     stream.seek(0)
     return self.src_attr % (path[:-3],
                             stream.read().decode('unicode_escape'))
示例#33
0
def base64Encode(data):
    return base64.encode(data)
 def encrypt(self, val):
     return base64.encode(val)
示例#35
0
def reactToAMQPMessage(message, send_back):
    """
    React to given (AMQP) message. `message` is expected to be
    :py:func:`collections.namedtuple` structure from :mod:`.structures` filled
    with all necessary data.

    Args:
        message (object): One of the request objects defined in
                          :mod:`.structures`.
        send_back (fn reference): Reference to function for responding. This is
                  useful for progress monitoring for example. Function takes
                  one parameter, which may be response structure/namedtuple, or
                  string or whatever would be normally returned.

    Returns:
        object: Response class from :mod:`structures`.

    Raises:
        ValueError: if bad type of `message` structure is given.
    """
    user_db = _UserHandler(
        conf_path=settings.ZEO_CLIENT_CONF_FILE,
        project_key=settings.PROJECT_KEY,
    )
    status_db = _StatusHandler(
        conf_path=settings.ZEO_CLIENT_CONF_FILE,
        project_key=settings.PROJECT_KEY,
    )
    cache_db = _CacheHandler(
        conf_path=settings.ZEO_CLIENT_CONF_FILE,
        project_key=settings.PROJECT_KEY,
    )

    if _instanceof(message, SaveLogin):
        return user_db.add_user(
            username=message.username,
            pw_hash=message.password_hash,
        )

    elif _instanceof(message, RemoveLogin):
        status_db.remove_user(username=message.username)
        return user_db.remove_user(username=message.username)

    elif _instanceof(message, CacheTick):
        if user_db.is_empty():
            return AfterDBCleanupRequest()

        if cache_db.is_empty():
            return

        # this will pop the RequestInfo from `cache_db` if success
        with cache_db.pop_manager() as cached_request:
            cached_file = cached_request.get_file_obj()

            # convert the file to base64 memory-efficient way
            with tempfile.TemporaryFile() as tmp_file:
                base64.encode(cached_file, tmp_file)

                tmp_file.seek(0)
                req = UploadRequest(
                    username=cached_request.username,
                    rest_id=cached_request.rest_id,
                    b64_data=tmp_file.read(),
                    metadata=cached_request.metadata,
                )

            cached_file.close()

        return req

    elif _instanceof(message, StatusUpdate):
        status_db.save_status_update(
            rest_id=message.rest_id,
            message=message.message,
            timestamp=message.timestamp,
            book_name=message.book_name,
            pub_url=message.pub_url,
        )
        return

    raise ValueError("'%s' is unknown type of request!" % str(type(message)))
示例#36
0
#! /usr/bin/env python3
"""
This script is only for unittests, And not to be used for production.

"""

import sys
import io
import pickle
import base64

if __name__ == '__main__':

    buffer = io.BytesIO()

    data = {'cpu': 40, 'memory': 50}

    # Dumping
    pickle.dump(data, buffer)

    # Encrypting
    # TODO: encrypt data using pycrypto, not required, because the connection is made by SSH.

    # Encode the binary as base64
    buffer.seek(0)
    base64.encode(buffer, sys.stdout.buffer)
示例#37
0
import base64

msg = input("message:")

print("original", msg)
print("base64", base64.encode(msg.encode())
 def getFilePath(self, filepath):
     with open(filepath, 'rb') as test_data:
         with tempfile.TemporaryFile() as out:
             base64.encode(test_data, out)
             out.seek(0)
             return filepath, out.read()
示例#39
0
def continue_app():
    global user_name, demo_name, demo_novel, demo_new
    global num_vis, demo_rate, demo_comm, image_file

    datasentScreen = appuifw.Text()
    datasentScreen.add(u'Great job, ' + user_name + u'!')
    datasentScreen.add(u'\n\nWe will slog your data now.')
    datasentScreen.add(u'\n\nThis might take a couple of mins.')
    datasentScreen.add(u'\nData will be encoded, wrapped in xml, and sent.')

    appuifw.app.body = datasentScreen

    user_name_filtered = user_name.replace(',', '_')
    demo_name_filtered = demo_name.replace(',', '_')
    demo_novel_filtered = demo_novel.replace(',', '_')
    demo_new_filtered = demo_new.replace(',', '_')
    demo_comm_filtered = demo_comm.replace(',', '_')

    for chr in user_name_filtered:
        if ord(chr) not in range(0, 128):
            user_name_filtered = user_name_filtered.replace(chr, '_')

    for chr in demo_name_filtered:
        if ord(chr) not in range(0, 128):
            demo_name_filtered = demo_name_filtered.replace(chr, '_')

    for chr in demo_novel_filtered:
        if ord(chr) not in range(0, 128):
            demo_novel_filtered = demo_novel_filtered.replace(chr, '_')

    for chr in demo_new_filtered:
        if ord(chr) not in range(0, 128):
            demo_new_filtered = demo_new_filtered.replace(chr, '_')

    for chr in demo_comm_filtered:
        if ord(chr) not in range(0, 128):
            demo_comm_filtered = demo_comm_filtered.replace(chr, '_')

    continueScreen = appuifw.Text()
    continueScreen.add(u'Are you done, ' + user_name + u'?')
    continueScreen.add(
        u'\n\nIf so, please return the equipment back to UrbanCENS.')
    continueScreen.add(u' If not, we will let you document another demo.')
    continueScreen.add(u'\n\n\nAre you done?')
    #pos = continueScreen.get_pos()
    continueScreen.add(u'\nYes (pencil) or No (c)')
    continueScreen.add(u'\nPress and hold the key.')
    #continueScreen.set_pos(pos)
    continueScreen.bind(EKeyEdit, done)
    continueScreen.bind(EKeyBackspace, not_done)

    date_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

    image_output = StringIO.StringIO()
    image_input = open(image_file, "rb")
    base64.encode(image_input, image_output)
    image_data = image_output.getvalue()

    #print 'Image Base 64 Time %0.3fms' % ((t2-t1)*1000.)
    datasentScreen.add(u'\n\nData encoded...')

    xml = '<?xml version="1.0" encoding="UTF-8"?>'
    xml += '<table>'
    xml += '<row>'
    xml += '<field name="User_Name">' + user_name_filtered + '</field>'
    xml += '<field name="Demo_Name">' + demo_name_filtered + '</field>'
    xml += '<field name="Demo_Novel">' + demo_novel_filtered + '</field>'
    xml += '<field name="Demo_New">' + demo_new_filtered + '</field>'
    xml += '<field name="Num_Of_Visitors">' + str(num_vis) + '</field>'
    xml += '<field name="Rate_Of_Demo">' + str(demo_rate) + '</field>'
    xml += '<field name="Comment">' + demo_comm_filtered + '</field>'
    xml += '<field name="Image">' + image_data + '</field>'
    #xml += '<field name="Image">' + 'abc' + '</field>'
    xml += '<field name="Date_Time">' + date_time + '</field>'
    xml += '</row>'
    xml += '</table>'

    params = {}
    params['email'] = '*****@*****.**'
    params['pw'] = 'intel'
    params['data_string'] = xml
    params['type'] = 'xml'
    params['project_id'] = "39"
    params['tableName'] = 'ubicompDemo'

    params = urllib.urlencode(params)

    #print 'URL Encode Time %0.3fms' % ((t2-t1)*1000.)
    datasentScreen.add(u'\nXML encoded...')

    headers = {}
    headers['Content-type'] = 'application/x-www-form-urlencoded'
    headers['Accept'] = 'text/plain'

    conn = httplib.HTTPConnection("sensorbase.org")
    conn.request("POST", "/alpha/upload.php", params, headers)
    response = conn.getresponse()
    responseText = response.read()
    conn.close()

    #print 'HTTP Post Time %0.3fms' % ((t2-t1)*1000.)
    datasentScreen.add(u'\nHTTP POST...')
    e32.ao_sleep(1)

    #print responseText

    appuifw.app.body = continueScreen
示例#40
0
 def verification_key(self):
     ""
     return encode("%s,%s,%s" % (self.uid, self.id, self.pw))
示例#41
0
def onPbemSend(argsList):
    import smtplib, MimeWriter, base64, StringIO

    szToAddr = argsList[0]
    szFromAddr = argsList[1]
    szSubject = argsList[2]
    szPath = argsList[3]
    szFilename = argsList[4]
    szHost = argsList[5]
    szUser = argsList[6]
    szPassword = argsList[7]

    print 'sending e-mail'
    print 'To:', szToAddr
    print 'From:', szFromAddr
    print 'Subject:', szSubject
    print 'Path:', szPath
    print 'File:', szFilename
    print 'Server:', szHost
    print 'User:'******'host or address empty'
        return 1

    message = StringIO.StringIO()
    writer = MimeWriter.MimeWriter(message)

    writer.addheader('To', szToAddr)
    writer.addheader('From', szFromAddr)
    writer.addheader('Subject', szSubject)
    writer.addheader('MIME-Version', '1.0')
    writer.startmultipartbody('mixed')

    part = writer.nextpart()
    body = part.startbody('text/plain')
    body.write('CIV4 PBEM save attached')

    part = writer.nextpart()
    part.addheader('Content-Transfer-Encoding', 'base64')
    szStartBody = "application/CivBeyondSwordSave; name=%s" % szFilename
    body = part.startbody(szStartBody)
    base64.encode(open(szPath + szFilename, 'rb'), body)

    # finish off
    writer.lastpart()

    # send the mail
    try:
        smtp = smtplib.SMTP(szHost)
        if len(szUser) > 0:
            smtp.login(szUser, szPassword)
        smtp.sendmail(szFromAddr, szToAddr, message.getvalue())
        smtp.quit()
    except smtplib.SMTPAuthenticationError, e:
        CyInterface().addImmediateMessage(
            "Authentication Error: The server didn't accept the username/password combination provided.",
            "")
        CyInterface().addImmediateMessage(
            "Error %d: %s" % (e.smtp_code, e.smtp_error), "")
        return 1
示例#42
0
def create_id(req, pub, priv):
    return encode(
        hashlib.sha256(str(getrandbits(2048))).digest(),
        choice(['rA', 'aZ', 'gQ', 'hH', 'hG', 'aR', 'DD'])).rstrip("==")
 def dump(obj, fp):
     input_fp = io.BytesIO(obj)
     _base64.encode(input_fp, fp)
示例#44
0
 def ECB_encode_date(self,key="BuctBuct",iv="BuctBuct"):
     data=self.read_date()
     k=des(key,ECB,iv,pad=None,padmode=PAD_PKCS5)
     d=k.encrypt(data)
     assert k.decrypt(d,padmode=PAD_PKCS5) == data
     return base64.encode(d)
 def getFile(self, path):
     with open(path) as test_data:
         with tempfile.TemporaryFile() as out:
             base64.encode(test_data, out)
             out.seek(0)
             return path, out.read()
示例#46
0
    def process_block(self, block_text, user, block_id, **params):
        def int_or_none(val):
            """Returns an integer or none. May pass anything
            """
            try:
                ret = int(val)
            except ValueError:
                ret = None
            return ret

        def int_or_default(val, default=0):
            """ Returns int or a given default
            """
            try:
                ret = int(val)
            except ValueError:
                ret = default

            return ret

        def float_or_default(val, default=0.0):
            """ Returns float or a given default
            """
            try:
                ret = float(val)
            except ValueError:
                ret = default

            return ret

        tokens = self.parse_block(block_text)

        # get our tokens
        db_name = tokens.get(self.ATTR_DB,
                             settings.DATABASE_DEFAULT_ALIAS).strip()

        # chart title. empty by default
        chart_title = tokens.get(self.ATTR_TITLE, '').strip()

        # chart width and height in pixels. Beware, the user
        # inevitably will write anything but valid numbers
        chart_width = int_or_none(tokens.get(self.ATTR_WIDTH, '').strip())
        chart_height = int_or_none(tokens.get(self.ATTR_HEIGHT, '').strip())
        ylabel = tokens.get(self.ATTR_YLABEL, '').strip()
        xlabel = tokens.get(self.ATTR_XLABEL, '').strip()
        font_size = int_or_default(
            tokens.get(self.ATTR_FONT_SIZE, self.DEFAULT_FONT_SIZE))
        if font_size <= 1:
            font_size = self.DEFAULT_FONT_SIZE
        if font_size >= 100:
            font_size = self.DEFAULT_FONT_SIZE

        # grid
        grid = tokens.get(self.ATTR_GRID, 'none').strip().lower()
        if grid not in ('x', 'y', 'both', 'none'):
            grid = 'none'

        # also check for negative numbers or zeroes
        if (chart_width is not None) and (chart_height is not None):
            if (chart_width <= 0) or (chart_height <= 0):
                # both none
                chart_width = None
                chart_height = None
        else:
            # some of them are none
            # set both to none
            chart_width = None
            chart_height = None

        # xtick rotation
        x_tick_rotation = int_or_default(
            tokens.get(self.ATTR_XTICK_ROTATION, self.DEFAULT_XTICK_ROTATION))
        if x_tick_rotation > 90:
            x_tick_rotation = 90

        if x_tick_rotation < -90:
            x_tick_rotation = -90

        # legend
        legend_str = tokens.get(self.ATTR_LEGEND,
                                self.ATTR_VALUE_NO).strip().lower()
        if legend_str not in (self.ATTR_VALUE_NO, self.ATTR_VALUE_YES):
            legend_str = self.ATTR_VALUE_NO

        # legend location
        legend_location = tokens.get(
            self.ATTR_LEGEND_LOCATION,
            self.DEFAULT_LEGEND_LOCATION).strip().lower()
        # this is not necessary, matplotlib does it by himself,
        # yet we check it here to avoid warnings on stdout
        if legend_location not in self.VALID_LEGEND_LOCATIONS:
            legend_location = self.DEFAULT_LEGEND_LOCATION

        # bar width
        bar_width = float_or_default(
            tokens.get(self.ATTR_BAR_WIDTH, self.DEFAULT_BAR_WIDTH),
            self.DEFAULT_BAR_WIDTH)
        if bar_width > self.MAX_BAR_WIDTH:
            bar_width = self.MAX_BAR_WIDTH

        if bar_width < self.MIN_BAR_WIDTH:
            bar_width = self.MIN_BAR_WIDTH

        # stacked
        stacked = tokens.get(self.ATTR_STACKED,
                             self.ATTR_VALUE_NO).strip().lower()
        if stacked not in (self.ATTR_VALUE_YES, self.ATTR_VALUE_NO):
            stacked = self.ATTR_VALUE_NO

        con = None
        # if anything, we rethrow the exception
        try:
            db = settings.DATABASES.get(db_name, None)
            # non-existent database - exception
            if db == None:
                raise DwException(db_name, "Unknown database %s." % db_name)

            true_sql = tokens.sqltext

            # now that we have a sql, try to replace parameters in it.
            # Parameter looks like ${param_name}
            p = re.compile(u'\$\{[a-z]+[0-9]*\}')
            # get the list of all mentioned params
            lst = p.findall(true_sql)
            # loop through all these variables and try to replace
            # them with params passed to us
            for item in lst:
                stripped_item = item[2:-1]
                # TODO check for default value here
                value = 'None'
                if stripped_item in params:
                    value = params[stripped_item]
                    value = urllib.unquote(value)
                # replace it
                true_sql = true_sql.replace(item, value)

            # get a connection from somewhere
            con = self.get_con(db)
            cur = con.cursor()
            cur.execute(true_sql)
            row = cur.fetchone()

            # TODO Now if row is None it means the set is empty
            # in this case we have to generate a stub
            # for now assume the data is present

            # Get columns for labels
            # We need at least two columns
            # first one is x axis, column heading does not matter
            # the second is y axis values
            # the third one is the color of values
            # if there is no third column,  use default color
            # which is gray
            columns = cur.description
            col_count = len(columns)
            if col_count < 2:
                raise DwException(db_name,
                                  "There should be at least two columns")

            # second column should be a number. Don't test it here.
            # we will try to test each value

            # every odd column is value
            # every even column is color

            # Now traverse all the rows
            # x_tick_marks is col 0 values
            x_tick_marks = list()

            # y_values is an array of bar heights
            # stored in the second column, fourth etc. columns

            # this is array of arrays
            y_values_array = list()
            y_colors_array = list()
            for i in range(1, col_count):
                is_value = i % 2 == 1
                is_color = i % 2 == 0
                if is_value is True:
                    y_values = list()
                    y_values_array.append(y_values)
                    # add color array in any case
                    y_colors = list()
                    y_colors_array.append(y_colors)
                #if is_color is True:
                #y_colors_array.append(y_colors)

            #y_values = list()

            # bar_colors is an array of bar colors
            # stored in the third column
            # if there is no third column,
            # assume the color is grey
            #y_colors = list()

            # Now traverse. If row count is too big,
            # just stop where it exceeds the maximum allowed number
            # which we set to 100 for now
            curr_bar = 0

            color_converter = ColorConverter()

            while row is not None:
                # tick mark as unicode
                mark = row[0]
                if mark is None:
                    mark = ''
                if type(mark) is str:
                    mark = mark.decode('utf-8')
                elif type(mark) is unicode:
                    pass
                else:
                    # TODO maybe a number
                    # we need to convert it to a string
                    # according to it's type (integer, decimal, float)
                    # date, time, datetime
                    mark = unicode(mark)

                x_tick_marks.append(mark)

                # collect values and colors
                for i in range(1, col_count):
                    is_value = i % 2 == 1
                    is_color = i % 2 == 0

                    # value itself. plot does not support Decimal,
                    # need to convert to float
                    if is_value is True:
                        value_index = i / 2
                        y_values = y_values_array[value_index]

                        value = row[i]
                        tp = type(value).__name__
                        if tp is 'Decimal':
                            value = float(value)

                        # all nulls are replaced with zeroes
                        if value is None:
                            value = 0.0

                        y_values.append(value)

                        # now colors
                        color_col = i + 1

                        y_colors = y_colors_array[value_index]

                        # color himself +1 col if exists
                        color_str = None

                        if color_col < len(row):
                            color_str = self.make_unicode_or_none(row[i + 1])

                        if color_str is None:
                            color_str = self.DEFAULT_BAR_COLOR

                        # Now try to make a color. If it's unsuccessful,
                        # it returns an exception
                        try:
                            color_rgba = color_converter.to_rgba(color_str)
                        except Exception, e:
                            #sys.stderr.write("Color error: %s\n" % color_str)
                            color_rgba = color_converter.to_rgba(
                                self.USER_ERROR_BAR_COLOR)

                        # Hopefully, color_rgba is now set
                        # to a tuple of R, G, B and Alpha
                        y_colors.append(color_rgba)

                # increment row counter
                curr_bar += 1
                if curr_bar >= self.MAX_BARS:
                    break
                else:
                    row = cur.fetchone()

            # Now we have collected all the values, marks and colors

            con.close()
            con = None

            # Build a graph

            # 80 dots per inch. So 7 x 4 inches will make 560 x 320 pixels
            if (chart_width > 0) and (chart_height > 0):
                fig = plt.figure(figsize=[chart_width / 80, chart_height / 80],
                                 dpi=80)
            else:
                fig = plt.figure()

            ax = fig.add_subplot(111)

            # data size
            #N = len(curr_bar) # number of bar groups - scale units for x axis = number of query rows

            # arrange N between 0 and N-1. Returns an array
            ind = np.arange(curr_bar)  # distribute equally

            # todo expose bar width
            if stacked == self.ATTR_VALUE_NO:
                width = bar_width / len(
                    y_values_array)  # width of the bars (measures?)
            else:
                width = bar_width

            min_value = 0
            max_value = 0

            for y_values in y_values_array:
                # remember it may be negative
                temp_min_value = min(y_values)
                min_value = min(temp_min_value, min_value)
                if min_value > 0:
                    min_value = 0

                temp_max_value = max(y_values)
                max_value = max(temp_max_value, max_value)
                if max_value < 0:
                    max_value = 0

            # now add additional 10% of min-max range at the top
            value_range = max_value - min_value
            top_y_axis_margin = value_range * self.DEFAULT_TOP_Y_AXIS_MARGIN

            # no margin for bottom
            bottom_y_axis_margin = 0

            # if we have negative bars, set margin below too
            if min_value < 0:
                bottom_y_axis_margin = top_y_axis_margin

            # here we set final max and min y axis values to account for our margins
            max_y_axis_value = max_value + top_y_axis_margin
            min_y_axis_value = min_value - bottom_y_axis_margin

            # cycle through values and draw bars
            for i in range(len(y_values_array)):
                y_values = y_values_array[i]
                y_colors = y_colors_array[i]

                # bar labels
                # get a description
                # it's in columns 1,3,5 etc.
                # i=0 => col=1
                # i=1 => col=3
                col_index = i * 2 + 1
                col = columns[col_index]
                bar_label = col[0]
                if type(col[0]) is str:
                    bar_label = col[0].decode('utf-8')
                elif type(col[0]) is unicode:
                    bar_label = col[0]

                # The Drawing
                if stacked == self.ATTR_VALUE_NO:
                    rects1 = ax.bar(ind + i * width,
                                    y_values,
                                    width,
                                    color=y_colors,
                                    label=bar_label)
                else:
                    rects1 = ax.bar(ind,
                                    y_values,
                                    width,
                                    color=y_colors,
                                    label=bar_label)

            ax.set_xlim(-1 + bar_width, len(ind))

            ax.set_ylim(min_y_axis_value, max_y_axis_value)

            # draw horizontal grid lines
            if grid <> 'none':
                ax.grid(which='major', axis=grid)

            if ylabel <> '':
                plt.ylabel(ylabel, fontsize=font_size)

            if xlabel <> '':
                plt.xlabel(xlabel, fontsize=font_size)

            ax.set_title(chart_title, fontsize=font_size)

            # font for y major ticks
            for tick in ax.yaxis.get_major_ticks():
                tick.label.set_fontsize(font_size)

            # ticks on top and bottom
            ax.set_xticks(ind + bar_width / 2)

            #canvas = FigureCanvasAgg(fig)

            x_tick_labels = ax.set_xticklabels(x_tick_marks)

            plt.setp(x_tick_labels,
                     rotation=x_tick_rotation,
                     fontsize=font_size)

            # legend
            if legend_str == self.ATTR_VALUE_YES:
                ax.legend(loc=legend_location, prop={'size': font_size})

            plt.tight_layout()

            tempfiledir = cherrypy.config['dwwiki.tempfiledir']
            tempfile.tempdir = tempfiledir
            try:
                f = tempfile.NamedTemporaryFile(delete=False)
                # print graph to a temporary file
                # TODO we assume it prints png. Yet I don't know
                # why. Is it the default format?
                #canvas.print_figure(f)
                #canvas.print_png(f)
                fig.savefig(f)
                f.close()

                # Now all we need is to encode the file in base64,
                # then serve it as an <img>
                input_file = open(f.name, 'rb')
                output_file = cStringIO.StringIO()
                base64.encode(input_file, output_file)
                # we have it as a png string
                #yield '<img alt="graph" src="data:image/png;base64,'
                yield '<img alt="graph" src="data:image/png;base64,'
                yield output_file.getvalue()
                yield "\"/>\n"
                output_file.close()
                input_file.close()
            finally:
                os.remove(f.name)
示例#47
0
    def dump_stage3(indenter, node, use_references, name=None):
        cls = type(node)
        if cls == types.InstanceType: cls = node.__class__ # For old style stuff

        if name is None: name_key = ""
        else: name_key = " label=" + quoteattr(name)

        if issubclass(cls, str):
            indenter.write_line("<str%s>%s</str>" % (name_key, escape(node)))
        elif issubclass(cls, float):
            indenter.write_line("<float%s>%s</float>" % (name_key, str(node)))
        elif issubclass(cls, bool):
            indenter.write_line("<bool%s>%s</bool>" % (name_key, str(node)))
        elif issubclass(cls, int):
            indenter.write_line("<int%s>%s</int>" % (name_key, str(node)))
        elif cls == Undefined:
            pass
        elif cls == list:
            indenter.write_line("<list%s>" % name_key, 1)
            for item in node: dump_stage3(indenter, item, use_references)
            indenter.write_line("</list>", -1)
        elif cls == dict:
            indenter.write_line("<dict%s>" % name_key, 1)
            for key, val in node.iteritems():
                if not isinstance(key, str):
                    raise FilterError("ZML supports only strings as dictionary keys.")
                dump_stage3(indenter, val, use_references, key)
            indenter.write_line("</dict>", -1)
        elif cls == tuple:
            indenter.write_line("<tuple%s>" % name_key, 1)
            for item in node: dump_stage3(indenter, item, use_references)
            indenter.write_line("</tuple>", -1)
        elif cls == numpy.ndarray:
            shape = node.shape
            indenter.write_line("<array%s>" % name_key, 1)
            indenter.write("<shape>")
            for value in node.shape:
                indenter.write("%s " % value)
            indenter.write("</shape>", True)
            indenter.write("<cells>")
            for value in numpy.ravel(node):
                indenter.write("%s " % value)
            indenter.write("</cells>", True)
            indenter.write_line("</array>", -1)
        elif cls == StringIO.StringIO:
            indenter.write("<binary%s>" % name_key)
            node.seek(0)
            base64.encode(node, f)
            indenter.write("</binary>", True)
        elif cls == Translation:
            indenter.write_line("<translation%s>" % name_key, 1)
            dump_stage3(indenter, node.t, use_references, name="translation_vector")
            indenter.write_line("</translation>", -1)
        elif cls == Rotation:
            indenter.write_line("<rotation%s>" % name_key, 1)
            dump_stage3(indenter, node.r, use_references, name="rotation_matrix")
            indenter.write_line("</rotation>", -1)
        elif cls == Complete:
            indenter.write_line("<transformation%s>" % name_key, 1)
            dump_stage3(indenter, node.t, use_references, name="translation_vector")
            dump_stage3(indenter, node.r, use_references, name="rotation_matrix")
            indenter.write_line("</transformation>", -1)
        elif cls == UnitCell:
            indenter.write_line("<unit_cell%s>" % name_key, 1)
            dump_stage3(indenter, node.matrix, use_references, name="matrix")
            dump_stage3(indenter, node.active, use_references, name="active")
            indenter.write_line("</unit_cell>", -1)
        elif cls == Expression:
            indenter.write_line("<expression%s>%s</expression>" % (name_key, escape(node.code)))
        elif issubclass(cls, ModelObject):
            if node in identifiers:
                if use_references:
                    indenter.write_line("<reference to='%i' />" % identifiers[node])
                else:
                    indenter.write_line("<model_object%s id='%i' class='%s'>" % (name_key, identifiers[node], node.class_name()), 1)
                    for key, item in node.__getstate__().iteritems():
                        dump_stage3(indenter, item, key!="children", key)
                    indenter.write_line("</model_object>", -1)
        else:
            raise FilterError, "Can not handle node %s of class %s" % (node, cls)
示例#48
0
def iter2base(arr, b_conv):
    b_ips = bz2.compress(b"".join(map(b_conv, arr)))
    b_in, b_out = io.BytesIO(b_ips), io.BytesIO()
    base64.encode(b_in, b_out)
    return b_out.getvalue()
示例#49
0
# 	- Vulnerable to frequency analysis attacks, use scripts in 'addNoise' directory
#	  to add entropy to your cloaked payloads (must strip away prior to decloaking)
#	- Creates temporary Base64 file in local directory and deletes when finished,
#	  but does not do "secure delete" (potential digital forensics trail)

import os, sys, getopt, base64

array64 = list(
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/+=")
payloadB64File = "payloadB64.txt"

if (len(sys.argv) != 3):
    print "usage: cloakify.py <payloadFilename> <cipherFilename>"
    exit

else:
    base64.encode(open(sys.argv[1]), open(payloadB64File, "w"))

    with open(payloadB64File) as file:
        payloadB64 = file.read()

    with open(sys.argv[2]) as file:
        arrayCipher = file.readlines()

    for char in payloadB64:
        if char != '\n':
            print arrayCipher[array64.index(char)],

    if os.path.exists(payloadB64File):
        os.remove(payloadB64File)
示例#50
0
    def encode(self, out):
	import base64, StringIO
	out.write("<value><base64>\n")
	base64.encode(StringIO.StringIO(self.data), out)
	out.write("</base64></value>\n")
示例#51
0
import base64
import codecs
import binascii
from requests.utils import requote_uri
from urllib.parse import unquote

text = input("Enter text: ")
print("Text length:", len(text))
print('''
-------------------------------
            Base 64
-------------------------------
''')
print("Base64 decode (if any): ", base64.decode(text))
print("Base64 encode (if any): ", base64.encode(text))
print('''
-------------------------------
            Base 32
-------------------------------
''')
print("Base32 decode (if any): ", base32.decode(text))
print("Base32 encode (if any): ", base32.encode(text))
示例#52
0
y8PgwH8AfAxFzC0JzeAMtratAsC/ffwAAAD//wBlAJr/BGKAyCAA4AAAAvgeYTAwHd1kmQF5chkG
ABoMIHcL5xVpTfQbUqzlAAAErwAQBgAAEOClA5D9il08AEh/tUzdCBsXkbgACED+woQg8Si9VeqY
lODCn7lmF6NhnAEYgAAA/NMIAAAAAAD//2JgjLZgVGBg5Pv/Tvpc8hwGBjYGJADjHDrAwPzAjv/H
/Wf3PzCwtzcwHmBgYGcwbZz8wHaCAQMDOwMDQ8MCBgYOC3W7mp+f0w+wHOYxO3OG+e376hsMZjk3
AAAAAP//YmCMY2A4wMAIN5e5gQETPD6AZisDAwMDgzSDAAPjByiHcQMDAwMDg1nOze1lByRu5/47
c4859311AYNZzg0AAAAA//9iYGDBYihOIIMuwIjGL39/fwffA8b//xv/P2BPtzzHwCBjUQAAAAD/
/yLFBrIBAAAA//9i1HhcwdhizX7u8NZNzyLbvT97bfrMf/QHI8evOwcSqGUJAAAA//9iYBB81iSw
pEE170Qrg5MIYydHqwdDQRMrAwcVrQAAAAD//2J4x7j9AAMDn8Q/BgYLBoaiAwwMjPdvMDBYM1Tv
oJodAAAAAP//Yqo/83+dxePWlxl3npsel9lvLfPcqlE9725C+acfVLMEAAAA//9i+s9gwCoaaGMR
evta/58PTEWzr21hufPjA8N+qlnBwAAAAAD//2JiWLci5v1+HmFXDqcnULE/MxgYGBj+f6CaJQAA
AAD//2Ji2FrkY3iYpYC5qDeGgeEMAwPDvwQBBoYvcTwOVLMEAAAA//9isDBgkP///0EOg9z35v//
Gc/eeW7BwPj5+QGZhANUswMAAAD//2JgqGBgYGBgqEMXlvhMPUsAAAAA//8iYDd1AAAAAP//AwDR
w7IkEbzhVQAAAABJRU5ErkJggg==
'''))))
    return f


if __name__ == "__main__":
    # create font data chunk for embedding
    import base64, os, sys
    output = open(sys.argv[1], "wb")
    font = b"../Images/courB08"
    output.write(b"    f._load_pilfont_data(\n")
    output.write(b"         # " + os.path.basename(font) + b"\n")
    output.write(b"         BytesIO(base64.decodestring(b'''\n")
    base64.encode(open(font + b".pil", "rb"), output)
    output.write(b"''')), Image.open(BytesIO(base64.decodestring(b'''\n")
    base64.encode(open(font + b".pbm", "rb"), output)
    output.write(b"'''))))")
    output.close()
示例#53
0
 def create_file(repo, msg, new_file, branch, data):
     print(msg, new_file, branch)
     repo.create_file(message=msg,
                      content=base64.encode(msg),
                      path=new_file,
                      branch=branch)
示例#54
0
def makeSecret(password):
    salt = os.urandom(4)
    h = hashlib.sha1(password)
    h.update(salt)
    return "{SSHA}" + encode(h.digest() + salt)[:-1]
示例#55
0
def hash_pw(password, saltf=get_salt):
    salt = saltf()
    h = hashlib.sha1(password)
    h.update(salt)
    return "{SSHA}" + encode(h.digest() + salt).rstrip()
    def post(self):
        """
        Change password for a given user
        ---
        tags:
          - User Management

        parameters:
          - in: body
            name: body
            schema:
              required:
                - user
                - password
              properties:
                user:
                  type: string
                  description: SOCA user
                password:
                  type: string
                  description: New password to configure

        responses:
          200:
            description: Pair of username/token is valid
          203:
            description: Invalid username/token pair
          400:
            description: Malformed client input
        """
        parser = reqparse.RequestParser()
        parser.add_argument("user", type=str, location="form")
        parser.add_argument("password", type=str, location="form")
        args = parser.parse_args()
        user = args["user"]
        password = args["password"]
        if user is None or password is None:
            return errors.all_errors(
                "CLIENT_MISSING_PARAMETER",
                "user (str) and password (str) parameters are required")

        dn_user = "******" + user + ",ou=people," + config.Config.LDAP_BASE_DN
        enc_passwd = bytes(password, 'utf-8')
        salt = os.urandom(16)
        sha = hashlib.sha1(enc_passwd)
        sha.update(salt)
        digest = sha.digest()
        b64_envelop = encode(digest + salt)
        passwd = '{{SSHA}}{}'.format(b64_envelop.decode('utf-8'))
        new_value = passwd
        try:
            conn = ldap.initialize('ldap://' + config.Config.LDAP_HOST)
            conn.simple_bind_s(config.Config.ROOT_DN, config.Config.ROOT_PW)
            mod_attrs = [(ldap.MOD_REPLACE, "userPassword",
                          new_value.encode('utf-8'))]
            conn.modify_s(dn_user, mod_attrs)
            return {
                "success": True,
                "message": "Password updated correctly."
            }, 200

        except Exception as err:
            return errors.all_errors(type(err).__name__, err)
示例#57
0
def populate_foxml_datastream(foxml,
                              pid,
                              datastream,
                              base_url='http://localhost:8080/fedora',
                              archival=False,
                              inline_to_managed=False,
                              cursor=None):
    """
    Add a FOXML datastream into an lxml etree.
    """
    datastream_attributes = {
        'ID': datastream['dsid'],
        'STATE': datastream['state'],
        'CONTROL_GROUP': datastream['control_group'],
        'VERSIONABLE': str(datastream['versioned']).lower(),
    }
    with foxml.element('{{{0}}}datastream'.format(FOXML_NAMESPACE),
                       datastream_attributes):
        versions = list(datastream_reader.old_datastreams(datastream['id']))
        versions.append(datastream)

        for index, version in enumerate(versions):
            datastream_reader.resource(version['resource'], cursor=cursor)
            resource_info = cursor.fetchone()
            datastream_reader.mime(resource_info['mime'], cursor=cursor)
            mime_info = cursor.fetchone()
            try:
                created = format_date(version['committed'])
            except KeyError:
                created = format_date(datastream['created'])

            version_attributes = {
                'ID': '{}.{}'.format(datastream['dsid'], index),
                'LABEL': version['label'] if version['label'] else '',
                'CREATED': created,
                'MIMETYPE': mime_info['mime'],
            }
            if datastream['control_group'] != 'R':
                size = filestore.uri_size(resource_info['uri'])
                version_attributes['SIZE'] = str(size)

            with foxml.element(
                    '{{{0}}}datastreamVersion'.format(FOXML_NAMESPACE),
                    version_attributes):

                datastream_reader.checksums(version['resource'], cursor=cursor)
                checksums = cursor.fetchall()
                for checksum in checksums:
                    foxml.write(
                        etree.Element(
                            '{{{0}}}datastreamDigest'.format(FOXML_NAMESPACE),
                            {
                                'TYPE': checksum['type'],
                                'DIGEST': checksum['checksum']
                            }))

                if datastream['control_group'] == 'X' and (
                        not inline_to_managed):
                    content_element = etree.Element(
                        '{{{0}}}xmlContent'.format(FOXML_NAMESPACE))
                    uri = filestore.resolve_uri(resource_info['uri'])
                    xml_etree = etree.parse(uri)
                    content_element.append(xml_etree.getroot())
                    foxml.write(content_element)
                elif datastream['control_group'] in ['M', 'X'] and archival:
                    uri = filestore.resolve_uri(resource_info['uri'])
                    with open(uri, 'rb') as ds_file:
                        with foxml.element('{{{0}}}binaryContent'.format(
                                FOXML_NAMESPACE)):
                            base64.encode(ds_file, foxml)
                else:
                    if datastream['control_group'] == 'R':
                        content_attributes = {
                            'TYPE': 'URL',
                            'REF': resource_info['uri'],
                        }
                    else:
                        content_attributes = {
                            'TYPE':
                            'INTERNAL_ID',
                            'REF': ('{}/objects/{}/datastreams/{}/'
                                    'content?asOfDateTime={}').format(
                                        base_url, pid, datastream['dsid'],
                                        created),
                        }

                    foxml.write(
                        etree.Element(
                            '{{{0}}}contentLocation'.format(FOXML_NAMESPACE),
                            content_attributes))
示例#58
0
 def encode(self, out):
     out.write('<value><base64>\n')
     base64.encode(StringIO.StringIO(self.data), out)
     out.write('</base64></value>\n')
#!/home/dacastrom/Documents/django/test2/myvenv/bin/python3
from __future__ import print_function
import base64
import os
import sys

if __name__ == "__main__":
    # create font data chunk for embedding
    font = "Tests/images/courB08"
    print("    f._load_pilfont_data(")
    print("         # %s" % os.path.basename(font))
    print("         BytesIO(base64.decodestring(b'''")
    base64.encode(open(font + ".pil", "rb"), sys.stdout)
    print("''')), Image.open(BytesIO(base64.decodestring(b'''")
    base64.encode(open(font + ".pbm", "rb"), sys.stdout)
    print("'''))))")
示例#60
0
#!/usr/bin/python
import base64

base = base64.encode(r'binary\x00strin')
print base
print base64.decode(base)
l = r'i\x7\x1d\xfb\xef\xff'
base1 = base64.b64encode(l)
#base1 = base64.b64encode(l)
print base1
base11 = base64.urlsafe_b64encode(l)
print base11
print base64.urlsafe_b64decode(l)