code
string | signature
string | docstring
string | loss_without_docstring
float64 | loss_with_docstring
float64 | factor
float64 |
|---|---|---|---|---|---|
self._owner_type = value
if value == 'User':
self._fields['owner'] = entity_fields.OneToOneField(User)
if hasattr(self, 'owner'):
# pylint:disable=no-member
self.owner = User(
self._server_config,
id=self.owner.id if isinstance(self.owner, Entity)
else self.owner
)
elif value == 'Usergroup':
self._fields['owner'] = entity_fields.OneToOneField(UserGroup)
if hasattr(self, 'owner'):
# pylint:disable=no-member
self.owner = UserGroup(
self._server_config,
id=self.owner.id if isinstance(self.owner, Entity)
else self.owner
)
|
def owner_type(self, value)
|
Set ``owner_type`` to the given value.
In addition:
* Update the internal type of the ``owner`` field.
* Update the value of the ``owner`` field if a value is already set.
| 2.461724
| 2.525848
| 0.974613
|
attrs = super(Host, self).get_values()
if '_owner_type' in attrs and attrs['_owner_type'] is not None:
attrs['owner_type'] = attrs.pop('_owner_type')
else:
attrs.pop('_owner_type')
return attrs
|
def get_values(self)
|
Correctly set the ``owner_type`` attribute.
| 3.648998
| 2.712677
| 1.345165
|
return Host(
self._server_config,
id=self.create_json(create_missing)['id'],
).read()
|
def create(self, create_missing=None)
|
Manually fetch a complete set of attributes for this entity.
For more information, see `Bugzilla #1449749
<https://bugzilla.redhat.com/show_bug.cgi?id=1449749>`_.
| 16.941069
| 18.14599
| 0.933598
|
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
response = client.put(self.path('errata/applicability'), **kwargs)
return _handle_response(response, self._server_config, synchronous)
|
def errata_applicability(self, synchronous=True, **kwargs)
|
Force regenerate errata applicability
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all content decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 6.776036
| 6.809268
| 0.995119
|
if attrs is None:
attrs = self.read_json()
if ignore is None:
ignore = set()
if 'parameters' in attrs:
attrs['host_parameters_attributes'] = attrs.pop('parameters')
else:
ignore.add('host_parameters_attributes')
if 'content_facet_attributes' not in attrs:
ignore.add('content_facet_attributes')
ignore.add('compute_attributes')
ignore.add('interfaces_attributes')
ignore.add('root_pass')
# Image entity requires compute_resource_id to initialize as it is
# part of its path. The thing is that entity_mixins.read() initializes
# entities by id only.
# Workaround is to add image to ignore, call entity_mixins.read()
# and then add 'manually' initialized image to the result.
# If image_id is None set image to None as it is done by default.
ignore.add('image')
# host id is required for interface initialization
ignore.add('interface')
ignore.add('build_status_label')
result = super(Host, self).read(entity, attrs, ignore, params)
if attrs.get('image_id'):
result.image = Image(
server_config=self._server_config,
id=attrs.get('image_id'),
compute_resource=attrs.get('compute_resource_id'),
)
else:
result.image = None
if 'interfaces' in attrs and attrs['interfaces']:
result.interface = [
Interface(
self._server_config,
host=result.id,
id=interface['id'],
)
for interface in attrs['interfaces']
]
if 'build_status_label' in attrs:
result.build_status_label = attrs['build_status_label']
return result
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Deal with oddly named and structured data returned by the server.
For more information, see `Bugzilla #1235019
<https://bugzilla.redhat.com/show_bug.cgi?id=1235019>`_
and `Bugzilla #1449749
<https://bugzilla.redhat.com/show_bug.cgi?id=1449749>`_.
`content_facet_attributes` are returned only in case any of facet
attributes were actually set.
Also add image to the response if needed, as
:meth:`nailgun.entity_mixins.EntityReadMixin.read` can't initialize
image.
| 4.256613
| 3.906388
| 1.089655
|
if which in (
'enc',
'errata',
'errata/apply',
'errata/applicability',
'facts',
'packages',
'power',
'puppetclass_ids',
'smart_class_parameters',
'smart_variables',
'module_streams',
):
return '{0}/{1}'.format(
super(Host, self).path(which='self'),
which
)
elif which in ('bulk/install_content',):
return '{0}/{1}'.format(
super(Host, self).path(which='base'),
which
)
elif which in ('upload_facts',):
return '{0}/{1}'.format(
super(Host, self).path(which='base'),
'facts'
)
return super(Host, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
bulk/install_content
/api/hosts/:host_id/bulk/install_content
errata
/api/hosts/:host_id/errata
power
/api/hosts/:host_id/power
errata/apply
/api/hosts/:host_id/errata/apply
puppetclass_ids
/api/hosts/:host_id/puppetclass_ids
smart_class_parameters
/api/hosts/:host_id/smart_class_parameters
smart_variables
/api/hosts/:host_id/smart_class_variables
module_streams
/api/hosts/:host_id/module_streams
Otherwise, call ``super``.
| 5.166258
| 2.464466
| 2.096299
|
results = self.search_json(fields, query)['results']
results = self.search_normalize(results)
entities = []
for result in results:
image = result.get('image')
if image is not None:
del result['image']
entity = type(self)(self._server_config, **result)
if image:
entity.image = Image(
server_config=self._server_config,
id=image,
compute_resource=AbstractComputeResource(
server_config=self._server_config,
id=result.get('compute_resource')
),
)
entities.append(entity)
if filters is not None:
entities = self.search_filter(entities, filters)
return entities
|
def search(self, fields=None, query=None, filters=None)
|
Search for entities.
:param fields: A set naming which fields should be used when generating
a search query. If ``None``, all values on the entity are used. If
an empty set, no values are used.
:param query: A dict containing a raw search query. This is melded in
to the generated search query like so: ``{generated:
query}.update({manual: query})``.
:param filters: A dict. Used to filter search results locally.
:return: A list of entities, all of type ``type(self)``.
| 3.34545
| 3.213245
| 1.041144
|
# read() should not change the state of the object it's called on, but
# super() alters the attributes of any entity passed in. Creating a new
# object and passing it to super() lets this one avoid changing state.
if entity is None:
entity = type(self)(
self._server_config,
compute_resource=self.compute_resource, # pylint:disable=E1101
)
if ignore is None:
ignore = set()
ignore.add('compute_resource')
return super(Image, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Provide a default value for ``entity``.
By default, ``nailgun.entity_mixins.EntityReadMixin.read`` provides a
default value for ``entity`` like so::
entity = type(self)()
However, :class:`Image` requires that an
``compute_resource`` be provided, so this technique will not work. Do
this instead::
entity = type(self)(compute_resource=self.compute_resource.id)
| 5.982015
| 6.1198
| 0.977485
|
# read() should not change the state of the object it's called on, but
# super() alters the attributes of any entity passed in. Creating a new
# object and passing it to super() lets this one avoid changing state.
if entity is None:
entity = type(self)(
self._server_config,
host=self.host, # pylint:disable=no-member
)
if attrs is None:
attrs = self.read_json()
if ignore is None:
ignore = set()
ignore.add('host')
# type-specific fields
if attrs['type'] != 'bmc':
ignore.add('password')
ignore.add('provider')
ignore.add('username')
if attrs['type'] != 'bond':
ignore.add('mode')
ignore.add('bond_options')
if attrs['type'] != 'virtual':
ignore.add('attached_to')
ignore.add('tag')
if attrs['type'] != 'bridge' and attrs['type'] != 'bond':
ignore.add('attached_devices')
return super(Interface, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Provide a default value for ``entity``.
By default, ``nailgun.entity_mixins.EntityReadMixin.read`` provides a
default value for ``entity`` like so::
entity = type(self)()
However, :class:`Interface` requires that a ``host`` must be provided,
so this technique will not work. Do this instead::
entity = type(self)(host=self.host)
In addition, some of interface fields are specific to its ``type`` and
are never returned for different ``type`` so ignoring all the redundant
fields.
| 4.58369
| 4.608776
| 0.994557
|
for interface in results:
interface[u'host_id'] = self.host.id # pylint:disable=no-member
return super(Interface, self).search_normalize(results)
|
def search_normalize(self, results)
|
Append host id to search results to be able to initialize found
:class:`Interface` successfully
| 5.839902
| 3.999965
| 1.459988
|
payload = super(LifecycleEnvironment, self).create_payload()
if (_get_version(self._server_config) < Version('6.1') and
'prior_id' in payload):
payload['prior'] = payload.pop('prior_id')
return payload
|
def create_payload(self)
|
Rename the payload key "prior_id" to "prior".
For more information, see `Bugzilla #1238757
<https://bugzilla.redhat.com/show_bug.cgi?id=1238757>`_.
| 7.919258
| 5.115788
| 1.548003
|
# We call `super` first b/c it populates `self.organization`, and we
# need that field to perform a search a little later.
super(LifecycleEnvironment, self).create_missing()
if (self.name != 'Library' and # pylint:disable=no-member
not hasattr(self, 'prior')):
results = self.search({'organization'}, {u'name': u'Library'})
if len(results) != 1:
raise APIResponseError(
u'Could not find the "Library" lifecycle environment for '
u'organization {0}. Search results: {1}'
.format(self.organization, results) # pylint:disable=E1101
)
self.prior = results[0]
|
def create_missing(self)
|
Automatically populate additional instance attributes.
When a new lifecycle environment is created, it must either:
* Reference a parent lifecycle environment in the tree of lifecycle
environments via the ``prior`` field, or
* have a name of "Library".
Within a given organization, there can only be a single lifecycle
environment with a name of 'Library'. This lifecycle environment is at
the root of a tree of lifecycle environments, so its ``prior`` field is
blank.
This method finds the 'Library' lifecycle environment within the
current organization and points to it via the ``prior`` field. This is
not done if the current lifecycle environment has a name of 'Library'.
| 6.380426
| 4.688013
| 1.361009
|
attrs = self.create_json(create_missing)
return Location(self._server_config, id=attrs['id']).read()
|
def create(self, create_missing=None)
|
Manually fetch a complete set of attributes for this entity.
For more information, see `Bugzilla #1216236
<https://bugzilla.redhat.com/show_bug.cgi?id=1216236>`_.
| 15.172518
| 15.538402
| 0.976453
|
payload = super(Media, self).create_payload()
if 'path_' in payload:
payload['path'] = payload.pop('path_')
return {u'medium': payload}
|
def create_payload(self)
|
Wrap submitted data within an extra dict and rename ``path_``.
For more information on wrapping submitted data, see `Bugzilla #1151220
<https://bugzilla.redhat.com/show_bug.cgi?id=1151220>`_.
| 6.457785
| 4.961896
| 1.301475
|
return Media(
self._server_config,
id=self.create_json(create_missing)['id'],
).read()
|
def create(self, create_missing=None)
|
Manually fetch a complete set of attributes for this entity.
For more information, see `Bugzilla #1219653
<https://bugzilla.redhat.com/show_bug.cgi?id=1219653>`_.
| 16.124317
| 19.890377
| 0.810659
|
payload = super(Media, self).update_payload(fields)
if 'path_' in payload:
payload['path'] = payload.pop('path_')
return {u'medium': payload}
|
def update_payload(self, fields=None)
|
Wrap submitted data within an extra dict.
| 5.659167
| 5.025246
| 1.126147
|
# read() should not change the state of the object it's called on, but
# super() alters the attributes of any entity passed in. Creating a new
# object and passing it to super() lets this one avoid changing state.
if entity is None:
entity = type(self)(
self._server_config,
operatingsystem=self.operatingsystem, # pylint:disable=E1101
)
if ignore is None:
ignore = set()
ignore.add('operatingsystem')
return super(OperatingSystemParameter, self).read(
entity,
attrs,
ignore,
params
)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Provide a default value for ``entity``.
By default, ``nailgun.entity_mixins.EntityReadMixin.read`` provides a
default value for ``entity`` like so::
entity = type(self)()
However, :class:`OperatingSystemParameter` requires that an
``operatingsystem`` be provided, so this technique will not work. Do
this instead::
entity = type(self)(operatingsystem=self.operatingsystem.id)
| 6.50243
| 6.156016
| 1.056272
|
if which in (
'download_debug_certificate',
'subscriptions',
'subscriptions/delete_manifest',
'subscriptions/manifest_history',
'subscriptions/refresh_manifest',
'subscriptions/upload',
'sync_plans',
):
return '{0}/{1}'.format(
super(Organization, self).path(which='self'),
which
)
return super(Organization, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
download_debug_certificate
/organizations/<id>/download_debug_certificate
subscriptions
/organizations/<id>/subscriptions
subscriptions/upload
/organizations/<id>/subscriptions/upload
subscriptions/delete_manifest
/organizations/<id>/subscriptions/delete_manifest
subscriptions/refresh_manifest
/organizations/<id>/subscriptions/refresh_manifest
sync_plans
/organizations/<id>/sync_plans
Otherwise, call ``super``.
| 6.365432
| 2.753125
| 2.312075
|
return Organization(
self._server_config,
id=self.create_json(create_missing)['id'],
).read()
|
def create(self, create_missing=None)
|
Do extra work to fetch a complete set of attributes for this entity.
For more information, see `Bugzilla #1230873
<https://bugzilla.redhat.com/show_bug.cgi?id=1230873>`_.
| 15.874147
| 18.254915
| 0.869582
|
org_payload = super(Organization, self).update_payload(fields)
payload = {u'organization': org_payload}
if 'redhat_repository_url' in org_payload:
rh_repo_url = org_payload.pop('redhat_repository_url')
payload['redhat_repository_url'] = rh_repo_url
return payload
|
def update_payload(self, fields=None)
|
Wrap submitted data within an extra dict.
| 3.243574
| 3.119601
| 1.03974
|
payload = super(OSDefaultTemplate, self).update_payload(fields)
return {'os_default_template': payload}
|
def update_payload(self, fields=None)
|
Wrap payload in ``os_default_template``
relates to `Redmine #21169`_.
.. _Redmine #21169: http://projects.theforeman.org/issues/21169
| 7.025033
| 4.683788
| 1.499861
|
payload = super(OverrideValue, self).create_payload()
if hasattr(self, 'smart_class_parameter'):
del payload['smart_class_parameter_id']
if hasattr(self, 'smart_variable'):
del payload['smart_variable_id']
return payload
|
def create_payload(self)
|
Remove ``smart_class_parameter_id`` or ``smart_variable_id``
| 4.716619
| 2.378838
| 1.98274
|
# read() should not change the state of the object it's called on, but
# super() alters the attributes of any entity passed in. Creating a new
# object and passing it to super() lets this one avoid changing state.
if entity is None:
if hasattr(self, 'smart_class_parameter'):
entity = type(self)(
self._server_config,
# pylint:disable=no-member
smart_class_parameter=self.smart_class_parameter,
)
elif hasattr(self, 'smart_variable'):
entity = type(self)(
self._server_config,
# pylint:disable=no-member
smart_variable=self.smart_variable,
)
if ignore is None:
ignore = set()
ignore.update(['smart_class_parameter', 'smart_variable'])
return super(OverrideValue, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Provide a default value for ``entity``.
By default, ``nailgun.entity_mixins.EntityReadMixin.read provides a
default value for ``entity`` like so::
entity = type(self)()
However, :class:`OverrideValue` requires that an
``smart_class_parameter`` or ``smart_varaiable`` be provided, so this
technique will not work. Do this instead::
entity = type(self)(
smart_class_parameter=self.smart_class_parameter)
entity = type(self)(smart_variable=self.smart_variable)
| 4.349434
| 3.513267
| 1.238003
|
if entity is None:
entity = type(self)(
self._server_config,
**{self._parent_type: self._parent_id}
)
if ignore is None:
ignore = set()
for field_name in self._path_fields:
ignore.add(field_name)
return super(Parameter, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Ignore path related fields as they're never returned by the server
and are only added to entity to be able to use proper path.
| 3.884094
| 3.302973
| 1.175939
|
if which == 'sync':
return '{0}/{1}'.format(
super(Product, self).path(which='self'),
which,
)
return super(Product, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
sync
/products/<product_id>/sync
``super`` is called otherwise.
| 6.011649
| 4.480042
| 1.341873
|
if attrs is None:
attrs = self.read_json()
if _get_version(self._server_config) < Version('6.1'):
org = _get_org(self._server_config, attrs['organization']['label'])
attrs['organization'] = org.get_values()
if ignore is None:
ignore = set()
ignore.add('sync_plan')
result = super(Product, self).read(entity, attrs, ignore, params)
if 'sync_plan' in attrs:
sync_plan_id = attrs.get('sync_plan_id')
if sync_plan_id is None:
result.sync_plan = None
else:
result.sync_plan = SyncPlan(
server_config=self._server_config,
id=sync_plan_id,
organization=result.organization,
)
return result
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Fetch an attribute missing from the server's response.
Also add sync plan to the responce if needed, as
:meth:`nailgun.entity_mixins.EntityReadMixin.read` can't initialize
sync plan.
For more information, see `Bugzilla #1237283
<https://bugzilla.redhat.com/show_bug.cgi?id=1237283>`_ and
`nailgun#261 <https://github.com/SatelliteQE/nailgun/issues/261>`_.
| 3.155862
| 3.205262
| 0.984588
|
results = self.search_json(fields, query)['results']
results = self.search_normalize(results)
entities = []
for result in results:
sync_plan = result.get('sync_plan')
if sync_plan is not None:
del result['sync_plan']
entity = type(self)(self._server_config, **result)
if sync_plan:
entity.sync_plan = SyncPlan(
server_config=self._server_config,
id=sync_plan,
organization=Organization(
server_config=self._server_config,
id=result.get('organization')
),
)
entities.append(entity)
if filters is not None:
entities = self.search_filter(entities, filters)
return entities
|
def search(self, fields=None, query=None, filters=None)
|
Search for entities with missing attribute
:param fields: A set naming which fields should be used when generating
a search query. If ``None``, all values on the entity are used. If
an empty set, no values are used.
:param query: A dict containing a raw search query. This is melded in
to the generated search query like so: ``{generated:
query}.update({manual: query})``.
:param filters: A dict. Used to filter search results locally.
:return: A list of entities, all of type ``type(self)``.
For more information, see `Bugzilla #1237283
<https://bugzilla.redhat.com/show_bug.cgi?id=1237283>`_ and
`nailgun#261 <https://github.com/SatelliteQE/nailgun/issues/261>`_.
| 3.109607
| 3.130068
| 0.993463
|
flattened_results = []
for key in results.keys():
for item in results[key]:
flattened_results.append(item)
return super(PuppetClass, self).search_normalize(flattened_results)
|
def search_normalize(self, results)
|
Flattens results.
:meth:`nailgun.entity_mixins.EntitySearchMixin.search_normalize`
expects structure like
list(dict_1(name: class_1), dict_2(name: class_2)),
while Puppet Class entity returns dictionary with lists of subclasses
split by main puppet class.
| 3.492381
| 2.544305
| 1.372627
|
if which in ('smart_class_parameters', 'smart_variables'):
return '{0}/{1}'.format(
super(PuppetClass, self).path(which='self'),
which
)
return super(PuppetClass, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
smart_class_parameters
/api/puppetclasses/:puppetclass_id/smart_class_parameters
Otherwise, call ``super``.
| 6.671987
| 3.440286
| 1.93937
|
return Realm(
self._server_config,
id=self.create_json(create_missing)['id'],
).read()
|
def create(self, create_missing=None)
|
Do extra work to fetch a complete set of attributes for this entity.
For more information, see `Bugzilla #1232855
<https://bugzilla.redhat.com/show_bug.cgi?id=1232855>`_.
| 17.088955
| 18.162062
| 0.940915
|
if which in ('cancel',):
return '{0}/{1}'.format(
super(RecurringLogic, self).path(which='self'),
which
)
return super(RecurringLogic, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.RecurringLogic.path``.
The format of the returned path depends on the value of ``which``:
cancel
/foreman_tasks/api/recurring_logics/:id/cancel
Otherwise, call ``super``.
| 7.415153
| 4.011883
| 1.848297
|
return Registry(
self._server_config,
id=self.create_json(create_missing)['id'],
).read()
|
def create(self, create_missing=None)
|
Manually fetch a complete set of attributes for this entity.
For more information, see `Bugzilla #1479391
<https://bugzilla.redhat.com/show_bug.cgi?id=1479391>`_.
| 17.347433
| 18.362986
| 0.944696
|
if attrs is None:
attrs = self.read_json()
if ignore is None:
ignore = set()
ignore.add('password')
return super(Registry, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Do not read the ``password`` argument.
| 3.218741
| 2.863797
| 1.123942
|
if which in (
'errata',
'files',
'packages',
'module_streams',
'puppet_modules',
'remove_content',
'sync',
'import_uploads',
'upload_content'):
return '{0}/{1}'.format(
super(Repository, self).path(which='self'),
which
)
return super(Repository, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
errata
/repositories/<id>/errata
files
/repositories/<id>/files
packages
/repositories/<id>/packages
module_streams
/repositories/<id>/module_streams
puppet_modules
/repositories/<id>/puppet_modules
remove_content
/repositories/<id>/remove_content
sync
/repositories/<id>/sync
upload_content
/repositories/<id>/upload_content
import_uploads
/repositories/<id>/import_uploads
``super`` is called otherwise.
| 7.40257
| 2.568132
| 2.882473
|
if getattr(self, 'content_type', '') == 'docker':
self._fields['docker_upstream_name'].required = True
super(Repository, self).create_missing()
|
def create_missing(self)
|
Conditionally mark ``docker_upstream_name`` as required.
Mark ``docker_upstream_name`` as required if ``content_type`` is
"docker".
| 9.450454
| 4.027848
| 2.346279
|
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
response = client.post(self.path('upload_content'), **kwargs)
json = _handle_response(response, self._server_config, synchronous)
if json['status'] != 'success':
raise APIResponseError(
# pylint:disable=no-member
'Received error when uploading file {0} to repository {1}: {2}'
.format(kwargs.get('files'), self.id, json)
)
return json
|
def upload_content(self, synchronous=True, **kwargs)
|
Upload a file or files to the current repository.
Here is an example of how to upload content::
with open('my_content.rpm') as content:
repo.upload_content(files={'content': content})
This method accepts the same keyword arguments as Requests. As a
result, the following examples can be adapted for use here:
* `POST a Multipart-Encoded File`_
* `POST Multiple Multipart-Encoded Files`_
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
:raises nailgun.entities.APIResponseError: If the response has a status
other than "success".
.. _POST a Multipart-Encoded File:
http://docs.python-requests.org/en/latest/user/quickstart/#post-a-multipart-encoded-file
.. _POST Multiple Multipart-Encoded Files:
http://docs.python-requests.org/en/latest/user/advanced/#post-multiple-multipart-encoded-files
| 5.214803
| 4.799483
| 1.086534
|
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
if uploads:
data = {'uploads': uploads}
elif upload_ids:
data = {'upload_ids': upload_ids}
response = client.put(self.path('import_uploads'), data, **kwargs)
json = _handle_response(response, self._server_config, synchronous)
return json
|
def import_uploads(self, uploads=None, upload_ids=None, synchronous=True,
**kwargs)
|
Import uploads into a repository
It expects either a list of uploads or upload_ids (but not both).
:param uploads: Array of uploads to be imported
:param upload_ids: Array of upload ids to be imported
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 4.004417
| 4.233878
| 0.945804
|
if 'data' not in kwargs:
kwargs['data'] = dict()
kwargs['data']['product_id'] = self.product.id
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
response = client.get(self.path('available_repositories'), **kwargs)
return _handle_response(response, self._server_config)
|
def available_repositories(self, **kwargs)
|
Lists available repositories for the repository set
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 4.970191
| 5.119611
| 0.970814
|
if 'data' not in kwargs:
kwargs['data'] = dict()
kwargs['data']['product_id'] = self.product.id
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
response = client.put(self.path('enable'), **kwargs)
return _handle_response(response, self._server_config, synchronous)
|
def enable(self, synchronous=True, **kwargs)
|
Enables the RedHat Repository
RedHat Repos needs to be enabled first, so that we can sync it.
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 5.081763
| 5.171352
| 0.982676
|
if which in (
'available_repositories',
'enable',
'disable',
):
return '{0}/{1}'.format(
super(RepositorySet, self).path(which='self'),
which
)
return super(RepositorySet, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
available_repositories
/repository_sets/<id>/available_repositories
enable
/repository_sets/<id>/enable
disable
/repository_sets/<id>/disable
``super`` is called otherwise.
| 5.681325
| 3.506889
| 1.620047
|
# read() should not change the state of the object it's called on, but
# super() alters the attributes of any entity passed in. Creating a new
# object and passing it to super() lets this one avoid changing state.
if entity is None:
entity = type(self)(
self._server_config,
product=self.product, # pylint:disable=no-member
)
if ignore is None:
ignore = set()
return super(RepositorySet, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Provide a default value for ``entity``.
By default, ``nailgun.entity_mixins.EntityReadMixin.read`` provides a
default value for ``entity`` like so::
entity = type(self)()
However, :class:`RepositorySet` requires that a ``product`` be
provided, so this technique will not work. Do this instead::
entity = type(self)(product=self.product.id)
| 7.529768
| 7.231661
| 1.041222
|
if which == 'deploy':
return '{0}/{1}'.format(
super(RHCIDeployment, self).path(which='self'),
which
)
return super(RHCIDeployment, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
deploy
/deployments/<id>/deploy
``super`` is called otherwise.
| 6.581847
| 6.659297
| 0.98837
|
if which == 'clone':
return '{0}/{1}'.format(
super(Role, self).path(which='self'),
which
)
return super(Role, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
clone
/api/roles/:role_id/clone
Otherwise, call ``super``.
| 5.734941
| 3.930031
| 1.459261
|
if which in ('refresh',):
return '{0}/{1}'.format(
super(SmartProxy, self).path(which='self'),
which
)
return super(SmartProxy, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
refresh
/api/smart_proxies/:id/refresh
Otherwise, call ``super``.
| 6.087478
| 4.156931
| 1.464416
|
kwargs = kwargs.copy()
kwargs.update(self._server_config.get_client_kwargs())
# Check if environment_id was sent and substitute it to the path
# but do not pass it to requests
if 'environment' in kwargs:
if isinstance(kwargs['environment'], Environment):
environment_id = kwargs.pop('environment').id
else:
environment_id = kwargs.pop('environment')
path = '{0}/environments/{1}/import_puppetclasses'.format(
self.path(), environment_id)
else:
path = '{0}/import_puppetclasses'.format(self.path())
return _handle_response(
client.post(path, **kwargs), self._server_config, synchronous)
|
def import_puppetclasses(self, synchronous=True, **kwargs)
|
Import puppet classes from puppet Capsule.
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 3.650635
| 3.843216
| 0.949891
|
# read() should not change the state of the object it's called on, but
# super() alters the attributes of any entity passed in. Creating a new
# object and passing it to super() lets this one avoid changing state.
if entity is None:
entity = type(self)(
self._server_config,
user=self.user, # pylint:disable=no-member
)
if ignore is None:
ignore = set()
ignore.add('user')
return super(SSHKey, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Provide a default value for ``entity``.
By default, ``nailgun.entity_mixins.EntityReadMixin.read`` provides a
default value for ``entity`` like so::
entity = type(self)()
However, :class:`SSHKey` requires that an ``user`` be
provided, so this technique will not work. Do this instead::
entity = type(self)(user=self.user.id)
| 6.414429
| 6.672499
| 0.961323
|
for sshkey in results:
sshkey[u'user_id'] = self.user.id # pylint:disable=no-member
return super(SSHKey, self).search_normalize(results)
|
def search_normalize(self, results)
|
Append user id to search results to be able to initialize found
:class:`User` successfully
| 5.565806
| 4.806537
| 1.157966
|
payload = super(Subnet, self).create_payload()
if 'from_' in payload:
payload['from'] = payload.pop('from_')
return {u'subnet': payload}
|
def create_payload(self)
|
Wrap submitted data within an extra dict.
For more information, see `Bugzilla #1151220
<https://bugzilla.redhat.com/show_bug.cgi?id=1151220>`_.
In addition, rename the ``from_`` field to ``from``.
| 5.147008
| 4.006837
| 1.284556
|
if attrs is None:
attrs = self.read_json()
attrs['from_'] = attrs.pop('from')
if ignore is None:
ignore = set()
if attrs is not None and 'parameters' in attrs:
attrs['subnet_parameters_attributes'] = attrs.pop('parameters')
else:
ignore.add('subnet_parameters_attributes')
ignore.add('discovery')
ignore.add('remote_execution_proxy')
return super(Subnet, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Fetch as many attributes as possible for this entity.
Do not read the ``discovery`` attribute. For more information, see
`Bugzilla #1217146
<https://bugzilla.redhat.com/show_bug.cgi?id=1217146>`_.
In addition, rename the ``from_`` field to ``from``.
| 4.303441
| 3.420065
| 1.258292
|
payload = super(Subnet, self).update_payload(fields)
if 'from_' in payload:
payload['from'] = payload.pop('from_')
return {u'subnet': payload}
|
def update_payload(self, fields=None)
|
Wrap submitted data within an extra dict.
| 4.556025
| 4.223598
| 1.078707
|
if which in (
'delete_manifest',
'manifest_history',
'refresh_manifest',
'upload'):
_check_for_value('organization', self.get_values())
# pylint:disable=no-member
return self.organization.path('subscriptions/{0}'.format(which))
return super(Subscription, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
delete_manifest
/katello/api/v2/organizations/:organization_id/subscriptions/delete_manifest
manifest_history
/katello/api/v2/organizations/:organization_id/subscriptions/manifest_history
refresh_manifest
/katello/api/v2/organizations/:organization_id/subscriptions/refresh_manifest
upload
/katello/api/v2/organizations/:organization_id/subscriptions/upload
| 8.641638
| 5.157073
| 1.675686
|
return Subscription(
self._server_config,
organization=payload['organization_id'],
).path(which)
|
def _org_path(self, which, payload)
|
A helper method for generating paths with organization IDs in them.
:param which: A path such as "manifest_history" that has an
organization ID in it.
:param payload: A dict with an "organization_id" key in it.
:returns: A string. The requested path.
| 16.495596
| 19.216799
| 0.858395
|
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
response = client.get(
self._org_path('manifest_history', kwargs['data']),
**kwargs
)
return _handle_response(response, self._server_config, synchronous)
|
def manifest_history(self, synchronous=True, **kwargs)
|
Obtain manifest history for subscriptions.
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 6.747229
| 7.092048
| 0.951379
|
if ignore is None:
ignore = set()
ignore.add('organization')
return super(Subscription, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Ignore ``organization`` field as it's never returned by the server
and is only added to entity to be able to use organization path
dependent helpers.
| 3.599579
| 2.758832
| 1.304747
|
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
response = client.put(
self._org_path('refresh_manifest', kwargs['data']),
**kwargs
)
return _handle_response(
response,
self._server_config,
synchronous,
timeout=1500,
)
|
def refresh_manifest(self, synchronous=True, **kwargs)
|
Refresh previously imported manifest for Red Hat provider.
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 6.832124
| 7.127978
| 0.958494
|
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
response = client.post(
self._org_path('upload', kwargs['data']),
**kwargs
)
# Setting custom timeout as manifest upload can take enormously huge
# amount of time. See BZ#1339696 for more details
return _handle_response(
response,
self._server_config,
synchronous,
timeout=1500,
)
|
def upload(self, synchronous=True, **kwargs)
|
Upload a subscription manifest.
Here is an example of how to use this method::
with open('my_manifest.zip') as manifest:
sub.upload({'organization_id': org.id}, manifest)
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 8.956636
| 9.681503
| 0.925129
|
# read() should not change the state of the object it's called on, but
# super() alters the attributes of any entity passed in. Creating a new
# object and passing it to super() lets this one avoid changing state.
if entity is None:
entity = type(self)(
self._server_config,
organization=self.organization, # pylint:disable=no-member
)
if ignore is None:
ignore = set()
ignore.add('organization')
return super(SyncPlan, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Provide a default value for ``entity``.
By default, ``nailgun.entity_mixins.EntityReadMixin.read`` provides a
default value for ``entity`` like so::
entity = type(self)()
However, :class:`SyncPlan` requires that an ``organization`` be
provided, so this technique will not work. Do this instead::
entity = type(self)(organization=self.organization.id)
| 6.654758
| 6.656343
| 0.999762
|
data = super(SyncPlan, self).create_payload()
if isinstance(data.get('sync_date'), datetime):
data['sync_date'] = data['sync_date'].strftime('%Y-%m-%d %H:%M:%S')
return data
|
def create_payload(self)
|
Convert ``sync_date`` to a string.
The ``sync_date`` instance attribute on the current object is not
affected. However, the ``'sync_date'`` key in the dict returned by
``create_payload`` is a string.
| 3.157405
| 2.393468
| 1.319176
|
if which in ('add_products', 'remove_products'):
return '{0}/{1}'.format(
super(SyncPlan, self).path(which='self'),
which
)
return super(SyncPlan, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
add_products
/katello/api/v2/organizations/:organization_id/sync_plans/:sync_plan_id/add_products
remove_products
/katello/api/v2/organizations/:organization_id/sync_plans/:sync_plan_id/remove_products
| 6.103478
| 3.50092
| 1.743392
|
data = super(SyncPlan, self).update_payload(fields)
if isinstance(data.get('sync_date'), datetime):
data['sync_date'] = data['sync_date'].strftime('%Y-%m-%d %H:%M:%S')
return data
|
def update_payload(self, fields=None)
|
Convert ``sync_date`` to a string if datetime object provided.
| 2.873914
| 2.034838
| 1.412355
|
if which == 'subscriptions':
return '{0}/{1}/{2}'.format(
super(System, self).path('base'),
self.uuid, # pylint:disable=no-member
which,
)
if hasattr(self, 'uuid') and (which is None or which == 'self'):
return '{0}/{1}'.format(
super(System, self).path('base'),
self.uuid # pylint:disable=no-member
)
return super(System, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
This method contains a workaround for `Bugzilla #1202917`_.
Most entities are uniquely identified by an ID. ``System`` is a bit
different: it has both an ID and a UUID, and the UUID is used to
uniquely identify a ``System``.
Return a path in the format ``katello/api/v2/systems/<uuid>`` if a UUID
is available and:
* ``which is None``, or
* ``which == 'this'``.
.. _Bugzilla #1202917:
https://bugzilla.redhat.com/show_bug.cgi?id=1202917
Finally, return a path in the form
``katello/api/v2/systems/<uuid>/subscriptions`` if ``'subscriptions'``
is passed in.
| 3.229431
| 2.866353
| 1.126669
|
if attrs is None:
attrs = self.read_json()
attrs['last_checkin'] = attrs.pop('checkin_time')
attrs['host_collections'] = attrs.pop('hostCollections')
attrs['installed_products'] = attrs.pop('installedProducts')
if ignore is None:
ignore = set()
ignore.update(['facts', 'organization', 'type'])
return super(System, self).read(entity, attrs, ignore, params)
|
def read(self, entity=None, attrs=None, ignore=None, params=None)
|
Fetch as many attributes as possible for this entity.
Do not read the ``facts``, ``organization`` or ``type`` attributes.
For more information, see `Bugzilla #1202917
<https://bugzilla.redhat.com/show_bug.cgi?id=1202917>`_.
| 4.505253
| 3.628291
| 1.241701
|
if which:
return '{0}/{1}'.format(
super(Template, self).path(which='base'), which)
return super(Template, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
import
/templates/import
export
/templates/export
| 5.285975
| 5.717311
| 0.924556
|
return UserGroup(
self._server_config,
id=self.create_json(create_missing)['id'],
).read()
|
def create(self, create_missing=None)
|
Do extra work to fetch a complete set of attributes for this entity.
For more information, see `Bugzilla #1301658
<https://bugzilla.redhat.com/show_bug.cgi?id=1301658>`_.
| 14.840643
| 16.317326
| 0.909502
|
if which and which in ('deploy_script'):
return '{0}/{1}'.format(
super(VirtWhoConfig, self).path(which='self'), which)
return super(VirtWhoConfig, self).path(which)
|
def path(self, which=None)
|
Extend ``nailgun.entity_mixins.Entity.path``.
The format of the returned path depends on the value of ``which``:
deploy_script
/foreman_virt_who_configure/api/v2/configs/:id/deploy_script
``super`` is called otherwise.
| 9.470144
| 5.543985
| 1.708183
|
kwargs = kwargs.copy() # shadow the passed-in kwargs
kwargs.update(self._server_config.get_client_kwargs())
response = client.get(self.path('deploy_script'), **kwargs)
return _handle_response(response, self._server_config, synchronous)
|
def deploy_script(self, synchronous=True, **kwargs)
|
Helper for Config's deploy_script method.
:param synchronous: What should happen if the server returns an HTTP
202 (accepted) status code? Wait for the task to complete if
``True``. Immediately return the server's response otherwise.
:param kwargs: Arguments to pass to requests.
:returns: The server's response, with all JSON decoded.
:raises: ``requests.exceptions.HTTPError`` If the server responds with
an HTTP 4XX or 5XX message.
| 6.189687
| 6.224748
| 0.994368
|
logger.info("checking docker can run")
version = docker_client.version()["ApiVersion"]
docker_client.containers.run("hello-world")
logger.debug(f"using docker API version {version}")
|
def ensure_docker_can_run() -> None
|
:raises docker.errors.ContainerError
:raises docker.errors.ImageNotFound
:raises docker.errors.APIError
| 5.956478
| 5.410358
| 1.10094
|
logger.info(f"checking whether docker has network {network_name}")
ipam_pool = docker.types.IPAMPool(subnet=subnet_cidr)
ipam_config = docker.types.IPAMConfig(pool_configs=[ipam_pool])
networks = docker_client.networks.list(names=DOCKER_STARCRAFT_NETWORK)
output = networks[0].short_id if networks else None
if not output:
logger.info("network not found, creating ...")
output = docker_client.networks.create(DOCKER_STARCRAFT_NETWORK, ipam=ipam_config).short_id
logger.debug(f"docker network id: {output}")
|
def ensure_local_net(
network_name: str = DOCKER_STARCRAFT_NETWORK,
subnet_cidr: str = SUBNET_CIDR
) -> None
|
Create docker local net if not found.
:raises docker.errors.APIError
| 2.589627
| 2.60234
| 0.995115
|
logger.info(f"checking if there is local image {local_image}")
docker_images = docker_client.images.list(local_image)
if len(docker_images) and docker_images[0].short_id is not None:
logger.info(f"image {local_image} found locally.")
return
logger.info("image not found locally, creating...")
pkg_docker_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), "local_docker")
base_dir = os.path.join(starcraft_base_dir, "docker")
logger.info(f"copying files from {pkg_docker_dir} to {base_dir}.")
distutils.dir_util.copy_tree(pkg_docker_dir, base_dir)
starcraft_zip_file = f"{base_dir}/starcraft.zip"
if not os.path.exists(starcraft_zip_file):
logger.info(f"downloading starcraft.zip to {starcraft_zip_file}")
download_file(starcraft_binary_link, starcraft_zip_file)
logger.info(f"pulling image {parent_image}, this may take a while...")
pulled_image = docker_client.images.pull(parent_image)
pulled_image.tag(java_image)
logger.info(f"building local image {local_image}, this may take a while...")
docker_client.images.build(path=base_dir, dockerfile="game.dockerfile", tag=local_image)
logger.info(f"successfully built image {local_image}")
|
def ensure_local_image(
local_image: str,
parent_image: str = SC_PARENT_IMAGE,
java_image: str = SC_JAVA_IMAGE,
starcraft_base_dir: str = SCBW_BASE_DIR,
starcraft_binary_link: str = SC_BINARY_LINK,
) -> None
|
Check if `local_image` is present locally. If it is not, pull parent images and build.
This includes pulling starcraft binary.
:raises docker.errors.ImageNotFound
:raises docker.errors.APIError
| 2.210519
| 2.184565
| 1.011881
|
logger.debug("checking docker-machine presence")
# noinspection PyBroadException
try:
out = subprocess \
.check_output(["docker-machine", "version"]) \
.decode("utf-8") \
.replace("docker-machine.exe", "") \
.replace("docker-machine", "") \
.strip()
logger.debug(f"using docker machine version {out}")
return True
except Exception:
logger.debug(f"docker machine not present")
return False
|
def check_dockermachine() -> bool
|
Checks that docker-machine is available on the computer
:raises FileNotFoundError if docker-machine is not present
| 3.101441
| 2.914352
| 1.064196
|
if not check_dockermachine():
return None
# noinspection PyBroadException
try:
out = subprocess.check_output(['docker-machine', 'ip'])
return out.decode("utf-8").strip()
except Exception:
logger.debug(f"docker machine not present")
return None
|
def dockermachine_ip() -> Optional[str]
|
Gets IP address of the default docker machine
Returns None if no docker-machine executable
in the PATH and if there no Docker machine
with name default present
| 3.173737
| 3.476294
| 0.912966
|
callback_lower_drive_letter = lambda pat: pat.group(1).lower()
host_mount = re.sub(r"^([a-zA-Z])\:", callback_lower_drive_letter, host_mount)
host_mount = re.sub(r"^([a-z])", "//\\1", host_mount)
host_mount = re.sub(r"\\", "/", host_mount)
return host_mount
|
def xoscmounts(host_mount)
|
Cross OS compatible mount dirs
| 3.28299
| 3.154138
| 1.040852
|
return [container.short_id for container in
docker_client.containers.list(filters={"name": name_filter})]
|
def running_containers(name_filter: str) -> List[str]
|
:raises docker.exceptions.APIError
| 3.389586
| 2.642121
| 1.282903
|
for container in docker_client.containers.list(filters={"name": name_filter}, all=True):
container.stop()
container.remove()
|
def remove_game_containers(name_filter: str) -> None
|
:raises docker.exceptions.APIError
| 3.381243
| 2.364065
| 1.430267
|
container = docker_client.containers.get(container_id)
return container.wait()["StatusCode"]
|
def container_exit_code(container_id: str) -> Optional[int]
|
:raises docker.errors.NotFound
:raises docker.errors.APIError
| 3.4216
| 3.256428
| 1.050722
|
if not players:
raise GameException("at least one player must be specified")
game_dir = launch_params["game_dir"]
game_name = launch_params["game_name"]
if os.path.exists(f"{game_dir}/{game_name}"):
logger.info(f"removing existing game results of {game_name}")
shutil.rmtree(f"{game_dir}/{game_name}")
for nth_player, player in enumerate(players):
launch_image(player, nth_player=nth_player, num_players=len(players), **launch_params)
logger.debug("checking if game has launched properly...")
time.sleep(1)
start_containers = running_containers(game_name + "_")
if len(start_containers) != len(players):
raise DockerException("some containers exited prematurely, please check logs")
if not launch_params["headless"]:
for index, player in enumerate(players if show_all else players[:1]):
port = launch_params["vnc_base_port"] + index
host = launch_params["vnc_host"]
logger.info(f"launching vnc viewer for {player} on address {host}:{port}")
launch_vnc_viewer(host, port)
logger.info("\n"
"In headful mode, you must specify and start the game manually.\n"
"Select the map, wait for bots to join the game "
"and then start the game.")
logger.info(f"waiting until game {game_name} is finished...")
running_time = time.time()
while True:
containers = running_containers(game_name)
if len(containers) == 0: # game finished
break
if len(containers) >= 2: # update the last time when there were multiple containers
running_time = time.time()
if len(containers) == 1 and time.time() - running_time > MAX_TIME_RUNNING_SINGLE_CONTAINER:
raise ContainerException(
f"One lingering container has been found after single container "
f"timeout ({MAX_TIME_RUNNING_SINGLE_CONTAINER} sec), the game probably crashed.")
logger.debug(f"waiting. {containers}")
wait_callback()
exit_codes = [container_exit_code(container) for container in containers]
# remove containers before throwing exception
logger.debug("removing game containers")
remove_game_containers(game_name)
if any(exit_code == EXIT_CODE_REALTIME_OUTED for exit_code in exit_codes):
raise RealtimeOutedException(f"some of the game containers has realtime outed.")
if any(exit_code == 1 for exit_code in exit_codes):
raise ContainerException(f"some of the game containers has finished with error exit code.")
if read_overwrite:
logger.info("overwriting bot files")
for nth_player, player in enumerate(players):
if isinstance(player, BotPlayer):
logger.debug(f"overwriting files for {player}")
distutils.dir_util.copy_tree(
f"{game_dir}/{game_name}/write_{nth_player}",
player.read_dir
)
|
def launch_game(
players: List[Player],
launch_params: Dict[str, Any],
show_all: bool,
read_overwrite: bool,
wait_callback: Callable
) -> None
|
:raises DockerException, ContainerException, RealtimeOutedException
| 3.639447
| 3.401266
| 1.070027
|
version_regex = re.compile(
'__version__\\s*=\\s*(?P<q>[\'"])(?P<version>\\d+(\\.\\d+)*(-(alpha|beta|rc)(\\.\\d+)?)?)(?P=q)'
)
here = path.abspath(path.dirname(__file__))
init_location = path.join(here, "CHAID/__init__.py")
with open(init_location) as init_file:
for line in init_file:
match = version_regex.search(line)
if not match:
raise Exception(
"Couldn't read version information from '{0}'".format(init_location)
)
return match.group('version')
|
def get_version()
|
Read version from __init__.py
| 2.955821
| 2.915688
| 1.013765
|
if weighted:
m_ij = n_ij / n_ij
nan_mask = np.isnan(m_ij)
m_ij[nan_mask] = 0.000001 # otherwise it breaks the chi-squared test
w_ij = m_ij
n_ij_col_sum = n_ij.sum(axis=1)
n_ij_row_sum = n_ij.sum(axis=0)
alpha, beta, eps = (1, 1, 1)
while eps > 10e-6:
alpha = alpha * np.vstack(n_ij_col_sum / m_ij.sum(axis=1))
beta = n_ij_row_sum / (alpha * w_ij).sum(axis=0)
eps = np.max(np.absolute(w_ij * alpha * beta - m_ij))
m_ij = w_ij * alpha * beta
else:
m_ij = (np.vstack(n_ij.sum(axis=1)) * n_ij.sum(axis=0)) / n_ij.sum().astype(float)
dof = (n_ij.shape[0] - 1) * (n_ij.shape[1] - 1)
chi, p_val = stats.chisquare(n_ij, f_exp=m_ij, ddof=n_ij.size - 1 - dof, axis=None)
return (chi, p_val, dof)
|
def chisquare(n_ij, weighted)
|
Calculates the chisquare for a matrix of ind_v x dep_v
for the unweighted and SPSS weighted case
| 2.666548
| 2.763201
| 0.965021
|
if isinstance(dep, ContinuousColumn):
return self.best_con_split(ind, dep)
else:
return self.best_cat_heuristic_split(ind, dep)
|
def best_split(self, ind, dep)
|
determine which splitting function to apply
| 5.09685
| 4.428976
| 1.150797
|
split = Split(None, None, None, None, 0)
is_normal = stats.normaltest(self.dep_population)[1] > 0.05
sig_test = stats.bartlett if is_normal else stats.levene
response_set = dep.arr
if dep.weights is not None:
response_set = dep.arr * dep.weights
for i, ind_var in enumerate(ind):
ind_var = ind_var.deep_copy()
unique = np.unique(ind_var.arr)
keyed_set = {}
for col in unique:
matched_elements = np.compress(ind_var.arr == col, response_set)
keyed_set[col] = matched_elements
while next(ind_var.possible_groupings(), None) is not None:
choice, highest_p_join, split_score = None, None, None
for comb in ind_var.possible_groupings():
col1_keyed_set = keyed_set[comb[0]]
col2_keyed_set = keyed_set[comb[1]]
dof = len(np.concatenate((col1_keyed_set, col2_keyed_set))) - 2
score, p_split = sig_test(col1_keyed_set, col2_keyed_set)
if choice is None or p_split > highest_p_join or (p_split == highest_p_join and score > split_score):
choice, highest_p_join, split_score = comb, p_split, score
sufficient_split = highest_p_join < self.alpha_merge and all(
len(node_v) >= self.min_child_node_size for node_v in keyed_set.values()
)
invalid_reason = None
sufficient_split = highest_p_join < self.alpha_merge
if not sufficient_split: invalid_reason = InvalidSplitReason.ALPHA_MERGE
sufficient_split = sufficient_split and all(
len(node_v) >= self.min_child_node_size for node_v in keyed_set.values()
)
if not sufficient_split: invalid_reason = InvalidSplitReason.MIN_CHILD_NODE_SIZE
if sufficient_split and len(keyed_set.values()) > 1:
dof = len(np.concatenate(list(keyed_set.values()))) - 2
score, p_split = sig_test(*keyed_set.values())
temp_split = Split(i, ind_var.groups(), score, p_split, dof, split_name=ind_var.name)
better_split = not split.valid() or p_split < split.p or (p_split == split.p and score > split.score)
if better_split:
split, temp_split = temp_split, split
score_threshold = self.split_threshold * split.score
if temp_split.valid() and temp_split.score >= score_threshold:
for sur in temp_split.surrogates:
if sur.column_id != i and sur.score >= score_threshold:
split.surrogates.append(sur)
temp_split.surrogates = []
split.surrogates.append(temp_split)
break
else:
split.invalid_reason = invalid_reason
ind_var.group(choice[0], choice[1])
keyed_set[choice[0]] = np.concatenate((keyed_set[choice[1]], keyed_set[choice[0]]))
del keyed_set[choice[1]]
if split.valid():
split.sub_split_values(ind[split.column_id].metadata)
return split
|
def best_con_split(self, ind, dep)
|
determine best continuous variable split
| 3.2091
| 3.165049
| 1.013918
|
vectorised_array = []
variable_types = variable_types or ['nominal'] * ndarr.shape[1]
for ind, col_type in enumerate(variable_types):
title = None
if split_titles is not None: title = split_titles[ind]
if col_type == 'ordinal':
col = OrdinalColumn(ndarr[:, ind], name=title)
elif col_type == 'nominal':
col = NominalColumn(ndarr[:, ind], name=title)
else:
raise NotImplementedError('Unknown independent variable type ' + col_type)
vectorised_array.append(col)
if dep_variable_type == 'categorical':
observed = NominalColumn(arr, weights=weights)
elif dep_variable_type == 'continuous':
observed = ContinuousColumn(arr, weights=weights)
else:
raise NotImplementedError('Unknown dependent variable type ' + dep_variable_type)
config = { 'alpha_merge': alpha_merge, 'max_depth': max_depth, 'min_parent_node_size': min_parent_node_size,
'min_child_node_size': min_child_node_size, 'split_threshold': split_threshold }
return Tree(vectorised_array, observed, config)
|
def from_numpy(ndarr, arr, alpha_merge=0.05, max_depth=2, min_parent_node_size=30,
min_child_node_size=30, split_titles=None, split_threshold=0, weights=None,
variable_types=None, dep_variable_type='categorical')
|
Create a CHAID object from numpy
Parameters
----------
ndarr : numpy.ndarray
non-aggregated 2-dimensional array containing
independent variables on the veritcal axis and (usually)
respondent level data on the horizontal axis
arr : numpy.ndarray
1-dimensional array of the dependent variable associated with
ndarr
alpha_merge : float
the threshold value in which to create a split (default 0.05)
max_depth : float
the threshold value for the maximum number of levels after the root
node in the tree (default 2)
min_parent_node_size : float
the threshold value of the number of respondents that the node must
contain (default 30)
split_titles : array-like
array of names for the independent variables in the data
variable_types : array-like or dict
array of variable types, or dict of column names to variable types.
Supported variable types are the strings 'nominal' or 'ordinal' in
lower case
| 2.139397
| 2.360675
| 0.906265
|
self._tree_store = []
self.node(np.arange(0, self.data_size, dtype=np.int), self.vectorised_array, self.observed)
|
def build_tree(self)
|
Build chaid tree
| 14.435658
| 12.681715
| 1.138305
|
ind_df = df[list(i_variables.keys())]
ind_values = ind_df.values
dep_values = df[d_variable].values
weights = df[weight] if weight is not None else None
return Tree.from_numpy(ind_values, dep_values, alpha_merge, max_depth, min_parent_node_size,
min_child_node_size, list(ind_df.columns.values), split_threshold, weights,
list(i_variables.values()), dep_variable_type)
|
def from_pandas_df(df, i_variables, d_variable, alpha_merge=0.05, max_depth=2,
min_parent_node_size=30, min_child_node_size=30, split_threshold=0,
weight=None, dep_variable_type='categorical')
|
Helper method to pre-process a pandas data frame in order to run CHAID
analysis
Parameters
----------
df : pandas.DataFrame
the dataframe with the dependent and independent variables in which
to slice from
i_variables : dict
dict of instance variable names with their variable types. Supported
variable types are the strings 'nominal' or 'ordinal' in lower case
d_variable : string
the name of the dependent variable in the dataframe
alpha_merge : float
the threshold value in which to create a split (default 0.05)
max_depth : float
the threshold value for the maximum number of levels after the root
node in the tree (default 2)
split_threshold : float
the variation in chi-score such that surrogate splits are created
(default 0)
min_parent_node_size : float
the threshold value of the number of respondents that the node must
contain (default 30)
min_child_node_size : float
the threshold value of the number of respondents that each child node must
contain (default 30)
weight : array-like
the respondent weights. If passed, weighted chi-square calculation is run
dep_variable_type : str
the type of dependent variable. Supported variable types are 'categorical' or
'continuous'
| 2.513508
| 2.92552
| 0.859166
|
depth += 1
if self.max_depth < depth:
terminal_node = Node(choices=parent_decisions, node_id=self.node_count,
parent=parent, indices=rows, dep_v=dep)
self._tree_store.append(terminal_node)
self.node_count += 1
terminal_node.split.invalid_reason = InvalidSplitReason.MAX_DEPTH
return self._tree_store
split = self._stats.best_split(ind, dep)
node = Node(choices=parent_decisions, node_id=self.node_count, indices=rows, dep_v=dep,
parent=parent, split=split)
self._tree_store.append(node)
parent = self.node_count
self.node_count += 1
if not split.valid():
return self._tree_store
for index, choices in enumerate(split.splits):
correct_rows = np.in1d(ind[split.column_id].arr, choices)
dep_slice = dep[correct_rows]
ind_slice = [vect[correct_rows] for vect in ind]
row_slice = rows[correct_rows]
if self.min_parent_node_size < len(dep_slice.arr):
self.node(row_slice, ind_slice, dep_slice, depth=depth, parent=parent,
parent_decisions=split.split_map[index])
else:
terminal_node = Node(choices=split.split_map[index], node_id=self.node_count,
parent=parent, indices=row_slice, dep_v=dep_slice)
terminal_node.split.invalid_reason = InvalidSplitReason.MIN_PARENT_NODE_SIZE
self._tree_store.append(terminal_node)
self.node_count += 1
return self._tree_store
|
def node(self, rows, ind, dep, depth=0, parent=None, parent_decisions=None)
|
internal method to create a node in the tree
| 2.747458
| 2.730523
| 1.006202
|
tree = TreeLibTree()
for node in self:
tree.create_node(node, node.node_id, parent=node.parent)
return tree
|
def to_tree(self)
|
returns a TreeLib tree
| 5.779142
| 3.932735
| 1.469497
|
pred = np.zeros(self.data_size)
for node in self:
if node.is_terminal:
pred[node.indices] = node.node_id
return pred
|
def node_predictions(self)
|
Determines which rows fall into which node
| 4.695901
| 4.279437
| 1.097318
|
if isinstance(self.observed, ContinuousColumn):
return ValueError("Cannot make model predictions on a continuous scale")
pred = np.zeros(self.data_size).astype('object')
for node in self:
if node.is_terminal:
pred[node.indices] = max(node.members, key=node.members.get)
return pred
|
def model_predictions(self)
|
Determines the highest frequency of
categorical dependent variable in the
terminal node where that row fell
| 7.962221
| 6.999008
| 1.137621
|
sub_observed = np.array([self.observed.metadata[i] for i in self.observed.arr])
return float((self.model_predictions() == sub_observed).sum()) / self.data_size
|
def accuracy(self)
|
Calculates the accuracy of the tree by comparing
the model predictions to the dataset
(TP + TN) / (TP + TN + FP + FN) == (T / (T + F))
| 10.092752
| 9.10848
| 1.108061
|
if len(collection) == 1:
yield [ collection ]
return
first = collection[0]
for smaller in self.bell_set(collection[1:]):
for n, subset in enumerate(smaller):
if not ordinal or (ordinal and is_sorted(smaller[:n] + [[ first ] + subset] + smaller[n+1:], self._nan)):
yield smaller[:n] + [[ first ] + subset] + smaller[n+1:]
if not ordinal or (ordinal and is_sorted([ [ first ] ] + smaller, self._nan)):
yield [ [ first ] ] + smaller
|
def bell_set(self, collection, ordinal=False)
|
Calculates the Bell set
| 3.362149
| 3.381064
| 0.994405
|
return NominalColumn(self.arr, metadata=self.metadata, name=self.name,
missing_id=self._missing_id, substitute=False, weights=self.weights)
|
def deep_copy(self)
|
Returns a deep copy.
| 13.737251
| 12.385728
| 1.109119
|
try:
unique = np.unique(vect)
except:
unique = set(vect)
unique = [
x for x in unique if not isinstance(x, float) or not isnan(x)
]
arr = np.copy(vect)
for new_id, value in enumerate(unique):
np.place(arr, arr==value, new_id)
self.metadata[new_id] = value
arr = arr.astype(np.float)
np.place(arr, np.isnan(arr), -1)
self.arr = arr
if -1 in arr:
self.metadata[-1] = self._missing_id
|
def substitute_values(self, vect)
|
Internal method to substitute integers into the vector, and construct
metadata to convert back to the original vector.
np.nan is always given -1, all other objects are given integers in
order of apperence.
Parameters
----------
vect : np.array
the vector in which to substitute values in
| 3.80951
| 3.487476
| 1.09234
|
return OrdinalColumn(self.arr, metadata=self.metadata, name=self.name,
missing_id=self._missing_id, substitute=True,
groupings=self._groupings, weights=self.weights)
|
def deep_copy(self)
|
Returns a deep copy.
| 10.663899
| 9.850515
| 1.082573
|
return ContinuousColumn(self.arr, metadata=self.metadata, missing_id=self._missing_id, weights=self.weights)
|
def deep_copy(self)
|
Returns a deep copy.
| 15.837879
| 14.413843
| 1.098796
|
for i, arr in enumerate(self.splits):
self.split_map[i] = [sub.get(x, x) for x in arr]
for split in self.surrogates:
split.sub_split_values(sub)
|
def sub_split_values(self, sub)
|
Substitutes the splits with other values into the split_map
| 4.729121
| 3.370438
| 1.403117
|
if self.column_id is not None and len(sub) > self.column_id:
self.split_name = sub[self.column_id]
for split in self.surrogates:
split.name_columns(sub)
|
def name_columns(self, sub)
|
Substitutes the split column index with a human readable string
| 4.564116
| 3.824975
| 1.193241
|
f = [0] * (1 << len(x))
for i in range(len(x)):
for S in range(1 << i):
f[S | (1 << i)] = f[S] + x[i]
for A in range(1 << len(x)):
for B in range(1 << len(x)):
if A & B == 0 and f[A] == f[B] and 3 * f[A] == f[-1]:
return (A, B, ((1 << len(x)) - 1) ^ A ^ B)
return None
|
def three_partition(x)
|
partition a set of integers in 3 parts of same total value
:param x: table of non negative values
:returns: triplet of the integers encoding the sets, or None otherwise
:complexity: :math:`O(2^{2n})`
| 2.64892
| 2.74034
| 0.966639
|
n = len(A)
x = [randint(0, 1000000) for j in range(n)]
return mult(A, mult(B, x)) == mult(C, x)
|
def freivalds(A, B, C)
|
Tests matrix product AB=C by Freivalds
:param A: n by n numerical matrix
:param B: same
:param C: same
:returns: False with high probability if AB != C
:complexity:
:math:`O(n^2)`
| 4.029083
| 5.284429
| 0.762444
|
n = len(p)
opt = [[0] * (cmax + 1) for _ in range(n + 1)]
sel = [[False] * (cmax + 1) for _ in range(n + 1)]
# --- basic case
for cap in range(p[0], cmax + 1):
opt[0][cap] = v[0]
sel[0][cap] = True
# --- induction case
for i in range(1, n):
for cap in range(cmax + 1):
if cap >= p[i] and opt[i-1][cap - p[i]] + v[i] > opt[i-1][cap]:
opt[i][cap] = opt[i-1][cap - p[i]] + v[i]
sel[i][cap] = True
else:
opt[i][cap] = opt[i-1][cap]
sel[i][cap] = False
# --- reading solution
cap = cmax
solution = []
for i in range(n-1, -1, -1):
if sel[i][cap]:
solution.append(i)
cap -= p[i]
return (opt[n - 1][cmax], solution)
|
def knapsack(p, v, cmax)
|
Knapsack problem: select maximum value set of items if total size not more than capacity
:param p: table with size of items
:param v: table with value of items
:param cmax: capacity of bag
:requires: number of items non-zero
:returns: value optimal solution, list of item indexes in solution
:complexity: O(n * cmax), for n = number of items
| 1.864559
| 2.005346
| 0.929794
|
n = len(p)
# Plus grande valeur obtenable avec objets ≤ i et capacité c
pgv = [[0] * (cmax + 1) for _ in range(n)]
for c in range(cmax + 1): # Initialisation
pgv[0][c] = v[0] if c >= p[0] else 0
pred = {} # Prédécesseurs pour mémoriser les choix faits
for i in range(1, n):
for c in range(cmax + 1):
pgv[i][c] = pgv[i - 1][c] # Si on ne prend pas l'objet i
pred[(i, c)] = (i - 1, c)
# Est-ce que prendre l'objet i est préférable ?
if c >= p[i] and pgv[i - 1][c - p[i]] + v[i] > pgv[i][c]:
pgv[i][c] = pgv[i - 1][c - p[i]] + v[i]
pred[(i, c)] = (i - 1, c - p[i]) # On marque le prédécesseur
# On pourrait s'arrêter là, mais si on veut un sous-ensemble d'objets
# optimal, il faut remonter les marquages
cursor = (n - 1, cmax)
chosen = []
while cursor in pred:
# Si la case prédécesseur a une capacité inférieure
if pred[cursor][1] < cursor[1]:
# C'est qu'on a ramassé l'objet sur le chemin
chosen.append(cursor[0])
cursor = pred[cursor]
if cursor[1] > 0: # A-t-on pris le premier objet ?
# (La première ligne n'a pas de prédécesseur.)
chosen.append(cursor[0])
return pgv[n - 1][cmax], chosen
|
def knapsack2(p, v, cmax)
|
Knapsack problem: select maximum value set of items if total size not more than capacity.
alternative implementation with same behavior.
:param p: table with size of items
:param v: table with value of items
:param cmax: capacity of bag
:requires: number of items non-zero
:returns: value optimal solution, list of item indexes in solution
:complexity: O(n * cmax), for n = number of items
| 3.411138
| 3.63468
| 0.938497
|
x = sorted(x) # make copies
y = sorted(y) # to save arguments
return sum(x[i] * y[-i - 1] for i in range(len(x)))
|
def min_scalar_prod(x, y)
|
Permute vector to minimize scalar product
:param x:
:param y: x, y are vectors of same size
:returns: min sum x[i] * y[sigma[i]] over all permutations sigma
:complexity: O(n log n)
| 5.214518
| 5.633354
| 0.925651
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.