devin sipal

large_subgen.png

medium_subgen.png

small_subgen.png

thumbnail_subgen.png

subgen.png

thumbnail_android-chrome-192x192.png

android-chrome-192x192.png

One of the problems I was faced with at work required me to calculate the total value of transactions many different Shopify sites had within every North Carolina county. To do this, I created a Python script which uses the Google Maps API to process CSV files from Shopify containing all order history for a store. The script needed to be able to identify addresses within North Carolina, then run those through the Google Maps API in order to get the county which the address resides in, and add all order values to a running total per county.

First, I check to make sure the state is North Carolina, and then create a string to give the Google Maps API.

```py
for row in reader:
	if row[statekey] == 'NC':
		exists = False
        # address string is City, State such as Pittsboro, NC
        address_string = row[namekey].lower() + ', ' + row[statekey]
```

Then, I check to make sure I haven't already checked this address.

```py
for county in list(counties.keys()):
	if address_string in counties.get(county):
		exists = True
        county_name = county
```

Then, if it doesn't exist, this is where the getCounty() function comes in. This function makes the API request to Google and returns the county name.

```py
def getCounty(address_string):
    maps = googlemaps.Client(key='xxxxx')
    location = maps.geocode(address_string)
    target = 'administrative_area_level_2'

    for loc in location[0]['address_components']:
        if target in loc['types']:
            return loc['long_name']
        else:
            pass
```

By making sure we only make one request per city or town, we save a huge amount on the requests and make the script run much faster. We then check the county that was returned against those we currently have a total running for, and add the town to the county so we do not check it again.

```py
if not exists:
	print('Looking up county for ', address_string)
    county_name = getCounty(address_string)

    if county_name not in list(counties.keys()):
    	counties.update({county_name: [address_string]})
    else:
    	entries = counties.get(county_name)
        entries.append(address_string)
        counties.update({county_name: entries})
```

If the county does not already have a running total, we create a new county and set the price to the order total or 0 if there is none.

```py
if county_name not in places:
	print('{} doesn\'t exist, adding.'.format(county_name))
	try:
		priceData = []
		for key in datakeys:
			if row[key] != '':
				priceData.append( round( float( row[key]), 2))
			else:
				priceData.append(0.0)

			places.update({county_name: priceData})

		except ValueError:
			print(sys.exc_info())
```

Then, if it already has a county we pretty much do the same thing, without creating a new county.

```py
else:
	print('{} Already exists.'.format(county_name))
    try:
    	placevalues = places.get(county_name)
        for i in range(len(datakeys)):
        	if row[datakeys[i]] != '':
            	placevalues[i] += round(float(row[datakeys[i]]), 2)

        places.update({county_name: placevalues})
    except ValueError:
 		print(sys.exc_info())
```

Finally, this is all output to a CSV file.

```py
def writeData(places, outputfile):
    with open(outputfile, 'w', newline="\n", encoding='utf-8') as output:
        writer = csv.writer(output)
        writer.writerow(['County', 'Order Value', 'Discount Amount', 'Shipping', 'Sales Tax', 'Order Total', 'Card Processing Fee'])

        for county in places.keys():
            rowdata = places.get(county)
            rowdata.insert(0, str(county))

            writer.writerow(rowdata)
```

A script to calculate county sales tax for Shopify orders based on shipping address.

Calculating State Sales tax for Shopify Stores

This project was inspired when I came across this [GitHub repository](https://github.com/cwilso/metronome) which implements a metronome in JavaScript. I immediately realized the potential of this when used to sequence audio tracks to be on beat with each other. I combined this with [Three.JS](https://threejs.org/) in order to visualize the music and create a more engaging experience.

The backbone of the visualizer is the Web Audio API's Analyzer class. First, I created an AudioEngine class and initialized the required components.

```js
export function AudioEngine(){ 
	let audioLoader = new THREE.AudioLoader();
	this.ctx = new AudioContext();
	this.analyser = this.ctx.createAnalyser();
	this.analyser.connect(this.ctx.destination);
	this.loops = [];
	const audioRoot = './audio/';
	this.audioFiles = [
          'drumz.mp3',
	        'bass.mp3',
    	    'more.mp3'
	];
```
Then, I create a function within the class to handle the loading of the audio files.

```js
async function loadAudio(file) {
    return new Promise(function(resolve, reject) {
        var audio;
        audioLoader.load(file,
            function(buffer) {
                audio = new Loop(parent.ctx, buffer, parent.analyser);

                console.log('loaded file: ' + file);
                //push audio object to loops list in Metronome()
                parent.loops.push({
                    name: file,
                    audio: audio,
                    active: false
                });
                resolve();
            },
            function(xhr) {
                console.log('loading: ' + file + ' ' + (xhr.loaded / xhr.total) * 100 + '%');
            },
            function(err) {
                console.log("failed to load file: " + file);
                console.log(err);
            });
    });
}
```

From there, I also add in a function to the audio engine to handle the starting and stopping of loops.

```js
this.scheduleLoops = function(time) {
    for (var key in parent.loops) {
        if (!parent.loops[key].audio.isPlaying &amp;&amp; parent.loops[key].active) {
            console.log(key);
            parent.loops[key].audio.play(time);
        }

        if (!parent.loops[key].active &amp;&amp; parent.loops[key].audio.isPlaying) {
            parent.loops[key].audio.stop();
        }
    }
};
```

From this point, it was simply integrating the audio into the visualizer class and arranging the rest of the presentation.

Creating a Music Toy with a Visualizer

After seeing a data set containing over 18,000 different music reviews hosted on the site Pitchfork I was quite eager to write some code analyzing some of the trends that could be found within it. My initial idea was to see if there was a discrepancy between the scores that man-fronted acts are given compared to woman-fronted. This idea quickly developed into analyzing the different language used reviewing these groups.

One of the first issues that I faced was how I would determine the gender of each group. I decided that the most relevant way to address this was through the general attitude of the reviewer and which artist in the group was addressed the most. Therefore, I enumerated the pronouns that were used in each article and guessed the gender from there.

```py
def guessGender(self):
	maj = [0,0,0]
    for review in self.reviews:
    	pronouns = review.countPronouns()
        for i,b in enumerate(pronouns): maj[i] += b

    if maj[0] &gt; maj[1]: return('feminine')
    if maj[0] &lt; maj[1]: return('masculine')
    else: return('neutral')
```

Then, I collected each adjective that was used in the article with a filter, and ran the totals for each occurrence.

```py
def overallCommonWords(self,count=10,limits=['JJ', 'JJS', 'NN', 'NNP', 'NNS', 'RB', 'RBS', 'UH', 'VB', 'VBG', 'VBP']):
	reviews = []
    most = {}
    for review in self.reviews:
    	reviews.append(review.findCommonWords(limits))

	for review in reviews:
    	for word in review:
        	if word in reviews:
            	most[word[0]] += word[1]
            else:
            	most[word[0]] = word[1]
    return(sorted(most.items(), key=itemgetter(1))[-count:])
```

Each artist was given a page where you could see their average score, the most common adjectives that were used to describe them, and their guessed gender. There were some immediate observations that could be made.

Most of the time, acts referred to as feminine were described with words such as beautiful, soothing, or dreamy more than they were strong, exciting, or commanding. The numerical scores themselves didn't seem to have a statistically significant amount of difference, however woman led acts seemed to have a lesser number of reviews overall.

Analyzing a dataset of Pitchfork music reviews to see differences in how artists are described.

Language, Gender, and Music Reviews

This project is viewable [here](https://dsipal.github.io/subtractive-color-gen/)

This is an unconventional drawing application made completely in HTML and JavaScript. Instead of picking a color yourself, you slowly subtract color values from each individual pixel. The application also features some buttons that allow you to create gradients, add fuzz, create boxes, or change which color value you are subtracting from. There is also a console where you can sequence these effects to create animations.


```js
function gradient(i = 1, one = 0, two = 1) {
    for (a = 0; a &lt; i; a++) {
        one++;
        for (var r = 0; r &lt; (cHeight / bHeight); r++) {
            two++;
            for (var c = 0; c &lt; (cWidth / bWidth); c++) {
                subAmt = one * two;
                colorChange(r, c, subAmt);
            }
        }
    }
}
```

This is an unconventional drawing application made completely in HTML and JavaScript. Instead of picking a color yourself, you slowly subtract color values from each individual pixel.

Calculating State Sales tax for Shopify Stores

Creating a Music Toy with a Visualizer

Language, Gender, and Music Reviews

Making a Drawing Application using HTML, CSS, and JQuery