As far as I can tell, there are no logging APIs built into the PowerShell framework. So, when I have to write a code solution in PowerShell, I just add this snippet to meet some of my basic logging needs.
Set up some helper variables
I need to set the name and location of my log file. In addition, I like to add a “run id” to my logs so that I can easily group all the log entries associated with a given execution together for analysis or performance reporting:
Write-Log -logMsg "Starting up some script"
# do some work here
Sleep 2
Write-Log -logMsg "Finishing some script"
This produces a simple log like below. You can see my “run id” in the second column that helps me group log lines together by unique executions:
Sure, there are no log levels, no file rotations, no easy way to change the format…but in lieu of a built in API, this does the trick. One way it could be improved would be to stick this work into a module that I could simply import from script-to-script instead of copy/pasting this code around.
I’m not a big fan of wordclouds, but management seems to like them. Recently, I was working on a wordcloud of domains and generated some unexpected results. For demonstration purposes, I grabbed the domains of stories Firefox Pocket recommended to me and shoved them into a dataframe:
Then, I took a list of the domains and preprocessed them in the conventional way you do for the package: you join them together likes words of text with spaces in between:
text = ' '.join(df_domains.domain.tolist())
Finally, I loaded those words into a wordcloud object:
Excellent…except…where are the top-level domains? All the .coms, .nets, etc? By Jove, they’re not there! If you check out the frequency map the wordcloud created, you can start to get a clue about what happened:
The “generate” function removed all the .coms, .nets, and so on when it built the frequency map. A little more digging and we can see that the default regular expression is the problem: “\w[\w’]+”. It’s looking for words (and even apostrophes), but stopping with punctuation marks like periods. Now, you can futz around with providing your own regular expression that will include the full domain–I tried that–but regular expressions are hard and there’s actually a better way: the pandas value_counts function. The value_counts function will let you generate your own frequency map that you can provide to the wordcloud package directly. First, let’s just take a look at what value_counts produces. We’ll pipe the results to a dictionary so that the data is in a form the wordcloud package needs:
Lately, I’ve been challenged with performing calculations and charting of file size values in different units of measure. For example, I’ll have file size values in gigabytes but will have to plot those values against terabytes of disk capacity. I’m a little surprised that Python doesn’t have a ready way to solve this problem. There is the hurry.filesize package, but that requires that you pass a bytes value into the function. What if you only have a gigabytes value to pass? Well, I came up with my own solution, largely inspired by similar solutions. Here’s my function:
import re
def convert_filesize(size, desired_uom, factor=1024):
"""Converts a provided computer data storage value to a different unit of measure.
Keyword arguments:
size -- a string of the current size (ex. '1.5 GB')
desired_uom -- a string of the new unit of measure (ex. 'TB')
factor -- the factor used in the conversion (default 1024)
"""
uom_options = ['B', 'KB', 'MB', 'GB', 'TB']
supplied_uom = re.search(r'[a-zA-Z]+', size)
if supplied_uom:
supplied_uom = supplied_uom.group()
else:
raise ValueError('size argument did not contain expected unit of measure')
supplied_size = float(size.replace(supplied_uom, ''))
supplied_size_in_bytes = supplied_size * (factor ** (uom_options.index(supplied_uom)))
converted_size = supplied_size_in_bytes / (factor ** (uom_options.index(desired_uom)))
return converted_size, '{0:,.2f} {1}'.format(converted_size, desired_uom)
Then, you’ll use it like so:
# non SI conversion
print('Using default conversion factor of 1024:')
print(convert_filesize('1024 B', 'KB'))
print(convert_filesize('1.5 GB', 'MB'))
print(convert_filesize('59.3 GB', 'TB'))
print('\nUsing this IEC/SI conversion factor of 1000:')
# conversion recommended by IEC (https://www.convertunits.com/from/MB/to/GB)
print(convert_filesize('1024 B', 'KB', factor=1000))
print(convert_filesize('1.5 GB', 'MB', factor=1000))
print(convert_filesize('59.3 GB', 'TB', factor=1000))
Which produces the following results:
Using default conversion factor of 1024:
(1.0, '1.00 KB')
(1536.0, '1,536.00 MB')
(0.05791015625, '0.06 TB')
Using this IEC/SI conversion factor of 1000:
(1.024, '1.02 KB')
(1500.0, '1,500.00 MB')
(0.0593, '0.06 TB')
I’m sure there’s much room for improvement, but this routine seems to meet my needs for now.
Recent Comments