Release from CI (#178)

## Problem

A good release process needs to be fast while also ensuring quality and
consistency. Confidence of quality comes from incorporating automated
testing. And there are many aspects of consistency including:

- Ensuring commits are tagged with version number so we can know what is
in each release (now and in the future in case of any security reports)
- Version number in `pinecone/__version__` is correctly updated, so we
don't try to reuse the same one later
- Building in a standardized way to avoid introducing accidental
inconsistencies (e.g. uncommitted and untested local changes
accidentally included in a release, using an old version of python on a
local machine, etc)

## Solution

Implement github actions workflows for publishing releases
(`release.yaml`) and prereleases (`alpha-release.yaml`).

<img width="649" alt="Screenshot 2023-06-06 at 3 01 23 PM"
src="https://github.com/pinecone-io/pinecone-python-client/assets/1326365/79e2464a-832c-447d-a771-146dc6d60ecf">

These workflows both follow the same high-level steps that take place in
a `publish-to-pypi.yaml` [reusable
workflow](https://docs.github.com/en/actions/using-workflows/reusing-workflows):
- Run tests using another new reusable workflow, `testing.yaml`, which I
refactored out of the existing PR workflow.
- Automatic version bumps based on type of release (`major`, `minor`,
`patch`).
- I ended up writing my own small action to do this because I didn't
find a nice github action that would do this off the shelf. There are
lots of small code packages out there that do the version bump logic but
they tended to have weird flaws that made them a poor fit (e.g. wanting
to handle the git commit part even though this isn't the right moment
for it in my workflow, wanting to store separate version-related config
elsewhere, poor support for custom alpha/rc version numbers, etc.)
- Check that version numbers are unique (i.e. that there is no
preexisting git tag with that number. This mainly protects us from
accidentally reusing the same rc number). This validation is possible
since git tags become the source of truth on which version numbers are
used/available.
- Build with existing make task
- Upload to PyPI using twine. This is no change, just using Makefile
tasks defined by others in the past.
- Git push commit with updated `pinecone/__version__` and git tags. Save
this step for last so that the git tag is not consumed unless the pypi
upload is successful.

## Other notes

Updated the version saved in `pinecone/__version__` because I noticed
that it is out of date with the latest version published on PyPI. This
is one example of a type of error that will no longer occur when
publishing from CI.

While implementing this I ran into several different issues in github
actions including:

- actions/runner#2472
- actions/runner#1483
- actions/hello-world-javascript-action#12


## Future Work

Some ideas for future: 
- I would like to make some automated changelog updates and draft
release notes from CI. But not doing this now as this is already a large
change.
- I could also do some work to figure out what the automatic next rc
number is by inspecting what git tags have been used. But for now it's
easy to just pass in the values as an input when starting the job.

## Type of Change

- [x] Infrastructure change (CI configs, etc)

## Test Plan

I used the test environment at test.pypi.org to publish an rc version of
this package using the `alpha-release.yaml` version of the workflow.

Here's a [test
run](https://github.com/pinecone-io/pinecone-python-client/actions/runs/5192266625)
I did that targeted the testpypi and resulted in [this 2.2.2rc4
artifact](https://test.pypi.org/project/pinecone-client/2.2.2rc4/).
Which can be installed like this by specifying the test.pypi.org index:

```
pip install -i https://test.pypi.org/simple/ pinecone-client==2.2.2rc4
```

In general, to test a github workflow that only exists in a branch you
need to install the github CLI and run a command like this from inside
the project:

```
gh workflow run alpha-release.yaml -f ref=jhamon/release-from-ci -f releaseLevel=patch -f prereleaseSuffix='rc4'
```

The only thing I changed after this run was to switch from targeting the
test PyPI index to the production PyPI index.

The prod workflow is substantially similar so I have a high confidence
it should work but I don't want to test it and release until I land this
in master because I want to the release commit to tag a SHA in the main
history (and not this branch). I plan to land, then make a follow up for
any small issues that come up when trying to use it for the first time.

Author: jhamon

.github/actions/bump-version/.gitignore

@@ -0,0 +1 @@
+node_modules/

.github/actions/bump-version/action.js

@@ -0,0 +1,38 @@
+const core = require('./core');
+
+function bumpVersion(currentVersion, bumpType, prerelease) {
+  let newVersion = calculateNewVersion(currentVersion, bumpType);
+
+  if (prerelease) {
+    newVersion = `${newVersion}.${prerelease}`;
+  }
+  core.setOutput('previous_version', currentVersion)
+  core.setOutput('previous_version_tag', `v${currentVersion}`)
+  core.setOutput('version', newVersion);
+  core.setOutput('version_tag', `v${newVersion}`)
+
+  return newVersion;
+}
+
+function calculateNewVersion(currentVersion, bumpType) {
+  const [major, minor, patch] = currentVersion.split('.');
+  let newVersion;
+
+  switch (bumpType) {
+    case 'major':
+      newVersion = `${parseInt(major) + 1}.0.0`;
+      break;
+    case 'minor':
+      newVersion = `${major}.${parseInt(minor) + 1}.0`;
+      break;
+    case 'patch':
+      newVersion = `${major}.${minor}.${parseInt(patch) + 1}`;
+      break;
+    default:
+      throw new Error(`Invalid bumpType: ${bumpType}`);
+  }
+
+  return newVersion;
+}
+
+module.exports = { bumpVersion }

.github/actions/bump-version/action.test.js

@@ -0,0 +1,87 @@
+const action = require('./action')
+const core = require('./core');
+
+jest.mock('./core');
+
+describe('bump-version', () => {
+    test('bump major', () => {
+      action.bumpVersion('1.2.3', 'major', '')
+
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version', '1.2.3')
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v1.2.3')
+      expect(core.setOutput).toHaveBeenCalledWith('version', '2.0.0');
+      expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v2.0.0')
+    })
+
+    test('bump minor: existing minor and patch', () => {
+      action.bumpVersion('1.2.3', 'minor', '');
+
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version', '1.2.3')
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v1.2.3')
+      expect(core.setOutput).toHaveBeenCalledWith('version', '1.3.0');
+      expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v1.3.0')
+    })
+
+    test('bump minor: with no patch', () => {
+      action.bumpVersion('1.2.0', 'minor', '');
+
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version', '1.2.0')
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v1.2.0')
+      expect(core.setOutput).toHaveBeenCalledWith('version', '1.3.0');
+      expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v1.3.0')
+    })
+
+    test('bump minor: from existing patch', () => {
+      action.bumpVersion('2.2.3', 'minor', '');
+
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version', '2.2.3')
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v2.2.3')
+      expect(core.setOutput).toHaveBeenCalledWith('version', '2.3.0');
+      expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v2.3.0')
+    })
+
+    test('bump patch: existing patch', () => {
+      action.bumpVersion('1.2.3', 'patch', '');
+
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version', '1.2.3')
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v1.2.3')
+      expect(core.setOutput).toHaveBeenCalledWith('version', '1.2.4');
+      expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v1.2.4')
+    })
+
+    test('bump patch: minor with no patch', () => {
+      action.bumpVersion('1.2.0', 'patch', '');
+
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version', '1.2.0')
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v1.2.0')
+      expect(core.setOutput).toHaveBeenCalledWith('version', '1.2.1');
+      expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v1.2.1')
+    })
+
+    test('bump patch: major with no minor or patch', () => {
+      action.bumpVersion('1.0.0', 'patch', '');
+
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version', '1.0.0')
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v1.0.0')
+      expect(core.setOutput).toHaveBeenCalledWith('version', '1.0.1');
+      expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v1.0.1')
+    })
+
+    test('bump patch: major with minor', () => {
+      action.bumpVersion('1.1.0', 'patch', '');
+
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version', '1.1.0')
+      expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v1.1.0')
+      expect(core.setOutput).toHaveBeenCalledWith('version', '1.1.1');
+      expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v1.1.1')
+    })
+
+   test('prerelease suffix provided', () => {
+    action.bumpVersion('1.2.3', 'patch', 'rc1');
+
+    expect(core.setOutput).toHaveBeenCalledWith('previous_version', '1.2.3')
+    expect(core.setOutput).toHaveBeenCalledWith('previous_version_tag', 'v1.2.3')
+    expect(core.setOutput).toHaveBeenCalledWith('version', '1.2.4.rc1');
+    expect(core.setOutput).toHaveBeenCalledWith('version_tag', 'v1.2.4.rc1')
+   })
+})

.github/actions/bump-version/action.yml

@@ -0,0 +1,29 @@
+name: 'pinecone-io/bump-version'
+
+description: 'Bumps the version number in a file'
+
+inputs:
+  versionFile:
+    description: 'Path to a file containing the version number'
+    required: true
+  bumpType:
+    description: 'The type of version bump (major, minor, patch)'
+    required: true
+  prereleaseSuffix:
+    description: 'Optional prerelease identifier to append to the version number'
+    required: false
+    default: ''
+
+outputs:
+  version:
+    description: 'The new version number'
+  version_tag:
+    description: 'The new version tag'
+  previous_version:
+    description: 'The previous version number'
+  previous_version_tag:
+    description: 'The previous version tag'
+
+runs:
+  using: 'node16'
+  main: 'index.js'

.github/actions/bump-version/core.js

@@ -0,0 +1,79 @@
+// Copied these commands out of the github actions toolkit
+// because actually depending on @actions/core requires me to check
+// in node_modules and 34MB of dependencies, which I don't want to do.
+
+const fs = require('fs');
+const os = require('os');
+
+function getInput(name, options) {
+    const val =
+      process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''
+    if (options && options.required && !val) {
+      throw new Error(`Input required and not supplied: ${name}`)
+    }
+  
+    if (options && options.trimWhitespace === false) {
+      return val
+    }
+  
+    return val.trim()
+}
+
+function toCommandValue(input) {
+    if (input === null || input === undefined) {
+      return ''
+    } else if (typeof input === 'string' || input instanceof String) {
+      return input
+    }
+    return JSON.stringify(input)
+}
+
+function prepareKeyValueMessage(key, value) {
+    const delimiter = `delimiter_${Math.floor(Math.random()*100000)}`
+    const convertedValue = toCommandValue(value)
+  
+    // These should realistically never happen, but just in case someone finds a
+    // way to exploit uuid generation let's not allow keys or values that contain
+    // the delimiter.
+    if (key.includes(delimiter)) {
+      throw new Error(
+        `Unexpected input: name should not contain the delimiter "${delimiter}"`
+      )
+    }
+  
+    if (convertedValue.includes(delimiter)) {
+      throw new Error(
+        `Unexpected input: value should not contain the delimiter "${delimiter}"`
+      )
+    }
+  
+    return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`
+}
+
+function setOutput(name, value) {
+    const filePath = process.env['GITHUB_OUTPUT'] || ''
+    if (filePath) {
+      return issueFileCommand('OUTPUT', prepareKeyValueMessage(name, value))
+    }
+  
+    process.stdout.write(os.EOL)
+    issueCommand('set-output', {name}, toCommandValue(value))
+}
+
+function issueFileCommand(command, message) {
+    const filePath = process.env[`GITHUB_${command}`]
+    if (!filePath) {
+        throw new Error(
+        `Unable to find environment variable for file command ${command}`
+        )
+    }
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Missing file at path: ${filePath}`)
+    }
+
+    fs.appendFileSync(filePath, `${toCommandValue(message)}${os.EOL}`, {
+        encoding: 'utf8'
+    })
+}
+
+module.exports = { getInput, setOutput }

.github/actions/bump-version/index.js

@@ -0,0 +1,13 @@
+const action = require('./action');
+const fs = require('fs');
+const core = require('./core');
+
+const version = fs.readFileSync(core.getInput('versionFile'), 'utf8');
+
+const newVersion = action.bumpVersion(
+  version,
+  core.getInput('bumpType'),
+  core.getInput('prereleaseSuffix')
+);
+
+fs.writeFileSync(core.getInput('versionFile'), newVersion);

.github/actions/bump-version/jest.config.json

@@ -0,0 +1,3 @@
+{
+    "verbose": true
+}