def prettify_string(rough_string):
"""Return an XML string with added whitespace for legibility,
using .NET infrastructure.
Parameters
----------
rough_string : str
XML string
"""
mStream = MemoryStream()
writer = XmlTextWriter(mStream, Encoding.UTF8)
document = XmlDocument()
document.LoadXml(rough_string)
writer.Formatting = Formatting.Indented
writer.WriteStartDocument()
document.WriteContentTo(writer)
writer.Flush()
mStream.Flush()
mStream.Position = 0
sReader = StreamReader(mStream)
formattedXml = sReader.ReadToEnd()
return formattedXml
def serialize(self,
document,
indent=False,
encoding=bridge.ENCODING,
prefixes=None,
omit_declaration=False):
doc = XmlDocument()
doc.LoadXml(self.__start_document(document))
if document.xml_text:
doc.DocumentElement.AppendChild(
doc.CreateTextNode(document.xml_text))
self.__serialize_element(doc, doc.DocumentElement, document)
settings = XmlWriterSettings()
settings.Indent = indent
settings.Encoding = Encoding.GetEncoding(encoding)
settings.OmitXmlDeclaration = omit_declaration
ms = MemoryStream()
xw = XmlWriter.Create(ms, settings)
doc.Save(xw)
sr = StreamReader(ms)
ms.Seek(0, SeekOrigin.Begin)
content = sr.ReadToEnd()
ms.Close()
return content
def encode_job(self, job):
random_bytes = Array.CreateInstance(Byte, 2)
Random().NextBytes(random_bytes)
data = Encoding.UTF8.GetBytes(JavaScriptSerializer().Serialize(job))
with MemoryStream(data.Length) as initialStream:
initialStream.Write(data, 0, data.Length)
initialStream.Seek(0, SeekOrigin.Begin)
with MemoryStream() as resultStream:
with GZipStream(resultStream,
CompressionMode.Compress) as zipStream:
buffer = Array.CreateInstance(Byte, 4096)
bytesRead = initialStream.Read(buffer, 0, buffer.Length)
zipStream.Write(buffer, 0, bytesRead)
while bytesRead != 0:
bytesRead = initialStream.Read(buffer, 0,
buffer.Length)
zipStream.Write(buffer, 0, bytesRead)
result = resultStream.ToArray()
result[:2] = random_bytes
return {
Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(
0, 8):
Convert.ToBase64String(Guid.NewGuid().ToByteArray()),
"data":
Convert.ToBase64String(result)
}
def _dotnet_decrypt(data, key):
"""Perform decrypting of provided encrypted data.
If 'digest' is True data must be hex digest, otherwise data should be
encrypted bytes.
This function is symmetrical with encrypt function.
"""
data = Array[Byte](map(Byte, map(ord, data)))
key = Array[Byte](map(Byte, key))
rm = RijndaelManaged()
dec_transform = rm.CreateDecryptor(key, Array[Byte](_vector))
mem = MemoryStream()
cs = CryptoStream(mem, dec_transform, CryptoStreamMode.Write)
cs.Write(data, 0, data.Length)
cs.FlushFinalBlock()
mem.Position = 0
decrypted = Array.CreateInstance(Byte, mem.Length)
mem.Read(decrypted, 0, decrypted.Length)
cs.Close()
utfEncoder = UTF8Encoding()
return utfEncoder.GetString(decrypted)
def get_idf(self, args, request, uiApplication):
'''
deserializes a ModelSnapshot from the POST and then uses the DPV
idf writer to export the ModelSnapshot as an IDF file.
'''
clr.AddReference('DpvApplication')
clr.AddReference('DesignPerformanceViewer')
from DesignPerformanceViewer.Model import ModelSnapshotImporter
from DesignPerformanceViewer.EnergyPlusCalculation import IdfWriter
from System.IO import StreamReader
from System.IO import MemoryStream
from System.Text import Encoding
if request.HttpMethod == 'POST':
body = request.InputStream
encoding = request.ContentEncoding
reader = StreamReader(body, encoding)
snapshot_xml = reader.ReadToEnd()
snapshot = ModelSnapshotImporter().Import(snapshot_xml)
elif request.HttpMethod == 'GET':
snapshot = self.take_snapshot(uiApplication)
else:
return (404, 'text/plain',
'invalid HTTP method: ' + request.HttpMethod)
ms = MemoryStream()
writer = IdfWriter(ms, Encoding.UTF8)
writer.Write(snapshot)
ms.Position = 0
idf = StreamReader(ms, Encoding.UTF8).ReadToEnd()
print 'idf=', idf
return (200, 'text/plain', idf)
def createDatasetWithCompoundType(h5file):
mtype = createMemType()
ftype = createFileType()
npoints = 4
shape = Array[Int64]((npoints, ))
dspace = H5S.create_simple(shape.Length, shape)
dset = H5D.create(h5file, 'DS1', ftype, dspace)
ms = MemoryStream()
writer = BinaryWriter(ms)
writer.Write(Int32(1153))
s = 'Exterior (static)'
if IntPtr.Size == 8:
writer.Write(Marshal.StringToHGlobalAnsi(s).ToInt64())
else:
writer.Write(Marshal.StringToHGlobalAnsi(s).ToInt32())
writer.Write(Double(53.23))
writer.Write(Double(24.57))
writer.Write(Int32(1184))
s = 'Intake'
if IntPtr.Size == 8:
writer.Write(Marshal.StringToHGlobalAnsi(s).ToInt64())
else:
writer.Write(Marshal.StringToHGlobalAnsi(s).ToInt32())
writer.Write(Double(55.12))
writer.Write(Double(22.95))
writer.Write(Int32(1027))
s = 'Intake manifold'
if IntPtr.Size == 8:
writer.Write(Marshal.StringToHGlobalAnsi(s).ToInt64())
else:
writer.Write(Marshal.StringToHGlobalAnsi(s).ToInt32())
writer.Write(Double(103.55))
writer.Write(Double(31.23))
writer.Write(Int32(1313))
s = 'Exhaust manifold'
if IntPtr.Size == 8:
writer.Write(Marshal.StringToHGlobalAnsi(s).ToInt64())
else:
writer.Write(Marshal.StringToHGlobalAnsi(s).ToInt32())
writer.Write(Double(1252.89))
writer.Write(Double(84.11))
byteArray = ms.ToArray()
H5D.write(dset, mtype, H5Array[Byte](byteArray))
H5S.close(dspace)
H5T.close(ftype)
H5T.close(mtype)
return dset
def stream_bitmap(imagebytes):
memoryStream = MemoryStream(imagebytes)
memoryStream.Position = 0
image = Imaging.BitmapImage()
image.BeginInit()
image.StreamSource = memoryStream
image.CacheOption = Imaging.BitmapCacheOption.OnLoad
image.EndInit()
return image
def pick(snip=False):
snipper = PickSnipTool(PickSnipTool.take_screenshot(), snip=snip)
while True:
result = snipper.ShowDialog()
if result in [DialogResult.OK, DialogResult.Cancel]:
break
if snipper.mouse_down_seconds == 1:
Mouse.Instance.Click(snipper.mouse_down)
time.sleep(0.5)
snipper.BackgroundImage = PickSnipTool.take_screenshot()
if result == DialogResult.OK and snip:
if snipper.snip_rectangle.Width and snipper.snip_rectangle.Height:
img = Bitmap(
snipper.snip_rectangle.Width,
snipper.snip_rectangle.Height,
)
gr = Graphics.FromImage(img)
gr.DrawImage(
snipper.BackgroundImage,
Rectangle(0, 0, img.Width, img.Height),
snipper.snip_rectangle,
GraphicsUnit.Pixel,
)
fp = MemoryStream()
img.Save(fp, ImageFormat.Png)
return {
'bytes': bytes(bytearray(fp.ToArray())),
}
return {}
elif result == DialogResult.OK:
if (snipper.mouse_down_seconds
and snipper.mouse_down_seconds <= snipper.click_timeout):
Mouse.Instance.Click(snipper.mouse_down)
time.sleep(0.5)
el = AutomationElement.FromPoint(snipper.mouse_up)
result = {
prop.ProgrammaticName.split('.', 1)[-1]:
el.GetCurrentPropertyValue(prop)
for prop in el.GetSupportedProperties()
}
result.update({
'NameProperty':
el.GetCurrentPropertyValue(el.NameProperty),
'ControlTypeProperty':
el.GetCurrentPropertyValue(
el.ControlTypeProperty, ).ProgrammaticName.split('.',
1)[-1],
'AutomationIdProperty':
el.GetCurrentPropertyValue(el.AutomationIdProperty, ),
})
return result
else:
return {}
def _read_to_end(stream, bufsize=4096):
buffer = _make_buffer(bufsize)
memory = MemoryStream()
while True:
count = stream.Read(buffer, 0, bufsize)
if not count:
break
memory.Write(buffer, 0, count)
bytes = memory.ToArray()
memory.Close()
return bytes
def take_screenshot(as_bytes=False):
bounds = Screen.PrimaryScreen.Bounds
screenshot = Bitmap(bounds.Width, bounds.Height,
PixelFormat.Format32bppPArgb)
graphics = Graphics.FromImage(screenshot)
graphics.CopyFromScreen(0, 0, 0, 0, screenshot.Size)
if as_bytes:
fp = MemoryStream()
screenshot.Save(fp, ImageFormat.Png)
return bytes(bytearray(fp.ToArray()))
else:
return screenshot
def compress(string, level=6):
bytes = raw.GetBytes(string)
stream = MemoryStream()
zstream = DeflateStream(stream, CompressionMode.Compress, True)
zstream.Write(bytes, 0, len(bytes))
zstream.Close()
compressed = raw.GetString(stream.ToArray())
stream.Close()
header = _zlib_header()
footer = _zlib_footer(string)
return header + compressed + footer
def decode_job(self, job):
buffer = Convert.FromBase64String(job['data'])
buffer[:2] = Array[Byte](bytearray(b"\x1f\x8b"))
with MemoryStream(buffer.Length) as compressedStream:
compressedStream.Write(buffer, 0, buffer.Length)
compressedStream.Seek(0, SeekOrigin.Begin)
with GZipStream(compressedStream,
CompressionMode.Decompress) as zipStream:
with MemoryStream() as resultStream:
zipStream.CopyTo(resultStream)
return JavaScriptSerializer().DeserializeObject(
Encoding.UTF8.GetString(resultStream.ToArray()))
def Decompress(compressed):
with MemoryStream(compressed.Length) as inputStream:
inputStream.Write(compressed, 0, compressed.Length)
inputStream.Seek(0, SeekOrigin.Begin)
with MemoryStream() as outputStream:
with DeflateStream(inputStream, CompressionMode.Decompress) as deflateStream:
buffer = Array.CreateInstance(Byte, 4096)
bytesRead = deflateStream.Read(buffer, 0, buffer.Length)
outputStream.Write(buffer, 0, bytesRead)
while bytesRead != 0:
bytesRead = deflateStream.Read(buffer, 0, buffer.Length)
outputStream.Write(buffer, 0, bytesRead)
return outputStream.ToArray()
def table_text_writer(list_input):
"""Writes table input
args:
list_input (list of lists): input to be written
returns: stream
"""
from System.IO import StreamWriter, MemoryStream, SeekOrigin
list_input = controlled_list(list_input)
LOGGER.debug(list_input)
LOGGER.debug('--------')
header = controlled_list(list_input.pop(0))
length_of_header = len(header)
head_line = create_line(header)
# if only a header line
if not list_input:
text = ' ' * (length_of_header)
else:
text =''
LOGGER.debug('Loop')
for i, text_list in enumerate(list_input):
text_list = controlled_list(text_list)
LOGGER.debug(text_list)
if len(text_list) != length_of_header:
message = ('Line {} in text: [{}] does not have ' +
' same length as header [{}], will be ' +
'skipped').format(i, join_list(text_list),
join_list(header))
ok_message(message)
else:
text += create_line(text_list)
text = head_line + text
stream = MemoryStream()
writer = StreamWriter(stream)
writer.Write(text)
writer.Flush()
stream.Seek(0, SeekOrigin.Begin)
return stream
def test_z_cli_tests(self): # runs last to prevent tainting the module w/ CLR names
import clr
import System
self.load_iron_python_test()
from IronPythonTest import WriteOnly
if is_netcoreapp:
clr.AddReference("System.IO.Compression")
with stdout_trapper() as output:
help(WriteOnly)
help(System.IO.Compression)
help(System.Int64)
x = self.run_help(System.String.Format)
self.assertTrue(x.find('Format(format: str, arg0: object) -> str') != -1)
x = self.run_help('u.u'.Split('u'))
# requires std lib
self.assertTrue('Help on Array[str] object' in x, x)
# https://github.com/IronLanguages/ironpython2/issues/359
if not is_mono:
from System.IO import MemoryStream
x_class = self.run_help(MemoryStream.Write)
x_instance = self.run_help(MemoryStream().Write)
self.assertEqual(x_class, x_instance.replace("built-in function Write", "method_descriptor"))
#http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=11883
self.assertEqual(dir(System).count('Action'), 1)
with stdout_trapper() as output:
help(System.Action)
self.assertEqual(dir(System).count('Action'), 1)
def readFromDatasetWithCompoundType(dset):
mtype = createMemType()
sizeof = H5T.getSize(mtype)
dspace = H5D.getSpace(dset)
npoints = H5S.getSimpleExtentNPoints(dspace)
shape = Array[Int64]((npoints * sizeof, ))
byteArray = Array.CreateInstance(Byte, shape)
H5D.read(dset, mtype, H5Array[Byte](byteArray))
ms = MemoryStream(byteArray)
reader = BinaryReader(ms)
for i in range(npoints):
if IntPtr.Size == 8:
print '%d,%s,%.2f,%.2f' % (reader.ReadInt32(
), Marshal.PtrToStringAnsi(IntPtr(
reader.ReadInt64())), reader.ReadDouble(), reader.ReadDouble())
else:
print '%d,%s,%.2f,%.2f' % (reader.ReadInt32(
), Marshal.PtrToStringAnsi(IntPtr(
reader.ReadInt32())), reader.ReadDouble(), reader.ReadDouble())
H5S.close(dspace)
H5T.close(mtype)
return None
def copytoclipboard(args):
"""
Put data on Windows clipboard
in csv format.
"""
csvx = ""
if len(args) == 0:
pass
# clear clipboard
# print 'clearing clipboard'
elif len(args) == 1:
csvx = args[0]
else:
csvx = ""
csvx = ','.join(args)
# print "-------------------", csvx
dobj = DataObject()
# hack from MSDN PostID 238181
# this is a bit bizarre,
# but it works for getting csv data into Excel
txt = Text.Encoding.Default.GetBytes(csvx)
memstr = MemoryStream(txt)
dobj.SetData('CSV', memstr)
dobj.SetData(CSV, memstr)
Clipboard.SetDataObject(dobj)
def testMemoryStreams():
print 'Verifying MemoryStreams'
stopwatch = Stopwatch.StartNew()
for i in xrange(64):
streams = [MemoryStream() for x in xrange(2)]
randomOperations(128, streams)
stopwatch.Stop()
print '%s' % stopwatch.Elapsed
def ImageFromZip(zipFile, file):
if ZipFile is None:
raise Exception(
"'Ionic.Zip.dll' not found! ZipFile not supported!")
z = ZipFile(zipFile)
m = MemoryStream()
e = z[file]
e.Extract(m)
return Image(m)
def csvToDataSource(csv, columnDataTypes):
# Create memorystream to read from
stream = MemoryStream()
writer = StreamWriter(stream)
writer.Write(csv)
writer.Flush()
stream.Seek(0, SeekOrigin.Begin)
# Create text file data source
readerSettings = TextDataReaderSettings()
readerSettings.Separator = ','
readerSettings.AddColumnNameRow(0)
print 'columnDataTypes ', columnDataTypes
for i, columnDataType in enumerate(columnDataTypes):
readerSettings.SetDataType(i, columnDataType)
dataSource = TextFileDataSource(stream, readerSettings)
dataSource.ReuseSettingsWithoutPrompting = True
dataSource.IsPromptingAllowed = False
return dataSource
def CreateWebServiceFromWsdl(self, wsdl):
sd = ServiceDescription.Read(MemoryStream(wsdl))
ptcount = sd.PortTypes.Count
self.isap.print_out("Port Types:" + str(ptcount), 3)
for x in range(0, ptcount):
self.isap.print_out(str(sd.PortTypes[x].Name), 3)
portoperations = sd.PortTypes[x].Operations
portoperationscount = portoperations.Count
self.isap.print_out("Operations" + str(portoperationscount), 3)
for j in range(0, portoperationscount):
self.isap.print_out(str(portoperations[j].Name), 3)
self.returnres("GetProcessList")
def testColumnStream():
print 'Verifying ColumnStream against MemoryStream'
timer = Stopwatch.StartNew()
instance = Instance('ColumnStreamTest')
instance.Parameters.MaxVerPages = 1024
instance.Parameters.CircularLog = True
instance.Init()
bookmark = Array.CreateInstance(System.Byte, 255)
try:
session = Session(instance)
dbid = Api.JetCreateDatabase(session, 'ColumnStream.db', '',
CreateDatabaseGrbit.OverwriteExisting)
Api.JetBeginTransaction(session)
tableid = Api.JetCreateTable(session, dbid, 'table', 0, 100)
columndef = JET_COLUMNDEF(coltyp=JET_coltyp.LongBinary)
columnid = Api.JetAddColumn(session, tableid, 'LvColumn', columndef,
None, 0)
Api.JetCloseTable(session, tableid)
Api.JetCommitTransaction(session, CommitTransactionGrbit.LazyFlush)
tableid = Api.JetOpenTable(session, dbid, 'table', None, 0,
OpenTableGrbit.None)
for i in xrange(64):
runtimer = Stopwatch.StartNew()
Api.JetBeginTransaction(session)
Api.JetPrepareUpdate(session, tableid, JET_prep.Insert)
bookmarksize = Api.JetUpdate(session, tableid, bookmark, 255)
Api.JetCommitTransaction(session, CommitTransactionGrbit.LazyFlush)
Api.JetGotoBookmark(session, tableid, bookmark, bookmarksize)
Api.JetBeginTransaction(session)
Api.JetPrepareUpdate(session, tableid, JET_prep.Insert)
streams = [
MemoryStream(),
ColumnStream(session, tableid, columnid)
]
randomOperations(64, streams)
Api.JetUpdate(session, tableid)
Api.JetCommitTransaction(session, CommitTransactionGrbit.LazyFlush)
runtimer.Stop()
print '\t%s' % runtimer.Elapsed
finally:
instance.Dispose()
timer.Stop()
print '%s' % timer.Elapsed
def testWeCanBindToEncodingGetString(self):
"""Check that we can bind to the Encoding.GetString method with variables."""
from System.Text import Encoding
from System.IO import MemoryStream
myBytes = Encoding.UTF8.GetBytes('Some testing string')
stream = MemoryStream()
stream.Write(myBytes, 0, myBytes.Length)
stream.Position = 0
buff = System.Array.CreateInstance(System.Byte, 3)
buff.Initialize()
data = []
read = 1
while read > 0:
read, _ = stream.Read(buff, 0, buff.Length)
temp = Encoding.UTF8.GetString(buff, 0, read)
data.append(temp)
data = ''.join(data)
self.assertEqual(data, 'Some testing string')
def testWeCanBindToEncodingGetString(self):
"""Check that we can bind to the Encoding.GetString method with variables."""
from System.Text import Encoding
from System.IO import MemoryStream
myBytes = Encoding.UTF8.GetBytes('Some testing string')
stream = MemoryStream()
stream.Write(myBytes, 0, myBytes.Length)
stream.Position = 0
buff = System.Array.CreateInstance(System.Byte, 3)
buff.Initialize()
data = []
read = 1
while read > 0:
read, _ = stream.Read(buff, 0, buff.Length)
temp = Encoding.UTF8.GetString(buff, 0, read)
data.append(temp)
data = ''.join(data)
self.assertEqual(data, 'Some testing string')
def test_we_can_bind_to_encoding_get_string():
"""Check that we can bind to the Encoding.GetString method
with variables."""
from System.Text import Encoding
from System.IO import MemoryStream
my_bytes = Encoding.UTF8.GetBytes('Some testing string')
stream = MemoryStream()
stream.Write(my_bytes, 0, my_bytes.Length)
stream.Position = 0
buff = System.Array.CreateInstance(System.Byte, 3)
buff.Initialize()
data = []
read = 1
while read > 0:
read = stream.Read(buff, 0, buff.Length)
temp = Encoding.UTF8.GetString(buff, 0, read)
data.append(temp)
data = ''.join(data)
assert data == 'Some testing string'
def decompress(string, wbits=MAX_WBITS):
# Python Library Reference states:
# When wbits is negative, the header is suppressed
if wbits < 0:
pass
else:
string = string[2:-4] # strip header and footer
bytes = raw.GetBytes(string)
stream = MemoryStream(bytes)
zstream = DeflateStream(stream, CompressionMode.Decompress)
decompressed = raw.GetString(_read_to_end(zstream))
zstream.Close()
return decompressed
def _encrypt(text, key):
"""Performs crypting of provided text using AES algorithm.
If 'digest' is True hex_digest will be returned, otherwise bytes of
encrypted data will be returned.
This function is symmetrical with decrypt function.
"""
utfEncoder = UTF8Encoding()
bytes_text = utfEncoder.GetBytes(text)
rm = RijndaelManaged()
key = Array[Byte](key)
enc_transform = rm.CreateEncryptor(key, Array[Byte](_vector))
mem = MemoryStream()
cs = CryptoStream(mem, enc_transform, CryptoStreamMode.Write)
cs.Write(bytes_text, 0, len(bytes_text))
cs.FlushFinalBlock()
mem.Position = 0
encrypted = Array.CreateInstance(Byte, mem.Length)
mem.Read(encrypted, 0, mem.Length)
cs.Close()
return ''.join(map(chr, encrypted))
def testFileStream():
print 'Verifying FileStream against MemoryStream'
stopwatch = Stopwatch.StartNew()
for i in xrange(128):
m = MemoryStream()
file = Path.GetTempFileName()
f = FileStream(file, FileMode.Open)
try:
streams = [m, f]
randomOperations(128, streams)
finally:
f.Close()
File.Delete(file)
stopwatch.Stop()
print '%s' % stopwatch.Elapsed
def AesDecryptData(self, ciphertext, key, iv):
with Aes.Create() as aesAlg:
aesAlg.Padding = PaddingMode.PKCS7
aesAlg.KeySize = 256
aesAlg.Key = key
aesAlg.IV = iv
decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV)
with MemoryStream() as decryptedData:
with CryptoStream(decryptedData, decryptor,
CryptoStreamMode.Write) as cryptoStream:
cryptoStream.Write(ciphertext, 0, ciphertext.Length)
cryptoStream.FlushFinalBlock()
return decryptedData.ToArray()
def _dotnet_encrypt(text, key):
"""Performs crypting of provided text using AES algorithm.
If 'digest' is True hex_digest will be returned, otherwise bytes of
encrypted data will be returned.
This function is symmetrical with decrypt function.
"""
utfEncoder = UTF8Encoding()
bytes_text = utfEncoder.GetBytes(text)
rm = RijndaelManaged()
key = Array[Byte](key)
enc_transform = rm.CreateEncryptor(key, Array[Byte](_vector))
mem = MemoryStream()
cs = CryptoStream(mem, enc_transform, CryptoStreamMode.Write)
cs.Write(bytes_text, 0, len(bytes_text))
cs.FlushFinalBlock()
mem.Position = 0
encrypted = Array.CreateInstance(Byte, mem.Length)
mem.Read(encrypted, 0, mem.Length)
cs.Close()
return ''.join(map(chr, encrypted))
def _dotnet_decrypt(data, key):
"""Performs decrypting of provided encrypted data.
If 'digest' is True data must be hex digest, otherwise data should be
encrypted bytes.
This function is symmetrical with encrypt function.
"""
data = Array[Byte](map(Byte, map(ord, data)))
key = Array[Byte](map(Byte, key))
rm = RijndaelManaged()
dec_transform = rm.CreateDecryptor(key, Array[Byte](_vector))
mem = MemoryStream()
cs = CryptoStream(mem, dec_transform, CryptoStreamMode.Write)
cs.Write(data, 0, data.Length)
cs.FlushFinalBlock()
mem.Position = 0
decrypted = Array.CreateInstance(Byte, mem.Length)
mem.Read(decrypted, 0, decrypted.Length)
cs.Close()
utfEncoder = UTF8Encoding()
return utfEncoder.GetString(decrypted)
def __drawFolderThumbnail(self, parent):
size = ThumbnailSize
# create new image
newImage = Bitmap(size, size)
g = Graphics.FromImage(newImage)
g.InterpolationMode = InterpolationMode.HighQualityBicubic
# draw background
if parent: bc = ParentFolderColor
else: bc = ChildFolderColor
b = LinearGradientBrush(Point(0, 0), Point(size, size), bc,
Color.GhostWhite)
g.FillRectangle(b, 0, 0, size, size)
b.Dispose()
g.DrawRectangle(Pens.LightGray, 0, 0, size - 1, size - 1)
# draw up to 4 subitems
folderItems = self.GetFirstFolderItems(4)
delta = 10
side = (size - 3 * delta) / 2 - 1
rects = (Rectangle(delta + 3, delta + 12, side, side),
Rectangle(size / 2 + delta / 2 - 3, delta + 12, side, side),
Rectangle(delta + 3, size / 2 + delta / 2 + 6, side, side),
Rectangle(size / 2 + delta / 2 - 3, size / 2 + delta / 2 + 6,
side, side))
for rect, item in zip(rects, folderItems):
subImage = Bitmap.FromStream(MemoryStream(item.thumbnail()), False)
g.DrawImage(subImage, rect)
subImage.Dispose()
for rect in rects:
g.DrawRectangle(Pens.LightGray, rect)
# draw folder name
if parent: name = '[..]'
else: name = Path.GetFileName(self.path)
f = Font('Arial', 10)
g.DrawString(name, f, Brushes.Black,
RectangleF(2, 2, size - 2, size - 2))
f.Dispose()
# get the bytes of the image
imageBytes = BitmapToBytes(newImage)
# cleanup
g.Dispose()
newImage.Dispose()
return imageBytes
def CreateWebServiceFromWsdl(wsdl):
'convert the WSDL into an assembly containing the web service proxy classes'
# generate codeDom from wsdl
sd = ServiceDescription.Read(MemoryStream(wsdl))
importer = ServiceDescriptionImporter()
importer.ServiceDescriptions.Add(sd)
codeCompileUnit = CodeCompileUnit()
codeNamespace = CodeNamespace("")
codeCompileUnit.Namespaces.Add(codeNamespace)
importer.CodeGenerationOptions = (CodeGenerationOptions.GenerateNewAsync
| CodeGenerationOptions.GenerateOldAsync)
importer.Import(codeNamespace, codeCompileUnit)
# compile CodeDom into an assembly
provider = CodeDomProvider.CreateProvider("CS")
compilerParams = CompilerParameters()
compilerParams.GenerateInMemory = True
compilerParams.IncludeDebugInformation = False
results = provider.CompileAssemblyFromDom(compilerParams, codeCompileUnit)
generatedAssembly = results.CompiledAssembly
return generatedAssembly