awslimitchecker.services package¶

awslimitchecker.checker module¶

class awslimitchecker.checker.AwsLimitChecker(warning_threshold=80, critical_threshold=99)[source]¶

Bases: object

Main AwsLimitChecker class - this should be the only externally-used portion of awslimitchecker.

Constructor builds self.services as a dict of service_name (str) to _AwsService instance, and sets limit thresholds.

Parameters:	warning_threshold (int) – the default warning threshold, as an integer percentage, for any limits without a specifically-set threshold. critical_threshold (int) – the default critical threshold, as an integer percentage, for any limits without a specifically-set threshold.

__dict__ = dict_proxy({'set_limit_override': <function set_limit_override at 0x7fdd5dcd5b18>, '__module__': 'awslimitchecker.checker', 'find_usage': <function find_usage at 0x7fdd5dcd5a28>, 'get_service_names': <function get_service_names at 0x7fdd5dcd59b0>, 'set_threshold_overrides': <function set_threshold_overrides at 0x7fdd5dcd5b90>, 'get_version': <function get_version at 0x7fdd5dcd5848>, 'check_thresholds': <function check_thresholds at 0x7fdd5dcd5c80>, 'set_threshold_override': <function set_threshold_override at 0x7fdd5dcd5c08>, 'get_limits': <function get_limits at 0x7fdd5dcd5938>, 'set_limit_overrides': <function set_limit_overrides at 0x7fdd5dcd5aa0>, '__dict__': <attribute '__dict__' of 'AwsLimitChecker' objects>, 'get_required_iam_policy': <function get_required_iam_policy at 0x7fdd5dcd5cf8>, '__weakref__': <attribute '__weakref__' of 'AwsLimitChecker' objects>, '__doc__': None, '__init__': <function __init__ at 0x7fdd5dcd57d0>, 'get_project_url': <function get_project_url at 0x7fdd5dcd58c0>})¶

__init__(warning_threshold=80, critical_threshold=99)[source]¶

Main AwsLimitChecker class - this should be the only externally-used portion of awslimitchecker.

Constructor builds self.services as a dict of service_name (str) to _AwsService instance, and sets limit thresholds.

Parameters:	warning_threshold (int) – the default warning threshold, as an integer percentage, for any limits without a specifically-set threshold. critical_threshold (int) – the default critical threshold, as an integer percentage, for any limits without a specifically-set threshold.

__module__ = 'awslimitchecker.checker'¶

__weakref__¶

list of weak references to the object (if defined)

check_thresholds(service=None, use_ta=True)[source]¶

Check all limits and current usage against their specified thresholds; return all AwsLimit instances that have crossed one or more of their thresholds.

If service is specified, the returned dict has one element, the service name, whose value is a nested dict as described below; otherwise it includes all known services.

The returned AwsLimit objects can be interrogated for their limits (get_limit()) as well as the details of usage that crossed the thresholds (get_warnings() and get_criticals()).

Parameters:	service (string) – the name of one service to return results for use_ta (bool) – check Trusted Advisor for information on limits
Returns:	dict of service name (string) to nested dict of limit name (string) to limit (AwsLimit)
Return type:	dict

find_usage(service=None, use_ta=True)[source]¶

For each limit in the specified service (or all services if service is None), query the AWS API via boto and find the current usage amounts for that limit.

This method updates the current_usage attribute of the AwsLimit objects for each service, which can then be queried using get_limits().

Parameters:	service (None, or string service name to get) – _AwsService name, or None to check all services. use_ta (bool) – check Trusted Advisor for information on limits

get_limits(service=None, use_ta=True)[source]¶

Return all AwsLimit objects for the given service name, or for all services if service is None.

If service is specified, the returned dict has one element, the service name, whose value is a nested dict as described below.

Parameters:	service (string) – the name of one service to return limits for use_ta (bool) – check Trusted Advisor for information on limits
Returns:	dict of service name (string) to nested dict of limit name (string) to limit (AwsLimit)
Return type:	dict

get_project_url()[source]¶

Return the URL for the awslimitchecker project.

Returns:	URL of where to find awslimitchecker
Return type:	string

get_required_iam_policy()[source]¶

Return an IAM policy granting all of the permissions needed for awslimitchecker to fully function. This returns a dict suitable for json serialization to a valid IAM policy.

Internally, this calls required_iam_permissions() on each _AwsService instance.

Returns:	dict representation of IAM Policy
Return type:	dict

get_service_names()[source]¶

Return a list of all known service names

Returns:	list of service names
Return type:	list

get_version()[source]¶

Return the version of awslimitchecker currently running.

Returns:	current awslimitchecker version
Return type:	string

set_limit_override(service_name, limit_name, value, override_ta=True)[source]¶

Set a manual override on an AWS service limits, i.e. if you had limits increased by AWS support.

This method calls set_limit_override() on the corresponding _AwsService instance.

Explicitly set limit overrides using this method will take precedence over default limits. They will also take precedence over limit information obtained via Trusted Advisor, unless override_ta is set to False.

Parameters:	service_name (string) – the name of the service to override limit for limit_name (string) – the name of the limit to override: value (int) – the new (overridden) limit value) override_ta (bool) – whether or not to use this value even if Trusted Advisor supplies limit information
Raises:	ValueError if limit_name is not known to the service instance

set_limit_overrides(override_dict, override_ta=True)[source]¶

Set manual overrides on AWS service limits, i.e. if you had limits increased by AWS support. This takes a dict in the same form as that returned by get_limits(), i.e. service_name (str) keys to nested dict of limit_name (str) to limit value (int) like:

{
    'EC2': {
      'Running On-Demand t2.micro Instances': 1000,
      'Running On-Demand r3.4xlarge Instances': 1000,
    }
}

Internally, for each limit override for each service in override_dict, this method calls set_limit_override() on the corresponding _AwsService instance.

Explicitly set limit overrides using this method will take precedence over default limits. They will also take precedence over limit information obtained via Trusted Advisor, unless override_ta is set to False.

Parameters:	override_dict (dict) – dict of overrides to default limits override_ta (bool) – whether or not to use this value even if Trusted Advisor supplies limit information
Raises:	exceptions.ValueError if limit_name is not known to the service instance

set_threshold_override(service_name, limit_name, warn_percent=None, warn_count=None, crit_percent=None, crit_count=None)[source]¶

Set a manual override on the threshold (used for determining warning/critical status) for a specific limit. See AwsLimitChecker for information on Warning and Critical thresholds.

See set_threshold_override().

Parameters:	service_name (string) – the name of the service to override limit for limit_name (string) – the name of the limit to override: warn_percent (int) – new warning threshold, percentage used warn_count (int) – new warning threshold, actual count/number crit_percent (int) – new critical threshold, percentage used crit_count (int) – new critical threshold, actual count/number

set_threshold_overrides(override_dict)[source]¶

Set manual overrides on the threshold (used for determining warning/critical status) a dict of limits. See AwsLimitChecker for information on Warning and Critical thresholds.

Dict is composed of service name keys (string) to dict of limit names (string), to dict of threshold specifications. Each threhold specification dict can contain keys ‘warning’ or ‘critical’, each having a value of a dict containing keys ‘percent’ or ‘count’, to an integer value.

Example:

{
    'EC2': {
        'SomeLimit': {
            'warning': {
                'percent': 80,
                'count': 8,
            },
            'critical': {
                'percent': 90,
                'count': 9,
            }
        }
    }
}

See set_threshold_override().

Parameters:	override_dict (dict) – nested dict of threshold overrides

awslimitchecker.limit module¶

class awslimitchecker.limit.AwsLimit(name, service, default_limit, def_warning_threshold, def_critical_threshold, limit_type=None, limit_subtype=None)[source]¶

Bases: object

Describes one specific AWS service limit, as well as its current utilization, default limit, thresholds, and any Trusted Advisor information about this limit.

Parameters:

name (string) – the name of this limit (may contain spaces); if possible, this should be the name used by AWS, i.e. TrustedAdvisor service – the _AwsService class that this limit is for default_limit (int) – the default value of this limit for new accounts def_warning_threshold (int) – the default warning threshold, as an integer percentage. def_critical_threshold (int) – the default critical threshold, as an integer percentage. limit_type – the type of resource this limit describes, specified as one of the type names used in CloudFormation # noqa such as “AWS::EC2::Instance” or “AWS::RDS::DBSubnetGroup”. limit_subtype – resource sub-type for this limit, if applicable, such as “t2.micro” or “SecurityGroup”

Raises:

ValueError

__dict__ = dict_proxy({'set_limit_override': <function set_limit_override at 0x7fdd5ddbbc08>, '__module__': 'awslimitchecker.limit', 'get_limit': <function get_limit at 0x7fdd5ddbbd70>, 'get_current_usage_str': <function get_current_usage_str at 0x7fdd5ddbbe60>, '_set_ta_limit': <function _set_ta_limit at 0x7fdd5ddbbc80>, '__weakref__': <attribute '__weakref__' of 'AwsLimit' objects>, 'check_thresholds': <function check_thresholds at 0x7fdd5dd42140>, 'get_criticals': <function get_criticals at 0x7fdd5dd42230>, 'get_current_usage': <function get_current_usage at 0x7fdd5ddbbde8>, '__dict__': <attribute '__dict__' of 'AwsLimit' objects>, 'set_threshold_override': <function set_threshold_override at 0x7fdd5dd420c8>, '_reset_usage': <function _reset_usage at 0x7fdd5ddbbf50>, 'get_limit_source': <function get_limit_source at 0x7fdd5ddbbcf8>, 'get_warnings': <function get_warnings at 0x7fdd5dd421b8>, '_get_thresholds': <function _get_thresholds at 0x7fdd5dd42050>, '_add_current_usage': <function _add_current_usage at 0x7fdd5ddbbed8>, '__doc__': None, '__init__': <function __init__ at 0x7fdd5ddbbb90>})¶

__init__(name, service, default_limit, def_warning_threshold, def_critical_threshold, limit_type=None, limit_subtype=None)[source]¶

Describes one specific AWS service limit, as well as its current utilization, default limit, thresholds, and any Trusted Advisor information about this limit.

Parameters:

name (string) – the name of this limit (may contain spaces); if possible, this should be the name used by AWS, i.e. TrustedAdvisor service – the _AwsService class that this limit is for default_limit (int) – the default value of this limit for new accounts def_warning_threshold (int) – the default warning threshold, as an integer percentage. def_critical_threshold (int) – the default critical threshold, as an integer percentage. limit_type – the type of resource this limit describes, specified as one of the type names used in CloudFormation # noqa such as “AWS::EC2::Instance” or “AWS::RDS::DBSubnetGroup”. limit_subtype – resource sub-type for this limit, if applicable, such as “t2.micro” or “SecurityGroup”

Raises:

ValueError

__module__ = 'awslimitchecker.limit'¶

__weakref__¶

list of weak references to the object (if defined)

_add_current_usage(value, resource_id=None, aws_type=None)[source]¶

Add a new current usage value for this limit.

Creates a new AwsLimitUsage instance and appends it to the internal list. If more than one usage value is given to this service, they should have id and aws_type set.

This method should only be called from the _AwsService instance that created and manages this Limit.

Parameters:	value (int or float) – the numeric usage value resource_id (string) – If there can be multiple usage values for one limit, an AWS ID for the resource this instance describes aws_type (string) – if id is not None, the AWS resource type that ID represents. As a convention, we use the AWS Resource Type names used by CloudFormation # noqa

_get_thresholds()[source]¶

Get the warning and critical thresholds for this Limit.

Return type is a 4-tuple of:

1. warning integer (usage) threshold, or None
2. warning percent threshold
3. critical integer (usage) threshold, or None
4. critical percent threshold

Return type:	tuple

_reset_usage()[source]¶

Discard all current usage data.

_set_ta_limit(limit_value)[source]¶

Set the value for the limit as reported by Trusted Advisor.

This method should only be called by TrustedAdvisor.

Parameters:	limit_value (int) – the Trusted Advisor limit value

check_thresholds()[source]¶

Check this limit’s current usage against the specified default thresholds, and any custom theresholds that have been set on the instance. Return True if usage is within thresholds, or false if warning or critical thresholds have been surpassed.

This method sets internal variables in this instance which can be queried via get_warnings() and get_criticals() to obtain further details about the thresholds that were crossed.

Parameters:	default_warning (int or float percentage) – default warning threshold in percentage; usage higher than this percent of the limit will be considered a warning default_critical (int or float percentage) – default critical threshold in percentage; usage higher than this percent of the limit will be considered a critical
Returns:	False if any thresholds crossed, True otherwise
Return type:	bool

get_criticals()[source]¶

Return a list of AwsLimitUsage instances that crossed the critical threshold. These objects are comparable and can be sorted.

Return type:	list

get_current_usage()[source]¶

Get the current usage for this limit, as a list of AwsLimitUsage instances.

Returns:	list of current usage values
Return type:	list of AwsLimitUsage

get_current_usage_str()[source]¶

Get the a string describing the current usage for this limit.

If no usage has been added for this limit, the result will be “<unknown>”.

If the limit has only one current usage instance, this will be that instance’s __str__() value.

If the limit has more than one current usage instance, this will be the a string of the form max: X (Y) where X is the __str__() value of the instance with the maximum value, and Y is a comma-separated list of the __str__() values of all usage instances in ascending order.

Returns:	representation of current usage
Return type:	string

get_limit()[source]¶

Returns the effective limit value for this Limit, taking into account limit overrides and Trusted Advisor data.

Returns:	effective limit value
Return type:	int

get_limit_source()[source]¶

Return SOURCE_DEFAULT if get_limit() returns the default limit, SOURCE_OVERRIDE if it returns a manually-overridden limit, or SOURCE_TA if it returns a limit from Trusted Advisor.

Returns:	one of SOURCE_DEFAULT, SOURCE_OVERRIDE, or SOURCE_TA
Return type:	int

get_warnings()[source]¶

Return a list of AwsLimitUsage instances that crossed the warning threshold. These objects are comparable and can be sorted.

Return type:	list

set_limit_override(limit_value, override_ta=True)[source]¶

Set a new value for this limit, to override the default (such as when AWS Support has increased a limit of yours). If override_ta is True, this value will also supersede any found through Trusted Advisor.

Parameters:	limit_value (int) – the new limit value override_ta (bool) – whether or not to also override Trusted Advisor information

set_threshold_override(warn_percent=None, warn_count=None, crit_percent=None, crit_count=None)[source]¶

Override the default warning and critical thresholds used to evaluate this limit’s usage. Theresholds can be specified as a percentage of the limit, or as a usage count, or both.

Parameters:	warn_percent (int) – new warning threshold, percentage used warn_count (int) – new warning threshold, actual count/number crit_percent (int) – new critical threshold, percentage used crit_count (int) – new critical threshold, actual count/number

class awslimitchecker.limit.AwsLimitUsage(limit, value, resource_id=None, aws_type=None)[source]¶

Bases: object

This object describes the usage of an AWS resource, with the capability of containing information about the resource beyond an integer usage.

The simplest case is an account- / region-wide count, such as the number of running EC2 Instances, in which case a simple integer value is sufficient. In this case, the AwsLimit would have one instance of this class for the single value.

In more complex cases, such as the “Subnets per VPC”, the limit is applied by AWS on multiple resources (once per VPC). In this case, the AwsLimit should have one instance of this class per VPC, so we can determine which VPCs have crossed thresholds.

AwsLimitUsage objects are comparable based on their numeric value.

Parameters:	limit (AwsLimit) – the AwsLimit that this instance describes value (int or float) – the numeric usage value resource_id (string) – If there can be multiple usage values for one limit, an AWS ID for the resource this instance describes aws_type (string) – if id is not None, the AWS resource type that ID represents. As a convention, we use the AWS Resource Type names used by CloudFormation # noqa

__dict__ = dict_proxy({'__ne__': <function __ne__ at 0x7fdd5dd42488>, '__module__': 'awslimitchecker.limit', '__weakref__': <attribute '__weakref__' of 'AwsLimitUsage' objects>, '__str__': <function __str__ at 0x7fdd5dd42398>, 'get_value': <function get_value at 0x7fdd5dd42320>, '__init__': <function __init__ at 0x7fdd5dd422a8>, '__gt__': <function __gt__ at 0x7fdd5dd42500>, '__dict__': <attribute '__dict__' of 'AwsLimitUsage' objects>, '__lt__': <function __lt__ at 0x7fdd5dd42578>, '__eq__': <function __eq__ at 0x7fdd5dd42410>, '__doc__': None, '__ge__': <function __ge__ at 0x7fdd5dd425f0>})¶

__eq__(other)[source]¶

__ge__(other)[source]¶

__gt__(other)[source]¶

__init__(limit, value, resource_id=None, aws_type=None)[source]¶

This object describes the usage of an AWS resource, with the capability of containing information about the resource beyond an integer usage.

The simplest case is an account- / region-wide count, such as the number of running EC2 Instances, in which case a simple integer value is sufficient. In this case, the AwsLimit would have one instance of this class for the single value.

In more complex cases, such as the “Subnets per VPC”, the limit is applied by AWS on multiple resources (once per VPC). In this case, the AwsLimit should have one instance of this class per VPC, so we can determine which VPCs have crossed thresholds.

AwsLimitUsage objects are comparable based on their numeric value.

Parameters:	limit (AwsLimit) – the AwsLimit that this instance describes value (int or float) – the numeric usage value resource_id (string) – If there can be multiple usage values for one limit, an AWS ID for the resource this instance describes aws_type (string) – if id is not None, the AWS resource type that ID represents. As a convention, we use the AWS Resource Type names used by CloudFormation # noqa

__lt__(other)[source]¶

__module__ = 'awslimitchecker.limit'¶

__ne__(other)[source]¶

__str__()[source]¶

Return a string representation of this object.

If id is not set, return value formatted as a string; otherwise, return a string of the format id=value.

Return type:	string

__weakref__¶

list of weak references to the object (if defined)

get_value()[source]¶

Get the current usage value

Returns:	current usage value
Return type:	int or float

awslimitchecker.limit.SOURCE_DEFAULT = 0¶

indicates a limit value that came from hard-coded defaults in awslimitchecker

awslimitchecker.limit.SOURCE_OVERRIDE = 1¶

indicates a limit value that came from user-defined limit overrides

awslimitchecker.limit.SOURCE_TA = 2¶

indicates a limit value that came from Trusted Advisor

awslimitchecker.runner module¶

class awslimitchecker.runner.Runner[source]¶

Bases: object

__dict__ = dict_proxy({'__module__': 'awslimitchecker.runner', 'color_output': <function color_output at 0x7fdd5d986d70>, 'parse_args': <function parse_args at 0x7fdd5d986aa0>, '__weakref__': <attribute '__weakref__' of 'Runner' objects>, 'list_services': <function list_services at 0x7fdd5d986b18>, 'check_thresholds': <function check_thresholds at 0x7fdd5d986e60>, 'console_entry_point': <function console_entry_point at 0x7fdd5d986f50>, '__doc__': None, 'list_defaults': <function list_defaults at 0x7fdd5d986c08>, 'iam_policy': <function iam_policy at 0x7fdd5d986c80>, '__dict__': <attribute '__dict__' of 'Runner' objects>, 'set_limit_overrides': <function set_limit_overrides at 0x7fdd5d986ed8>, 'list_limits': <function list_limits at 0x7fdd5d986b90>, 'print_issue': <function print_issue at 0x7fdd5d986de8>, '__init__': <function __init__ at 0x7fdd5d986a28>, 'show_usage': <function show_usage at 0x7fdd5d986cf8>})¶

__init__()[source]¶

__module__ = 'awslimitchecker.runner'¶

__weakref__¶

list of weak references to the object (if defined)

check_thresholds()[source]¶

color_output(s, color)[source]¶

console_entry_point()[source]¶

iam_policy()[source]¶

list_defaults()[source]¶

list_limits()[source]¶

list_services()[source]¶

parse_args(argv)[source]¶

parse arguments/options

Parameters:	argv (list) – argument list to parse, usually sys.argv[1:]
Returns:	parsed arguments
Return type:	argparse.Namespace

print_issue(service_name, limit, crits, warns)[source]¶

Parameters:	service_name (str) – the name of the service limit (AwsLimit) – the Limit this relates to crits – the specific usage values that crossed the critical threshold crits – the specific usage values that crossed the warning threshold

set_limit_overrides(overrides)[source]¶

show_usage()[source]¶

awslimitchecker.runner.console_entry_point()[source]¶

awslimitchecker.trustedadvisor module¶

class awslimitchecker.trustedadvisor.TrustedAdvisor[source]¶

Bases: object

Class to contain all TrustedAdvisor-related logic.

__dict__ = dict_proxy({'__module__': 'awslimitchecker.trustedadvisor', '_get_limit_check_id': <function _get_limit_check_id at 0x7fdd5dcd56e0>, '_poll': <function _poll at 0x7fdd5dcd5668>, 'update_limits': <function update_limits at 0x7fdd5dcd55f0>, '__dict__': <attribute '__dict__' of 'TrustedAdvisor' objects>, '_update_services': <function _update_services at 0x7fdd5dcd5758>, '__weakref__': <attribute '__weakref__' of 'TrustedAdvisor' objects>, '__doc__': None, '__init__': <function __init__ at 0x7fdd5dcd5500>, 'connect': <function connect at 0x7fdd5dcd5578>})¶

__init__()[source]¶

Class to contain all TrustedAdvisor-related logic.

__module__ = 'awslimitchecker.trustedadvisor'¶

__weakref__¶

list of weak references to the object (if defined)

_get_limit_check_id()[source]¶

Query currently-available TA checks, return the check ID and metadata of the ‘performance/Service Limits’ check.

Returns:	2-tuple of Service Limits TA check ID (string), metadata (list), or (None, None).
Return type:	tuple

_poll()[source]¶

Poll Trusted Advisor (Support) API for limit checks.

Return a dict of service name (string) keys to nested dict vals, where each key is a limit name and each value the current numeric limit.

e.g.:

{
    'EC2': {
        'SomeLimit': 10,
    }
}

_update_services(ta_results, services)[source]¶

Given a dict of TrustedAdvisor check results from _poll() and a dict of Service objects passed in to update_limits(), updated the TrustedAdvisor limits for all services.

Parameters:	ta_results (dict) – results returned by _poll() services (dict) – dict of service names to _AwsService objects

connect()[source]¶

update_limits(services)[source]¶

Poll ‘Service Limits’ check results from Trusted Advisor, if possible. Iterate over all AwsLimit objects for the given services and update their limits from TA if present in TA checks.

Parameters:	services (dict) – dict of service name (string) to _AwsService objects

awslimitchecker.utils module¶

class awslimitchecker.utils.StoreKeyValuePair(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)[source]¶

Bases: argparse.Action

Store key=value options in a dict as {‘key’: ‘value’}.

Supports specifying the option multiple times, but NOT with nargs.

See Action.

__call__(parser, namespace, values, option_string=None)[source]¶

__init__(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)[source]¶

__module__ = 'awslimitchecker.utils'¶

awslimitchecker.utils.dict2cols(d, spaces=2, separator=' ')[source]¶

Take a dict of string keys and string values, and return a string with them formatted as two columns separated by at least spaces number of separator characters.

Parameters:	d (dict) – dict of string keys, string values spaces (int) – number of spaces to separate columns by separator (string) – character to fill in between columns

awslimitchecker.version module¶

class awslimitchecker.version.AWSLimitCheckerVersion(release, url, commit=None, tag=None)[source]¶

Bases: object

__dict__ = dict_proxy({'__module__': 'awslimitchecker.version', '__str__': <function __str__ at 0x7fdd5f85faa0>, '__repr__': <function __repr__ at 0x7fdd5f85fb18>, 'version_str': <property object at 0x7fdd6156eb50>, '__dict__': <attribute '__dict__' of 'AWSLimitCheckerVersion' objects>, '__weakref__': <attribute '__weakref__' of 'AWSLimitCheckerVersion' objects>, '__doc__': None, '__init__': <function __init__ at 0x7fdd5f85f9b0>})¶

__init__(release, url, commit=None, tag=None)[source]¶

__module__ = 'awslimitchecker.version'¶

__repr__()[source]¶

Return a representation of this object that is valid Python and will create an idential AWSLimitCheckerVersion object.

Return type:	string

__str__()[source]¶

Human-readable string representation of this version object, in the format: “version_str <url>”

Return type:	string

__weakref__¶

list of weak references to the object (if defined)

version_str¶

The version string for the currently-running awslimitchecker; includes git branch and tag information.

Return type:	string

awslimitchecker.version._get_version_info()[source]¶

Returns the currently-installed awslimitchecker version, and a best-effort attempt at finding the origin URL and commit/tag if installed from an editable git clone.

Returns:	awslimitchecker version
Return type:	string

awslimitchecker.versioncheck module¶

class awslimitchecker.versioncheck.AGPLVersionChecker[source]¶

Bases: object

__dict__ = dict_proxy({'__dict__': <attribute '__dict__' of 'AGPLVersionChecker' objects>, '__module__': 'awslimitchecker.versioncheck', '_dist_version_url': <function _dist_version_url at 0x7fdd5f85f668>, '_is_git_dirty': <function _is_git_dirty at 0x7fdd5f85f758>, '_find_pip_info': <function _find_pip_info at 0x7fdd5f85f5f0>, '__weakref__': <attribute '__weakref__' of 'AGPLVersionChecker' objects>, '__doc__': None, '_find_git_info': <function _find_git_info at 0x7fdd5f85f6e0>, '_find_pkg_info': <function _find_pkg_info at 0x7fdd5f85f578>, 'find_package_version': <function find_package_version at 0x7fdd5f85f500>})¶

__module__ = 'awslimitchecker.versioncheck'¶

__weakref__¶

list of weak references to the object (if defined)

_dist_version_url(dist)[source]¶

Get version and homepage for a pkg_resources.Distribution

Parameters:	dist – the pkg_resources.Distribution to get information for
Returns:	2-tuple of (version, homepage URL)
Return type:	tuple

_find_git_info()[source]¶

Find information about the git repository, if this file is in a clone.

Returns:	information about the git clone
Return type:	dict

_find_pip_info()[source]¶

Try to find information about the installed awslimitchecker from pip. This should be wrapped in a try/except.

Returns:	information from pip about ‘awslimitchecker’
Return type:	dict

_find_pkg_info()[source]¶

Find information about the installed awslimitchecker from pkg_resources.

Returns:	information from pkg_resources about ‘awslimitchecker’
Return type:	dict

_is_git_dirty()[source]¶

Determine if the git clone has uncommitted changes or is behind origin

Returns:	True if clone is dirty, False otherwise
Return type:	bool

find_package_version()[source]¶

Find the installed version of the specified package, and as much information about it as possible (source URL, git ref or tag, etc.)

This attempts, to the best of our ability, to find out if the package was installed from git, and if so, provide information on the origin of that git repository and status of the clone. Otherwise, it uses pip and pkg_resources to find the version and homepage of the installed distribution.

This class is not a sure-fire method of identifying the source of the distribution or ensuring AGPL compliance; it simply helps with this process _iff_ a modified version is installed from an editable git URL _and_ all changes are pushed up to the publicly-visible origin.

Returns a dict with keys ‘version’, ‘tag’, ‘commit’, and ‘url’. Values are strings or None.

Parameters:	package_name (str) – name of the package to find information for
Returns:	information about the installed version of the package
Return type:	dict

awslimitchecker.versioncheck._check_output(args, stderr=None)[source]¶

Python version compatibility wrapper for subprocess.check_output

Parameters:	stderr – what to do with STDERR - None or an appropriate argument to subprocess.check_output / subprocess.Popen
Raises:	subprocess.CalledProcessError
Returns:	command output
Return type:	string

awslimitchecker.versioncheck._get_git_commit()[source]¶

Get the current (short) git commit hash of the current directory.

Returns:	short git hash
Return type:	string

awslimitchecker.versioncheck._get_git_tag(commit)[source]¶

Get the git tag for the specified commit, or None

Parameters:	commit (string) – git commit hash to get the tag for
Returns:	tag name pointing to commit
Return type:	string

awslimitchecker.versioncheck._get_git_url()[source]¶

Get the origin URL for the git repository.

Returns:	repository origin URL
Return type:	string