From 3df8a03870e4b07471b23a6bc8ede5d09b2a7e57 Mon Sep 17 00:00:00 2001 From: Spotlight Date: Thu, 11 Jan 2018 20:03:00 -0600 Subject: [PATCH] add those files ayy --- README.md | 6 + boto | 343 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ gitconfig | 13 +++ zshrc | 68 +++++++++++ 4 files changed, 430 insertions(+) create mode 100644 README.md create mode 100644 boto create mode 100644 gitconfig create mode 100644 zshrc diff --git a/README.md b/README.md new file mode 100644 index 0000000..33400ee --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +# hi +hi +# why +idk +# ok +ok diff --git a/boto b/boto new file mode 100644 index 0000000..4e976d5 --- /dev/null +++ b/boto @@ -0,0 +1,343 @@ +# This file contains credentials and other configuration information needed +# by the boto library, used by gsutil. You can edit this file (e.g., to add +# credentials) but be careful not to mis-edit any of the variable names (like +# "gs_access_key_id") or remove important markers (like the "[Credentials]" and +# "[Boto]" section delimiters). +# +# This file was created by gsutil version 4.28 at 2017-11-21 15:14:49. +# +# You can create additional configuration files by running +# gsutil config [options] [-o ] + + +[Credentials] + +# Google OAuth2 credentials are managed by the Cloud SDK and +# do not need to be present in this file. +# To add HMAC google credentials for "gs://" URIs, edit and uncomment the +# following two lines: +#gs_access_key_id = +#gs_secret_access_key = +# The ability to specify an alternate storage host and port +# is primarily for cloud storage service developers. +# Setting a non-default gs_host only works if prefer_api=xml. +#gs_host = +#gs_port = +#gs_json_host = +#gs_json_port = + + +# To add HMAC aws credentials for "s3://" URIs, edit and uncomment the +# following two lines: +#aws_access_key_id = +#aws_secret_access_key = +# The ability to specify an alternate storage host and port +# is primarily for cloud storage service developers. +# Setting a non-default gs_host only works if prefer_api=xml. +#s3_host = +#s3_port = + + +[Boto] + +# http_socket_timeout specifies the timeout (in seconds) used to tell httplib +# how long to wait for socket timeouts. The default is 70 seconds. Note that +# this timeout only applies to httplib, not to httplib2 (which is used for +# OAuth2 refresh/access token exchanges). +#http_socket_timeout = 70 + +# The following two options control the use of a secure transport for requests +# to S3 and Google Cloud Storage. It is highly recommended to set both options +# to True in production environments, especially when using OAuth2 bearer token +# authentication with Google Cloud Storage. + +# Set 'https_validate_certificates' to False to disable server certificate +# checking. The default for this option in the boto library is currently +# 'False' (to avoid breaking apps that depend on invalid certificates); it is +# therefore strongly recommended to always set this option explicitly to True +# in configuration files, to protect against "man-in-the-middle" attacks. +https_validate_certificates = True + +# 'debug' controls the level of debug messages printed for the XML API only: +# 0 for none, 1 for basic boto debug, 2 for all boto debug plus HTTP +# requests/responses. +#debug = <0, 1, or 2> + +# 'num_retries' controls the number of retry attempts made when errors occur +# during data transfers. The default is 6. +# Note 1: You can cause gsutil to retry failures effectively infinitely by +# setting this value to a large number (like 10000). Doing that could be useful +# in cases where your network connection occasionally fails and is down for an +# extended period of time, because when it comes back up gsutil will continue +# retrying. However, in general we recommend not setting the value above 10, +# because otherwise gsutil could appear to "hang" due to excessive retries +# (since unless you run gsutil -D you won't see any logged evidence that gsutil +# is retrying). +# Note 2: Don't set this value to 0, as it will cause boto to fail when reusing +# HTTP connections. +#num_retries = + +# 'max_retry_delay' controls the max delay (in seconds) between retries. The +# default value is 60, so the backoff sequence will be 1 seconds, 2 seconds, 4, +# 8, 16, 32, and then 60 for all subsequent retries for a given HTTP request. +# Note: At present this value only impacts the XML API and the JSON API uses a +# fixed value of 60. +#max_retry_delay = + +# To use a proxy, edit and uncomment the proxy and proxy_port lines. +# If you need a user/password with this proxy, edit and uncomment +# those lines as well. If your organization also disallows DNS +# lookups by client machines, set proxy_rdns to True (the default). +# If you have installed gsutil through the Cloud SDK and have +# configured proxy settings in gcloud, those proxy settings will +# override any other options (including those set here, along with +# any settings in proxy-related environment variables). Otherwise, +# if proxy_host and proxy_port are not specified in this file and +# one of the OS environment variables http_proxy, https_proxy, or +# HTTPS_PROXY is defined, gsutil will use the proxy server specified +# in these environment variables, in order of precedence according +# to how they are listed above. +#proxy = +#proxy_port = +#proxy_user = +#proxy_pass = +#proxy_rdns = + +[GoogleCompute] + +# 'service_account' specifies the a Google Compute Engine service account to +# use for credentials. This value is intended for use only on Google Compute +# Engine virtual machines and usually lives in /etc/boto.cfg. Most users +# shouldn't need to edit this part of the config. +#service_account = default + +[GSUtil] + +# 'resumable_threshold' specifies the smallest file size [bytes] for which +# resumable Google Cloud Storage uploads are attempted. The default is 8388608 +# (8 MiB). +#resumable_threshold = 8388608 + +# 'rsync_buffer_lines' specifies the number of lines of bucket or directory +# listings saved in each temp file during sorting. (The complete set is +# split across temp files and separately sorted/merged, to avoid needing to +# fit everything in memory at once.) If you are trying to synchronize very +# large directories/buckets (e.g., containing millions or more objects), +# having too small a value here can cause gsutil to run out of open file +# handles. If that happens, you can try to increase the number of open file +# handles your system allows (e.g., see 'man ulimit' on Linux; see also +# http://docs.python.org/2/library/resource.html). If you can't do that (or +# if you're already at the upper limit), increasing rsync_buffer_lines will +# cause gsutil to use fewer file handles, but at the cost of more memory. With +# rsync_buffer_lines set to 32000 and assuming a typical URL is 100 bytes +# long, gsutil will require approximately 10 MiB of memory while building +# the synchronization state, and will require approximately 60 open file +# descriptors to build the synchronization state over all 1M source and 1M +# destination URLs. Memory and file descriptors are only consumed while +# building the state; once the state is built, it resides in two temp files that +# are read and processed incrementally during the actual copy/delete +# operations. +#rsync_buffer_lines = 32000 + +# 'state_dir' specifies the base location where files that +# need a static location are stored, such as pointers to credentials, +# resumable transfer tracker files, and the last software update check. +# By default these files are stored in ~/.gsutil +#state_dir = +# gsutil periodically checks whether a new version of the gsutil software is +# available. 'software_update_check_period' specifies the number of days +# between such checks. The default is 30. Setting the value to 0 disables +# periodic software update checks. +#software_update_check_period = 30 + +# 'tab_completion_timeout' controls the timeout (in seconds) for tab +# completions that involve remote requests (such as bucket or object names). +# If tab completion does not succeed within this timeout, no tab completion +# suggestions will be returned. +# A value of 0 will disable completions that involve remote requests. +#tab_completion_timeout = 5 + +# 'parallel_process_count' and 'parallel_thread_count' specify the number +# of OS processes and Python threads, respectively, to use when executing +# operations in parallel. The default settings should work well as configured, +# however, to enhance performance for transfers involving large numbers of +# files, you may experiment with hand tuning these values to optimize +# performance for your particular system configuration. +# MacOS and Windows users should see +# https://github.com/GoogleCloudPlatform/gsutil/issues/77 before attempting +# to experiment with these values. +#parallel_process_count = 1 +#parallel_thread_count = 24 + +# 'parallel_composite_upload_threshold' specifies the maximum size of a file to +# upload in a single stream. Files larger than this threshold will be +# partitioned into component parts and uploaded in parallel and then composed +# into a single object. +# The number of components will be the smaller of +# ceil(file_size / parallel_composite_upload_component_size) and +# MAX_COMPONENT_COUNT. The current value of MAX_COMPONENT_COUNT is +# 1024. +# If 'parallel_composite_upload_threshold' is set to 0, then automatic parallel +# uploads will never occur. +# Setting an extremely low threshold is unadvisable. The vast majority of +# environments will see degraded performance for thresholds below 80M, and it +# is almost never advantageous to have a threshold below 20M. +# 'parallel_composite_upload_component_size' specifies the ideal size of a +# component in bytes, which will act as an upper bound to the size of the +# components if ceil(file_size / parallel_composite_upload_component_size) is +# less than MAX_COMPONENT_COUNT. +# Values can be provided either in bytes or as human-readable values +# (e.g., "150M" to represent 150 mebibytes) +# +# Note: At present parallel composite uploads are disabled by default, because +# using composite objects requires a compiled crcmod (see "gsutil help crcmod"), +# and for operating systems that don't already have this package installed this +# makes gsutil harder to use. Google is actively working with a number of the +# Linux distributions to get crcmod included with the stock distribution. Once +# that is done we will re-enable parallel composite uploads by default in +# gsutil. +# +# Note: Parallel composite uploads should not be used with NEARLINE or COLDLINE +# storage class buckets, as doing this incurs an early deletion charge for +# each component object. +#parallel_composite_upload_threshold = 0 +#parallel_composite_upload_component_size = 50M + +# 'sliced_object_download_threshold' and +# 'sliced_object_download_component_size' have analogous functionality to +# their respective parallel_composite_upload config values. +# 'sliced_object_download_max_components' specifies the maximum number of +# slices to be used when performing a sliced object download. It is not +# restricted by MAX_COMPONENT_COUNT. +#sliced_object_download_threshold = 0 +#sliced_object_download_component_size = 50M +#sliced_object_download_max_components = 4 + +# 'task_estimation_threshold' controls how many files or objects gsutil +# processes before it attempts to estimate the total work that will be +# performed by the command. Estimation makes extra directory listing or API +# list calls and is performed only if multiple processes and/or threads are +# used. Estimation can slightly increase cost due to extra +# listing calls; to disable it entirely, set this value to 0. +#task_estimation_threshold=30000 + +# 'use_magicfile' specifies if the 'file --mime-type ' command should +# be used to guess content types instead of the default filename extension-based +# mechanism. Available on UNIX and MacOS (and possibly on Windows, if you're +# running Cygwin or some other package that provides implementations of +# UNIX-like commands). When available and enabled use_magicfile should be more +# robust because it analyzes file contents in addition to extensions. +#use_magicfile = False + +# 'content_language' specifies the ISO 639-1 language code of the content, to be +# passed in the Content-Language header. By default no Content-Language is sent. +# See the ISO 639-1 column of +# http://www.loc.gov/standards/iso639-2/php/code_list.php for a list of +# language codes. +content_language = en + +# 'check_hashes' specifies how strictly to require integrity checking for +# downloaded data. Legal values are: +# 'if_fast_else_fail' - (default) Only integrity check if the digest +# will run efficiently (using compiled code), else fail the download. +# 'if_fast_else_skip' - Only integrity check if the server supplies a +# hash and the local digest computation will run quickly, else skip the +# check. +# 'always' - Always check download integrity regardless of possible +# performance costs. +# 'never' - Don't perform download integrity checks. This setting is +# not recommended except for special cases such as measuring download +# performance excluding time for integrity checking. +# This option exists to assist users who wish to download a GCS composite object +# and are unable to install crcmod with the C-extension. CRC32c is the only +# available integrity check for composite objects, and without the C-extension, +# download performance can be significantly degraded by the digest computation. +# This option is ignored for daisy-chain copies, which don't compute hashes but +# instead (inexpensively) compare the cloud source and destination hashes. +#check_hashes = if_fast_else_fail + +# 'encryption_key' specifies a single customer-supplied encryption key that +# will be used for all data written to Google Cloud Storage. See +# "gsutil help encryption" for more information +# Encryption key: RFC 4648 section 4 base64-encoded AES256 string +# Warning: If decrypt_key is specified without an encrypt_key, objects will be +# decrypted when copied in the cloud. +#encryption_key= + +# Each 'decryption_key' entry specifies a customer-supplied decryption key that +# will be used to access and Google Cloud Storage objects encrypted with +# the corresponding key. +# Decryption keys: Up to 100 RFC 4648 section 4 base64-encoded AES256 strings +# in ascending numerical order, starting with 1. +#decryption_key1= +#decryption_key2= +#decryption_key3= + +# The ability to specify an alternative JSON API version is primarily for cloud +# storage service developers. +#json_api_version = v1 + +# Specifies the API to use when interacting with cloud storage providers. If the +# gsutil command supports this API for the provider, it will be used instead of +# the default API. Commands typically default to XML for S3 and JSON for GCS. +# Note that if any encryption configuration options are set (see above), the +# JSON API will be used for interacting with Google Cloud Storage buckets even +# if XML is preferred, as gsutil does not currently support this functionality +# when using the XML API. +#prefer_api = json +#prefer_api = xml + +# Disables the prompt asking for opt-in to data collection for analytics. +#disable_analytics_prompt = True + + +# 'default_api_version' specifies the default Google Cloud Storage XML API +# version to use. If not set below gsutil defaults to API version 1. +default_api_version = 2 + +[OAuth2] +# This section specifies options used with OAuth2 authentication. + +# 'token_cache' specifies how the OAuth2 client should cache access tokens. +# Valid values are: +# 'in_memory': an in-memory cache is used. This is only useful if the boto +# client instance (and with it the OAuth2 plugin instance) persists +# across multiple requests. +# 'file_system' : access tokens will be cached in the file system, in files +# whose names include a key derived from the refresh token the access token +# based on. +# The default is 'file_system'. +#token_cache = file_system +#token_cache = in_memory + +# 'token_cache_path_pattern' specifies a path pattern for token cache files. +# This option is only relevant if token_cache = file_system. +# The value of this option should be a path, with place-holders '%(key)s' (which +# will be replaced with a key derived from the refresh token the cached access +# token was based on), and (optionally), %(uid)s (which will be replaced with +# the UID of the current user, if available via os.getuid()). +# Note that the config parser itself interpolates '%' placeholders, and hence +# the above placeholders need to be escaped as '%%(key)s'. +# The default value of this option is +# token_cache_path_pattern = /oauth2client-tokencache.%%(uid)s.%%(key)s +# where is the system-dependent default temp directory. + +# The following options specify the label and endpoint URIs for the OAUth2 +# authorization provider being used. Primarily useful for tool developers. +#provider_label = Google +#provider_authorization_uri = https://accounts.google.com/o/oauth2/auth +#provider_token_uri = https://accounts.google.com/o/oauth2/token + +# 'oauth2_refresh_retries' controls the number of retry attempts made when +# rate limiting errors occur for OAuth2 requests to retrieve an access token. +# The default value is 6. +#oauth2_refresh_retries = + +# The following options specify the OAuth2 client identity and secret that is +# used when requesting and using OAuth2 tokens. If not specified, a default +# OAuth2 client for the gsutil tool is used; for uses of the boto library (with +# OAuth2 authentication plugin) in other client software, it is recommended to +# use a tool/client-specific OAuth2 client. For more information on OAuth2, see +# http://code.google.com/apis/accounts/docs/OAuth2.html +#client_id = +#client_secret = diff --git a/gitconfig b/gitconfig new file mode 100644 index 0000000..dbd24ab --- /dev/null +++ b/gitconfig @@ -0,0 +1,13 @@ +[gpg] + program = /usr/local/MacGPG2/bin/gpg +[filter "lfs"] + process = git-lfs filter-process + required = true + clean = git-lfs clean -- %f + smudge = git-lfs smudge -- %f +[user] + name = Spotlight + email = awesomebing1@gmail.com + signingkey = CC3F4E0080AC47A3 +[commit] + gpgsign = true diff --git a/zshrc b/zshrc new file mode 100644 index 0000000..be410af --- /dev/null +++ b/zshrc @@ -0,0 +1,68 @@ +######### +# zplug configuraton +######### + +export ZPLUG_HOME=/usr/local/opt/zplug +source $ZPLUG_HOME/init.zsh + +zplug "plugins/git", from:oh-my-zsh + +# Stuff that modifies +zplug "zsh-users/zsh-syntax-highlighting", defer:3 +zplug "zsh-users/zsh-autosuggestions", defer:3 +zplug "zsh-users/zsh-completions", defer:3 + +setopt prompt_subst # Make sure prompt is able to be generated properly. +zplug "caiogondim/bullet-train.zsh", use:bullet-train.zsh-theme, defer:3 + +# Configure prompt to my liking. +BULLETTRAIN_PROMPT_ORDER=( + time + status + custom + context + dir + screen + ruby + go + git +) + +# Install plugins if there are plugins that have not been installed +if ! zplug check --verbose; then + printf "Install? [y/N]: " + if read -q; then + echo; zplug install + fi +fi + +# Let's do this. +zplug load + +######### +# the env _essentials_ +######### + +# Local stuff, homebrew python, theos +export PATH="${HOME}/bin:/usr/local/opt/theos/python/libexec/bin:${PATH}" +export EDITOR=nano + +# Google Cloud tools +source ${HOME}/bin/google-cloud-sdk/completion.zsh.inc +source ${HOME}/bin/google-cloud-sdk/path.zsh.inc + +# Go +export GOPATH=${HOME}/go +export PATH=${GOPATH}/bin:${PATH} + +# theos +export THEOS=/usr/local/opt/theos +export PATH=${THEOS}/bin:$PATH +export THEOS_DEVICE_IP=192.168.1.167 THEOS_DEVICE_PORT=22 + +# devkitPro and the like +export DEVKITPRO=${HOME}/devkitPro +export DEVKITPPC=${DEVKITPRO}/devkitPPC +export DEVKITARM=${DEVKITPRO}/devkitARM + +[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" ]]