Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Next line prediction: <|code_start|> "properties": {
"primary": {"type": "boolean"},
"classification": {"type": "string", "minLength": 1},
"name": {"type": "string", "minLength": 1},
"entity_type": {
"enum": ["organization", "person", ""],
"type": "string",
},
"person_id": {"type": ["string", "null"]},
"organization_id": {"type": ["string", "null"]},
},
"type": "object"
},
"type": "array",
},
"related_bills": {
"items": {
"properties": {
"identifier": {"type": "string", "minLength": 1},
"legislative_session": {"type": "string", "minLength": 1},
"relation_type": {"enum": common.BILL_RELATION_TYPES, "type": "string"},
},
"type": "object"
},
"type": "array",
},
"versions": versions_or_documents,
"documents": versions_or_documents,
<|code_end|>
. Use current file imports:
(from .common import sources, extras, fuzzy_date_blank, fuzzy_datetime
from opencivicdata import common)
and context including class names, function names, or small code snippets from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "sources": sources, |
Predict the next line after this snippet: <|code_start|> "primary": {"type": "boolean"},
"classification": {"type": "string", "minLength": 1},
"name": {"type": "string", "minLength": 1},
"entity_type": {
"enum": ["organization", "person", ""],
"type": "string",
},
"person_id": {"type": ["string", "null"]},
"organization_id": {"type": ["string", "null"]},
},
"type": "object"
},
"type": "array",
},
"related_bills": {
"items": {
"properties": {
"identifier": {"type": "string", "minLength": 1},
"legislative_session": {"type": "string", "minLength": 1},
"relation_type": {"enum": common.BILL_RELATION_TYPES, "type": "string"},
},
"type": "object"
},
"type": "array",
},
"versions": versions_or_documents,
"documents": versions_or_documents,
"sources": sources,
<|code_end|>
using the current file's imports:
from .common import sources, extras, fuzzy_date_blank, fuzzy_datetime
from opencivicdata import common
and any relevant context from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "extras": extras, |
Based on the snippet: <|code_start|>"""
Schema for bill objects.
"""
versions_or_documents = {
"items": {
"properties": {
"note": {"type": "string", "minLength": 1},
<|code_end|>
, predict the immediate next line with the help of imports:
from .common import sources, extras, fuzzy_date_blank, fuzzy_datetime
from opencivicdata import common
and context (classes, functions, sometimes code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "date": fuzzy_date_blank, |
Continue the code snippet: <|code_start|> "date": {"type": "string"},
},
"type": "object"},
"type": "array",
},
"other_titles": {
"items": {
"properties": {
"title": {"type": "string", "minLength": 1},
"note": {"type": "string"},
},
"type": "object"
},
"type": "array",
},
"other_identifiers": {
"items": {
"properties": {
"identifier": {"type": "string", "minLength": 1},
"note": {"type": "string"},
"scheme": {"type": "string"},
},
"type": "object"
},
"type": "array",
},
"actions": {
"items": {
"properties": {
"organization": {"type": ["string", "null"]},
<|code_end|>
. Use current file imports:
from .common import sources, extras, fuzzy_date_blank, fuzzy_datetime
from opencivicdata import common
and context (classes, functions, or code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "date": fuzzy_datetime, |
Continue the code snippet: <|code_start|>
# a copy of the org schema without sources
org_schema_no_sources = copy.deepcopy(org_schema)
org_schema_no_sources['properties'].pop('sources')
class Post(BaseModel, LinkMixin, ContactDetailMixin):
"""
A popolo-style Post
"""
_type = 'post'
<|code_end|>
. Use current file imports:
import copy
from .base import (BaseModel, SourceMixin, LinkMixin, ContactDetailMixin, OtherNameMixin,
IdentifierMixin)
from .schemas.post import schema as post_schema
from .schemas.person import schema as person_schema
from .schemas.membership import schema as membership_schema
from .schemas.organization import schema as org_schema
from ..utils import _make_pseudo_id
from pupa.exceptions import ScrapeValueError
and context (classes, functions, or code) from other files:
# Path: pupa/scrape/base.py
# class BaseModel(object):
# """
# This is the base class for all the Open Civic objects. This contains
# common methods and abstractions for OCD objects.
# """
#
# # to be overridden by children. Something like "person" or "organization".
# # Used in :func:`validate`.
# _type = None
# _schema = None
#
# def __init__(self):
# super(BaseModel, self).__init__()
# self._id = str(uuid.uuid1())
# self._related = []
# self.extras = {}
#
# # validation
#
# def validate(self, schema=None):
# """
# Validate that we have a valid object.
#
# On error, this will raise a `ScrapeValueError`
#
# This also expects that the schemas assume that omitting required
# in the schema asserts the field is optional, not required. This is
# due to upstream schemas being in JSON Schema v3, and not validictory's
# modified syntax.
# ^ TODO: FIXME
# """
# if schema is None:
# schema = self._schema
#
# type_checker = Draft3Validator.TYPE_CHECKER.redefine(
# "datetime", lambda c, d: isinstance(d, (datetime.date, datetime.datetime))
# )
# type_checker = type_checker.redefine(
# "date", lambda c, d: (isinstance(d, datetime.date)
# and not isinstance(d, datetime.datetime))
# )
#
# ValidatorCls = jsonschema.validators.extend(Draft3Validator, type_checker=type_checker)
# validator = ValidatorCls(schema, format_checker=FormatChecker())
#
# errors = [str(error) for error in validator.iter_errors(self.as_dict())]
# if errors:
# raise ScrapeValueError('validation of {} {} failed: {}'.format(
# self.__class__.__name__, self._id, '\n\t'+'\n\t'.join(errors)
# ))
#
# def pre_save(self, jurisdiction_id):
# pass
#
# def as_dict(self):
# d = {}
# for attr in self._schema['properties'].keys():
# if hasattr(self, attr):
# d[attr] = getattr(self, attr)
# d['_id'] = self._id
# return d
#
# # operators
#
# def __setattr__(self, key, val):
# if key[0] != '_' and key not in self._schema['properties'].keys():
# raise ScrapeValueError('property "{}" not in {} schema'.format(key, self._type))
# super(BaseModel, self).__setattr__(key, val)
#
# class SourceMixin(object):
# def __init__(self):
# super(SourceMixin, self).__init__()
# self.sources = []
#
# def add_source(self, url, *, note=''):
# """ Add a source URL from which data was collected """
# new = {'url': url, 'note': note}
# self.sources.append(new)
#
# class LinkMixin(object):
# def __init__(self):
# super(LinkMixin, self).__init__()
# self.links = []
#
# def add_link(self, url, *, note=''):
# self.links.append({"note": note, "url": url})
#
# class ContactDetailMixin(object):
# def __init__(self):
# super(ContactDetailMixin, self).__init__()
# self.contact_details = []
#
# def add_contact_detail(self, *, type, value, note=''):
# self.contact_details.append({"type": type, "value": value, "note": note})
#
# class OtherNameMixin(object):
# def __init__(self):
# super(OtherNameMixin, self).__init__()
# self.other_names = []
#
# def add_name(self, name, *, start_date='', end_date='', note=''):
# other_name = {'name': name}
# if start_date:
# other_name['start_date'] = start_date
# if end_date:
# other_name['end_date'] = end_date
# if note:
# other_name['note'] = note
# self.other_names.append(other_name)
#
# class IdentifierMixin(object):
# def __init__(self):
# super(IdentifierMixin, self).__init__()
# self.identifiers = []
#
# def add_identifier(self, identifier, *, scheme=''):
# self.identifiers.append({"identifier": identifier, "scheme": scheme})
#
# Path: pupa/scrape/schemas/post.py
#
# Path: pupa/scrape/schemas/person.py
#
# Path: pupa/scrape/schemas/membership.py
#
# Path: pupa/scrape/schemas/organization.py
#
# Path: pupa/utils/generic.py
# def _make_pseudo_id(**kwargs):
# """ pseudo ids are just JSON """
# # ensure keys are sorted so that these are deterministic
# return '~' + json.dumps(kwargs, sort_keys=True)
#
# Path: pupa/exceptions.py
# class ScrapeValueError(PupaError, ValueError):
# """ An invalid value was passed to a pupa scrape object. """
. Output only the next line. | _schema = post_schema |
Given the following code snippet before the placeholder: <|code_start|> 'motion_classification': {"items": {"type": "string", "minLength": 1},
"type": "array"},
'start_date': fuzzy_datetime_blank,
'end_date': fuzzy_datetime_blank,
'result': {"type": "string", "enum": common.VOTE_RESULTS},
'organization': {"type": ["string", "null"], "minLength": 1},
'legislative_session': {"type": "string", "minLength": 1},
'bill': {"type": ["string", "null"], "minLength": 1},
'bill_action': {"type": ["string", "null"], "minLength": 1},
'votes': {
"items": {
"type": "object",
"properties": {
"option": {"type": "string", "enum": common.VOTE_OPTIONS},
"voter_name": {"type": "string", "minLength": 1},
"voter_id": {"type": "string", "minLength": 1},
"note": {"type": "string"},
},
},
},
'counts': {
"items": {
"properties": {
"option": {"type": "string", "enum": common.VOTE_OPTIONS},
"value": {"type": "integer", "minimum": 0},
},
"type": "object"
},
},
<|code_end|>
, predict the next line using imports from the current file:
from .common import sources, extras, fuzzy_datetime_blank
from opencivicdata import common
and context including class names, function names, and sometimes code from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | 'sources': sources, |
Based on the snippet: <|code_start|> "type": "array"},
'start_date': fuzzy_datetime_blank,
'end_date': fuzzy_datetime_blank,
'result': {"type": "string", "enum": common.VOTE_RESULTS},
'organization': {"type": ["string", "null"], "minLength": 1},
'legislative_session': {"type": "string", "minLength": 1},
'bill': {"type": ["string", "null"], "minLength": 1},
'bill_action': {"type": ["string", "null"], "minLength": 1},
'votes': {
"items": {
"type": "object",
"properties": {
"option": {"type": "string", "enum": common.VOTE_OPTIONS},
"voter_name": {"type": "string", "minLength": 1},
"voter_id": {"type": "string", "minLength": 1},
"note": {"type": "string"},
},
},
},
'counts': {
"items": {
"properties": {
"option": {"type": "string", "enum": common.VOTE_OPTIONS},
"value": {"type": "integer", "minimum": 0},
},
"type": "object"
},
},
'sources': sources,
<|code_end|>
, predict the immediate next line with the help of imports:
from .common import sources, extras, fuzzy_datetime_blank
from opencivicdata import common
and context (classes, functions, sometimes code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | 'extras': extras, |
Predict the next line after this snippet: <|code_start|>
schema = {
"type": "object",
"properties": {
'identifier': {"type": "string"},
'motion_text': {"type": "string", "minLength": 1},
'motion_classification': {"items": {"type": "string", "minLength": 1},
"type": "array"},
<|code_end|>
using the current file's imports:
from .common import sources, extras, fuzzy_datetime_blank
from opencivicdata import common
and any relevant context from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | 'start_date': fuzzy_datetime_blank, |
Given snippet: <|code_start|>
for vote in queryset:
if vote.yes_count is None:
report['votes_missing_yes_count'] += 1
vote.yes_count = 0
if vote.no_count is None:
report['votes_missing_no_count'] += 1
vote.no_count = 0
if vote.other_count is None:
vote.other_count = 0
if (vote.yes_sum != vote.yes_count or
vote.no_sum != vote.no_count or
vote.other_sum != vote.other_count):
report['votes_with_bad_counts'] += 1
# handle unmatched
queryset = BillSponsorship.objects.filter(bill__legislative_session_id=session,
entity_type='person', person_id=None
).values('name').annotate(num=Count('name'))
report['unmatched_sponsor_people'] = {item['name']: item['num'] for item in queryset}
queryset = BillSponsorship.objects.filter(bill__legislative_session_id=session,
entity_type='organization', person_id=None
).values('name').annotate(num=Count('name'))
report['unmatched_sponsor_organizations'] = {item['name']: item['num'] for item in queryset}
queryset = PersonVote.objects.filter(vote_event__legislative_session_id=session,
voter__isnull=True).values(name=F('voter_name')).annotate(
num=Count('voter_name')
)
report['unmatched_voters'] = {item['name']: item['num'] for item in queryset}
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.db.models import Count, Subquery, OuterRef, Q, F
from opencivicdata.legislative.models import (Bill, VoteEvent, VoteCount, PersonVote,
BillSponsorship)
from ..models import SessionDataQualityReport
and context:
# Path: pupa/models.py
# class SessionDataQualityReport(models.Model):
# legislative_session = models.ForeignKey(LegislativeSession, on_delete=models.CASCADE)
#
# bills_missing_actions = models.PositiveIntegerField()
# bills_missing_sponsors = models.PositiveIntegerField()
# bills_missing_versions = models.PositiveIntegerField()
#
# votes_missing_voters = models.PositiveIntegerField()
# votes_missing_bill = models.PositiveIntegerField()
# votes_missing_yes_count = models.PositiveIntegerField()
# votes_missing_no_count = models.PositiveIntegerField()
# votes_with_bad_counts = models.PositiveIntegerField()
#
# # these fields store lists of names mapped to numbers of occurances
# unmatched_sponsor_people = JSONField()
# unmatched_sponsor_organizations = JSONField()
# unmatched_voters = JSONField()
which might include code, classes, or functions. Output only the next line. | return SessionDataQualityReport(legislative_session_id=session, **report) |
Given the code snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"classification": {
"type": ["string", "null"],
"enum": common.ORGANIZATION_CLASSIFICATIONS,
},
"parent_id": {"type": ["string", "null"],
},
"founding_date": fuzzy_date_blank,
"dissolution_date": fuzzy_date_blank,
"image": {"type": "string", "format": "uri-blank"},
"contact_details": contact_details,
<|code_end|>
, generate the next line using the imports in this file:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
from opencivicdata import common
and context (functions, classes, or occasionally code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "links": links, |
Predict the next line for this snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"classification": {
"type": ["string", "null"],
"enum": common.ORGANIZATION_CLASSIFICATIONS,
},
"parent_id": {"type": ["string", "null"],
},
"founding_date": fuzzy_date_blank,
"dissolution_date": fuzzy_date_blank,
"image": {"type": "string", "format": "uri-blank"},
<|code_end|>
with the help of current file imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
from opencivicdata import common
and context from other files:
# Path: pupa/scrape/schemas/common.py
, which may contain function names, class names, or code. Output only the next line. | "contact_details": contact_details, |
Continue the code snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
<|code_end|>
. Use current file imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
from opencivicdata import common
and context (classes, functions, or code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "identifiers": identifiers, |
Given the following code snippet before the placeholder: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
<|code_end|>
, predict the next line using imports from the current file:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
from opencivicdata import common
and context including class names, function names, and sometimes code from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "other_names": other_names, |
Given snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"classification": {
"type": ["string", "null"],
"enum": common.ORGANIZATION_CLASSIFICATIONS,
},
"parent_id": {"type": ["string", "null"],
},
"founding_date": fuzzy_date_blank,
"dissolution_date": fuzzy_date_blank,
"image": {"type": "string", "format": "uri-blank"},
"contact_details": contact_details,
"links": links,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
from opencivicdata import common
and context:
# Path: pupa/scrape/schemas/common.py
which might include code, classes, or functions. Output only the next line. | "sources": sources, |
Given the code snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"classification": {
"type": ["string", "null"],
"enum": common.ORGANIZATION_CLASSIFICATIONS,
},
"parent_id": {"type": ["string", "null"],
},
"founding_date": fuzzy_date_blank,
"dissolution_date": fuzzy_date_blank,
"image": {"type": "string", "format": "uri-blank"},
"contact_details": contact_details,
"links": links,
"sources": sources,
# added to popolo
"jurisdiction_id": {"type": "string", "minLength": 1},
"division_id": {"type": ["string", "null"], "minLength": 1},
<|code_end|>
, generate the next line using the imports in this file:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
from opencivicdata import common
and context (functions, classes, or occasionally code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "extras": extras, |
Given snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"classification": {
"type": ["string", "null"],
"enum": common.ORGANIZATION_CLASSIFICATIONS,
},
"parent_id": {"type": ["string", "null"],
},
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
from opencivicdata import common
and context:
# Path: pupa/scrape/schemas/common.py
which might include code, classes, or functions. Output only the next line. | "founding_date": fuzzy_date_blank, |
Continue the code snippet: <|code_start|>
schema = {
"type": "object",
"properties": {
"name": {"type": "string", "minLength": 1},
"url": {"type": "string", "minLength": 1},
"classification": {"type": "string", "minLength": 1}, # TODO: enum
"division_id": {"type": "string", "minLength": 1},
"legislative_sessions": {
"type": "array", "items": {"type": "object", "properties": {
"name": {"type": "string", "minLength": 1},
"type": {"type": "string", "enum": ["primary", "special"]},
"start_date": fuzzy_date_blank,
"end_date": fuzzy_date_blank,
}},
},
"feature_flags": {"type": "array", "items": {"type": "string", "minLength": 1}},
<|code_end|>
. Use current file imports:
from .common import extras, fuzzy_date_blank
and context (classes, functions, or code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "extras": extras, |
Using the snippet: <|code_start|>
schema = {
"type": "object",
"properties": {
"name": {"type": "string", "minLength": 1},
"url": {"type": "string", "minLength": 1},
"classification": {"type": "string", "minLength": 1}, # TODO: enum
"division_id": {"type": "string", "minLength": 1},
"legislative_sessions": {
"type": "array", "items": {"type": "object", "properties": {
"name": {"type": "string", "minLength": 1},
"type": {"type": "string", "enum": ["primary", "special"]},
<|code_end|>
, determine the next line of code. You have imports:
from .common import extras, fuzzy_date_blank
and context (class names, function names, or code) available:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "start_date": fuzzy_date_blank, |
Continue the code snippet: <|code_start|>
class Command(BaseCommand):
name = 'party'
help = 'command line tool to manage parties'
def add_args(self):
self.add_argument('action', type=str, help='add|list')
self.add_argument('party_name', type=str, nargs='?')
def handle(self, args, other):
django.setup()
if args.action == 'add':
o, created = Organization.objects.get_or_create(name=args.party_name,
classification='party')
if created:
print('added {}'.format(o))
else:
print('{} already exists'.format(o))
elif args.action == 'list':
for party in Organization.objects.filter(classification='party').order_by('name'):
print(party.name)
else:
<|code_end|>
. Use current file imports:
import django
from .base import BaseCommand
from pupa.exceptions import CommandError
from opencivicdata.core.models import Organization
and context (classes, functions, or code) from other files:
# Path: pupa/cli/commands/base.py
# class BaseCommand(object):
#
# def __init__(self, subparsers):
# self.subparser = subparsers.add_parser(self.name, description=self.help)
# self.add_args()
#
# def add_args(self):
# pass
#
# def add_argument(self, *args, **kwargs):
# self.subparser.add_argument(*args, **kwargs)
#
# def handle(self, args):
# raise NotImplementedError('commands must implement handle(args)')
#
# Path: pupa/exceptions.py
# class CommandError(PupaError):
# """ Errors from within pupa CLI """
. Output only the next line. | raise CommandError('party action must be "add" or "list"') |
Given the following code snippet before the placeholder: <|code_start|>
def test_basics():
# id property and string
j = FakeJurisdiction()
assert j.jurisdiction_id == 'ocd-jurisdiction/test/government'
assert j.name in str(j)
def test_as_dict():
j = FakeJurisdiction()
d = j.as_dict()
assert d['_id'] == j.jurisdiction_id
assert d['name'] == j.name
assert d['url'] == j.url
assert d['legislative_sessions'] == []
assert d['feature_flags'] == []
def test_jurisdiction_unicam_scrape():
class UnicameralJurisdiction(Jurisdiction):
jurisdiction_id = 'unicam'
name = 'Unicameral'
url = 'http://example.com'
def get_organizations(self):
yield Organization('Unicameral Legislature', classification='legislature')
j = UnicameralJurisdiction()
<|code_end|>
, predict the next line using imports from the current file:
from collections import defaultdict
from pupa.scrape import Jurisdiction, Organization, JurisdictionScraper
and context including class names, function names, and sometimes code from other files:
# Path: pupa/scrape/jurisdiction.py
# class Jurisdiction(BaseModel):
# """ Base class for a jurisdiction """
#
# _type = 'jurisdiction'
# _schema = schema
#
# # schema objects
# classification = None
# name = None
# url = None
# legislative_sessions = []
# feature_flags = []
# extras = {}
#
# # non-db properties
# scrapers = {}
# default_scrapers = None
# parties = []
# ignored_scraped_sessions = []
#
# def __init__(self):
# super(BaseModel, self).__init__()
# self._related = []
# self.extras = {}
#
# @property
# def jurisdiction_id(self):
# return '{}/{}'.format(self.division_id.replace('ocd-division', 'ocd-jurisdiction'),
# self.classification)
#
# _id = jurisdiction_id
#
# def as_dict(self):
# return {'_id': self.jurisdiction_id, 'id': self.jurisdiction_id,
# 'name': self.name, 'url': self.url, 'division_id': self.division_id,
# 'classification': self.classification,
# 'legislative_sessions': self.legislative_sessions,
# 'feature_flags': self.feature_flags, 'extras': self.extras, }
#
# def __str__(self):
# return self.name
#
# def get_organizations(self):
# raise NotImplementedError('get_organizations is not implemented') # pragma: no cover
#
# class JurisdictionScraper(Scraper):
# def scrape(self):
# # yield a single Jurisdiction object
# yield self.jurisdiction
#
# # yield all organizations
# for org in self.jurisdiction.get_organizations():
# yield org
#
# if self.jurisdiction.parties:
# warnings.warn('including parties on Jurisdiction is deprecated, '
# 'use "pupa party" command instead')
# for party in self.jurisdiction.parties:
# org = Organization(classification='party', name=party['name'])
# yield org
#
# Path: pupa/scrape/popolo.py
# class Organization(BaseModel, SourceMixin, ContactDetailMixin, LinkMixin, IdentifierMixin,
# OtherNameMixin):
# """
# A single popolo-style Organization
# """
#
# _type = 'organization'
# _schema = org_schema
#
# def __init__(self, name, *, classification='', parent_id=None,
# founding_date='', dissolution_date='', image='',
# chamber=None):
# """
# Constructor for the Organization object.
# """
# super(Organization, self).__init__()
# self.name = name
# self.classification = classification
# self.founding_date = founding_date
# self.dissolution_date = dissolution_date
# self.parent_id = pseudo_organization(parent_id, chamber)
# self.image = image
#
# def __str__(self):
# return self.name
#
# def validate(self):
# schema = None
# # these are implicitly declared & do not require sources
# if self.classification in ('party', 'legislature', 'upper', 'lower', 'executive'):
# schema = org_schema_no_sources
# return super(Organization, self).validate(schema=schema)
#
# def add_post(self, label, role, **kwargs):
# post = Post(label=label, role=role, organization_id=self._id, **kwargs)
# self._related.append(post)
# return post
#
# def add_member(self, name_or_person, role='member', **kwargs):
# if isinstance(name_or_person, Person):
# membership = Membership(person_id=name_or_person._id,
# person_name=name_or_person.name,
# organization_id=self._id,
# role=role, **kwargs)
# else:
# membership = Membership(person_id=_make_pseudo_id(name=name_or_person),
# person_name=name_or_person,
# organization_id=self._id, role=role, **kwargs)
# self._related.append(membership)
# return membership
. Output only the next line. | js = JurisdictionScraper(j, '/tmp/') |
Predict the next line for this snippet: <|code_start|>
class FakeJurisdiction(Jurisdiction):
division_id = 'ocd-division/test'
classification = 'government'
name = 'Test'
url = 'http://example.com'
def get_organizations(self):
<|code_end|>
with the help of current file imports:
from collections import defaultdict
from pupa.scrape import Jurisdiction, Organization, JurisdictionScraper
and context from other files:
# Path: pupa/scrape/jurisdiction.py
# class Jurisdiction(BaseModel):
# """ Base class for a jurisdiction """
#
# _type = 'jurisdiction'
# _schema = schema
#
# # schema objects
# classification = None
# name = None
# url = None
# legislative_sessions = []
# feature_flags = []
# extras = {}
#
# # non-db properties
# scrapers = {}
# default_scrapers = None
# parties = []
# ignored_scraped_sessions = []
#
# def __init__(self):
# super(BaseModel, self).__init__()
# self._related = []
# self.extras = {}
#
# @property
# def jurisdiction_id(self):
# return '{}/{}'.format(self.division_id.replace('ocd-division', 'ocd-jurisdiction'),
# self.classification)
#
# _id = jurisdiction_id
#
# def as_dict(self):
# return {'_id': self.jurisdiction_id, 'id': self.jurisdiction_id,
# 'name': self.name, 'url': self.url, 'division_id': self.division_id,
# 'classification': self.classification,
# 'legislative_sessions': self.legislative_sessions,
# 'feature_flags': self.feature_flags, 'extras': self.extras, }
#
# def __str__(self):
# return self.name
#
# def get_organizations(self):
# raise NotImplementedError('get_organizations is not implemented') # pragma: no cover
#
# class JurisdictionScraper(Scraper):
# def scrape(self):
# # yield a single Jurisdiction object
# yield self.jurisdiction
#
# # yield all organizations
# for org in self.jurisdiction.get_organizations():
# yield org
#
# if self.jurisdiction.parties:
# warnings.warn('including parties on Jurisdiction is deprecated, '
# 'use "pupa party" command instead')
# for party in self.jurisdiction.parties:
# org = Organization(classification='party', name=party['name'])
# yield org
#
# Path: pupa/scrape/popolo.py
# class Organization(BaseModel, SourceMixin, ContactDetailMixin, LinkMixin, IdentifierMixin,
# OtherNameMixin):
# """
# A single popolo-style Organization
# """
#
# _type = 'organization'
# _schema = org_schema
#
# def __init__(self, name, *, classification='', parent_id=None,
# founding_date='', dissolution_date='', image='',
# chamber=None):
# """
# Constructor for the Organization object.
# """
# super(Organization, self).__init__()
# self.name = name
# self.classification = classification
# self.founding_date = founding_date
# self.dissolution_date = dissolution_date
# self.parent_id = pseudo_organization(parent_id, chamber)
# self.image = image
#
# def __str__(self):
# return self.name
#
# def validate(self):
# schema = None
# # these are implicitly declared & do not require sources
# if self.classification in ('party', 'legislature', 'upper', 'lower', 'executive'):
# schema = org_schema_no_sources
# return super(Organization, self).validate(schema=schema)
#
# def add_post(self, label, role, **kwargs):
# post = Post(label=label, role=role, organization_id=self._id, **kwargs)
# self._related.append(post)
# return post
#
# def add_member(self, name_or_person, role='member', **kwargs):
# if isinstance(name_or_person, Person):
# membership = Membership(person_id=name_or_person._id,
# person_name=name_or_person.name,
# organization_id=self._id,
# role=role, **kwargs)
# else:
# membership = Membership(person_id=_make_pseudo_id(name=name_or_person),
# person_name=name_or_person,
# organization_id=self._id, role=role, **kwargs)
# self._related.append(membership)
# return membership
, which may contain function names, class names, or code. Output only the next line. | parent = Organization('Congress', classification='legislature') |
Predict the next line after this snippet: <|code_start|>
def create_jurisdictions():
Division.objects.create(id='ocd-division/country:us', name='USA')
Division.objects.create(id='ocd-division/country:us/state:nc', name='NC')
Jurisdiction.objects.create(id='us', division_id='ocd-division/country:us')
Jurisdiction.objects.create(id='nc', division_id='ocd-division/country:us/state:nc')
@pytest.mark.django_db
def test_full_post():
create_jurisdictions()
org = Organization.objects.create(name="United States Executive Branch",
classification="executive",
jurisdiction_id="us")
<|code_end|>
using the current file's imports:
import pytest
import datetime
from pupa.scrape import Post as ScrapePost
from pupa.importers import PostImporter, OrganizationImporter
from opencivicdata.core.models import Organization, Post, Division, Jurisdiction
and any relevant context from other files:
# Path: pupa/scrape/popolo.py
# class Post(BaseModel, LinkMixin, ContactDetailMixin):
# """
# A popolo-style Post
# """
#
# _type = 'post'
# _schema = post_schema
#
# def __init__(self, *, label, role, organization_id=None, chamber=None,
# division_id=None, start_date='', end_date='',
# maximum_memberships=1):
# super(Post, self).__init__()
# self.label = label
# self.role = role
# self.organization_id = pseudo_organization(organization_id, chamber)
# self.division_id = division_id
# self.start_date = start_date
# self.end_date = end_date
# self.maximum_memberships = maximum_memberships
#
# def __str__(self):
# return self.label
. Output only the next line. | post = ScrapePost(label='executive', role='President', |
Based on the snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"sort_name": {"type": "string"},
"family_name": {"type": "string"},
"given_name": {"type": "string"},
"gender": {"type": "string"},
"birth_date": fuzzy_date_blank,
"death_date": fuzzy_date_blank,
"image": {"format": "uri-blank", "type": "string"},
"summary": {"type": "string"},
"biography": {"type": "string"},
"national_identity": {"type": "string"},
"contact_details": contact_details,
<|code_end|>
, predict the immediate next line with the help of imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
and context (classes, functions, sometimes code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "links": links, |
Continue the code snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"sort_name": {"type": "string"},
"family_name": {"type": "string"},
"given_name": {"type": "string"},
"gender": {"type": "string"},
"birth_date": fuzzy_date_blank,
"death_date": fuzzy_date_blank,
"image": {"format": "uri-blank", "type": "string"},
"summary": {"type": "string"},
"biography": {"type": "string"},
"national_identity": {"type": "string"},
<|code_end|>
. Use current file imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
and context (classes, functions, or code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "contact_details": contact_details, |
Using the snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
<|code_end|>
, determine the next line of code. You have imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
and context (class names, function names, or code) available:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "identifiers": identifiers, |
Given the following code snippet before the placeholder: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
<|code_end|>
, predict the next line using imports from the current file:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
and context including class names, function names, and sometimes code from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "other_names": other_names, |
Given snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"sort_name": {"type": "string"},
"family_name": {"type": "string"},
"given_name": {"type": "string"},
"gender": {"type": "string"},
"birth_date": fuzzy_date_blank,
"death_date": fuzzy_date_blank,
"image": {"format": "uri-blank", "type": "string"},
"summary": {"type": "string"},
"biography": {"type": "string"},
"national_identity": {"type": "string"},
"contact_details": contact_details,
"links": links,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
and context:
# Path: pupa/scrape/schemas/common.py
which might include code, classes, or functions. Output only the next line. | "sources": sources, |
Using the snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"sort_name": {"type": "string"},
"family_name": {"type": "string"},
"given_name": {"type": "string"},
"gender": {"type": "string"},
"birth_date": fuzzy_date_blank,
"death_date": fuzzy_date_blank,
"image": {"format": "uri-blank", "type": "string"},
"summary": {"type": "string"},
"biography": {"type": "string"},
"national_identity": {"type": "string"},
"contact_details": contact_details,
"links": links,
"sources": sources,
<|code_end|>
, determine the next line of code. You have imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
and context (class names, function names, or code) available:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "extras": extras, |
Based on the snippet: <|code_start|>
schema = {
"properties": {
"name": {"type": "string", "minLength": 1},
"other_names": other_names,
"identifiers": identifiers,
"sort_name": {"type": "string"},
"family_name": {"type": "string"},
"given_name": {"type": "string"},
"gender": {"type": "string"},
<|code_end|>
, predict the immediate next line with the help of imports:
from .common import (links, contact_details, identifiers, other_names, sources, extras,
fuzzy_date_blank)
and context (classes, functions, sometimes code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "birth_date": fuzzy_date_blank, |
Here is a snippet: <|code_start|>
schema = {
"properties": {
"label": {"type": "string", "minLength": 1},
"role": {"type": "string"},
"maximum_memberships": {"type": "number"},
"organization_id": {"type": "string", "minLength": 1},
"division_id": {"type": ["null", "string"], "minLength": 1},
"start_date": fuzzy_date_blank,
"end_date": fuzzy_date_blank,
"contact_details": contact_details,
<|code_end|>
. Write the next line using the current file imports:
from .common import links, contact_details, extras, fuzzy_date_blank
and context from other files:
# Path: pupa/scrape/schemas/common.py
, which may include functions, classes, or code. Output only the next line. | "links": links, |
Given the code snippet: <|code_start|>
schema = {
"properties": {
"label": {"type": "string", "minLength": 1},
"role": {"type": "string"},
"maximum_memberships": {"type": "number"},
"organization_id": {"type": "string", "minLength": 1},
"division_id": {"type": ["null", "string"], "minLength": 1},
"start_date": fuzzy_date_blank,
"end_date": fuzzy_date_blank,
<|code_end|>
, generate the next line using the imports in this file:
from .common import links, contact_details, extras, fuzzy_date_blank
and context (functions, classes, or occasionally code) from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "contact_details": contact_details, |
Next line prediction: <|code_start|>
schema = {
"properties": {
"label": {"type": "string", "minLength": 1},
"role": {"type": "string"},
"maximum_memberships": {"type": "number"},
"organization_id": {"type": "string", "minLength": 1},
"division_id": {"type": ["null", "string"], "minLength": 1},
"start_date": fuzzy_date_blank,
"end_date": fuzzy_date_blank,
"contact_details": contact_details,
"links": links,
<|code_end|>
. Use current file imports:
(from .common import links, contact_details, extras, fuzzy_date_blank)
and context including class names, function names, or small code snippets from other files:
# Path: pupa/scrape/schemas/common.py
. Output only the next line. | "extras": extras, |
Predict the next line for this snippet: <|code_start|>
schema = {
"properties": {
"label": {"type": "string", "minLength": 1},
"role": {"type": "string"},
"maximum_memberships": {"type": "number"},
"organization_id": {"type": "string", "minLength": 1},
"division_id": {"type": ["null", "string"], "minLength": 1},
<|code_end|>
with the help of current file imports:
from .common import links, contact_details, extras, fuzzy_date_blank
and context from other files:
# Path: pupa/scrape/schemas/common.py
, which may contain function names, class names, or code. Output only the next line. | "start_date": fuzzy_date_blank, |
Next line prediction: <|code_start|> i.decompose()
foot = soup.find('div', style="font-family:'Helvetica Neue';font-size:14px;")
next_ = soup.find('div', clas="zan-page bs-example")
copy_right = soup.find('div', class_="copyright alert alert-success")
foot.decompose()
next_.decompose()
copy_right.decompose()
as_ = soup.find_all('a')
for i in as_:
i.decompose()
tree = etree.HTML(r.text)
title = tree.xpath('//div[@class="title-article"]/h1/a/text()')[0]
print(title)
codes = soup.find_all('div',
class_='crayon-syntax crayon-theme-solarized-light crayon-font-monaco crayon-os-pc print-yes notranslate')
images = soup.find('div', class_='centent-article').find_all('img')
img_list = []
if images:
for i in images:
new_img = soup.new_tag('img')
new_img.attrs['width'] = '100%'
url = i.get('src')
if str(url).startswith('/wp-content'):
url = 'http://xiaorui.cc' + url
r = self.fetch_page(url)
url_ = self.upload_img(url.split('/')[-1], r.content, 'crawl/')
img_list.append(url_)
new_img.attrs['src'] = url_
i.replace_with(new_img)
else:
<|code_end|>
. Use current file imports:
(from .crawler import BaseCrawler
from lxml import etree
from bs4 import BeautifulSoup
from ..shares import choice_img
import random
import datetime)
and context including class names, function names, or small code snippets from other files:
# Path: app/tasks/crawler.py
# class BaseCrawler(metaclass=ABCMeta):
# def __init__(self):
# self.site = None
# self.timeout = 30
# self.session = requests.Session()
# self.headers = {
# 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/'
# '60.0.3112.113 Safari/537.36'
# }
# self.today = datetime.datetime.today().strftime('%Y-%m-%d')
#
# def fetch_page(self, url, data=None, headers=None, timeout=None):
# try:
# timeout = timeout or self.timeout
# headers = headers or self.headers
# if data is None:
# r = self.session.get(url=url, timeout=timeout, headers=headers)
# else:
# r = self.session.post(url=url, data=data, timeout=timeout, headers=headers)
# except Exception as e:
# print(str(e))
# else:
# return r
#
# def login(self):
# cookies = self._login()
# self.session.cookies = cookies
#
# def _login(self):
# pass
#
# def parser(self):
# pass
#
# def save(self, title, body, style='转载', category='Python 进阶', post_img=choice_img()):
# app = create_app('default')
# with app.app_context():
# post = Post(title=title,
# body=body,
# style=style,
# category=category,
# author_id=1,
# post_img=post_img,
# created=datetime.datetime.now(),
# source=self.site)
# db.session.add(post)
# db.session.commit()
#
# def is_today(self, s):
# return s == datetime.datetime.now().strftime('%Y-%m-%d')
#
# def start(self):
# pass
#
# def upload_img(self, file_name, file, prefix, domian_name='https://static.51qinqing.com'):
# u = UploadToQiniu(file, prefix, mark=True)
# ret, info = u.upload_web(prefix + file_name, file)
# key = ret['key']
# url = domian_name + '/' + key
# return url
#
# @abstractmethod
# def parse(self):
# pass
#
# Path: app/shares.py
# def choice_img():
# return 'https://static.51qinqing.com/postimg/' + random.choice(img_list)
. Output only the next line. | new_img.attrs['src'] = choice_img() |
Predict the next line after this snippet: <|code_start|> if errors:
r['result'].update(ExtJSWrapper.build_errors(errors))
r['result']['success'] = False
else:
r['result']['success'] = True
r['result']['data'] = result
return r
else:
if errors:
errors = ExtJSWrapper.build_errors(errors)
return {
'type': 'exception',
'message': errors['msg'],
'where': 'n/a'
}
else:
return {
'result': result,
'type': db['type'],
'tid': db['tid'],
'action': db['action'],
'method': db['method'],
}
def parse(self, items):
if len(items) == 1:
# check for a batch request
key, value = items.items()[0]
if value == '':
<|code_end|>
using the current file's imports:
from simpleapi.message.common import json
and any relevant context from other files:
# Path: simpleapi/message/common.py
# class SAException(Exception):
# def __init__(self, msg=None):
# def _get_message(self):
# def _set_message(self, message):
# def __repr__(self):
. Output only the next line. | data = json.loads(key) |
Predict the next line after this snippet: <|code_start|> functions = {}
for cls in ('forms', 'direct'):
functions[cls] = []
for fn in function_map.iterkeys():
if len(function_map[fn]['args']['all']) > 0:
fnlen = 1
else:
fnlen = 0
functions[cls].append({
'name': fn,
'len': fnlen,
'formHandler': cls == 'forms',
})
result = {
'actions': {
self.request.route.name: functions['direct'],
u'%s_forms' % self.request.route.name: functions['forms'],
}
}
result['type'] = 'remoting'
result['url'] = u'%s?_wrapper=extjsdirect' % \
self.session.request.path_info
if namespace:
result['namespace'] = namespace
return UnformattedResponse(
content=u'%s.%s_REMOTING_API = %s;' %\
(provider, self.request.route.name.upper(),
<|code_end|>
using the current file's imports:
from simpleapi.message.common import json, SAException
from response import UnformattedResponse
and any relevant context from other files:
# Path: simpleapi/message/common.py
# class SAException(Exception):
# def __init__(self, msg=None):
# def _get_message(self):
# def _set_message(self, message):
# def __repr__(self):
. Output only the next line. | json.dumps(result)), |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
try:
has_django = True
except:
has_django = False
__all__ = ('__features__', 'Feature', 'FeatureException', 'FeatureContentResponse')
<|code_end|>
with the help of current file imports:
import cPickle
import hashlib
from simpleapi.message.common import SAException
from django.core.cache import cache
and context from other files:
# Path: simpleapi/message/common.py
# class SAException(Exception):
# def __init__(self, msg=None):
# super(Exception, self).__init__()
# self._message = msg
#
# def _get_message(self):
# return self._message
#
# def _set_message(self, message):
# self._message = message
#
# message = property(_get_message, _set_message)
#
# def __repr__(self):
# return self.message
, which may contain function names, class names, or code. Output only the next line. | class FeatureException(SAException): pass |
Predict the next line after this snippet: <|code_start|> else:
spins = list( range( self.spin_channels ) )
if not ions:
ions = [ self.number_of_ions ] # nions+1 is the `tot` index
if not orbitals:
orbitals = list( range( self.number_of_projections ) )
if self.calculation[ 'spin_polarised' ]:
band_energies = np.array( [ band.energy for band in self._bands ] ).reshape( self.spin_channels, self.number_of_k_points, self.number_of_bands )[ spins[0] ].T
else:
band_energies = np.array( [ band.energy for band in self._bands ] ).reshape( self.number_of_k_points, self.number_of_bands ).T
orbital_projection = np.sum( self._data[ :, :, :, :, orbitals ], axis = 4 )
ion_projection = np.sum( orbital_projection[ :, :, :, ions ], axis = 3 )
spin_projection = np.sum( ion_projection[ :, :, spins ], axis = 2 )
x_axis = self.x_axis( reciprocal_lattice )
to_return = []
for i in range( self.number_of_bands ):
for k, ( e, p ) in enumerate( zip( band_energies[i], spin_projection.T[i] ) ):
to_return.append( [ x_axis[ k ], e - e_fermi, p * scaling ] )
to_return = np.array( to_return ).reshape( self.number_of_bands, -1, 3 )
return to_return
def effective_mass_calc( self, k_point_indices, band_index, reciprocal_lattice, spin=1, printing=False ):
assert( spin <= self.k_point_blocks )
assert( len( k_point_indices ) > 1 ) # we need at least 2 k-points
band_energies = self._bands[:,1:].reshape( self.k_point_blocks, self.number_of_k_points, self.number_of_bands )
frac_k_point_coords = np.array( [ self._k_points[ k - 1 ].frac_coords for k in k_point_indices ] )
eigenvalues = np.array( [ band_energies[ spin - 1 ][ k - 1 ][ band_index - 1 ] for k in k_point_indices ] )
if printing:
print( '# h k l e' )
[ print( ' '.join( [ str( f ) for f in row ] ) ) for row in np.concatenate( ( frac_k_point_coords, np.array( [ eigenvalues ] ).T ), axis = 1 ) ]
<|code_end|>
using the current file's imports:
import numpy as np # type: ignore
import re
import math
import warnings
import fortranformat as ff # type: ignore
from .units import angstrom_to_bohr, ev_to_hartree
from .band import Band
from copy import deepcopy
from functools import reduce
and any relevant context from other files:
# Path: vasppy/units.py
#
# Path: vasppy/band.py
# class Band():
#
# def __init__( self, index, energy, occupancy, negative_occupancies='warn' ):
# self.index = index
# self.energy = energy
# self.occupancy = handle_occupancy( occupancy, negative_occupancies=negative_occupancies )
#
# def __eq__( self, other ):
# return ( ( self.index == other.index ) &
# ( self.energy == other.energy ) &
# ( self.occupancy == other.occupancy ) )
. Output only the next line. | reciprocal_lattice = reciprocal_lattice * 2 * math.pi * angstrom_to_bohr |
Next line prediction: <|code_start|> Args:
points (list(np.array)): list of Cartesian coordinates for each point.
tolerance (optional:float): the maximum triangle size for these points to be considered colinear. Default is 1e-7.
Returns:
(bool): True if all points fall on a straight line (within the allowed tolerance).
"""
a = points[0]
b = points[1]
for c in points[2:]:
if area_of_a_triangle_in_cartesian_space( a, b, c ) > tolerance:
return False
return True
def two_point_effective_mass( cartesian_k_points, eigenvalues ):
"""
Calculate the effective mass given eigenvalues at two k-points.
Reimplemented from Aron Walsh's original effective mass Fortran code.
Args:
cartesian_k_points (np.array): 2D numpy array containing the k-points in (reciprocal) Cartesian coordinates.
eigenvalues (np.array): numpy array containing the eigenvalues at each k-point.
Returns:
(float): The effective mass
"""
assert( cartesian_k_points.shape[0] == 2 )
assert( eigenvalues.size == 2 )
dk = cartesian_k_points[ 1 ] - cartesian_k_points[ 0 ]
mod_dk = np.sqrt( np.dot( dk, dk ) )
<|code_end|>
. Use current file imports:
(import numpy as np # type: ignore
import re
import math
import warnings
import fortranformat as ff # type: ignore
from .units import angstrom_to_bohr, ev_to_hartree
from .band import Band
from copy import deepcopy
from functools import reduce)
and context including class names, function names, or small code snippets from other files:
# Path: vasppy/units.py
#
# Path: vasppy/band.py
# class Band():
#
# def __init__( self, index, energy, occupancy, negative_occupancies='warn' ):
# self.index = index
# self.energy = energy
# self.occupancy = handle_occupancy( occupancy, negative_occupancies=negative_occupancies )
#
# def __eq__( self, other ):
# return ( ( self.index == other.index ) &
# ( self.energy == other.energy ) &
# ( self.occupancy == other.occupancy ) )
. Output only the next line. | delta_e = ( eigenvalues[ 1 ] - eigenvalues[ 0 ] ) * ev_to_hartree * 2.0 |
Given the code snippet: <|code_start|> new_procar.sanity_check()
return new_procar
def parse_projections( self ):
self.projection_data = projections_parser( self.read_in )
try:
assert( self._number_of_bands * self._number_of_k_points == len( self.projection_data ) )
self._spin_channels = 1 # non-magnetic, non-spin-polarised
self._k_point_blocks = 1
self.calculation[ 'non_spin_polarised' ] = True
except:
if self._number_of_bands * self._number_of_k_points * 4 == len( self.projection_data ):
self._spin_channels = 4 # non-collinear (spin-orbit coupling)
self._k_point_blocks = 1
self.calculation[ 'non_collinear' ] = True
pass
elif self._number_of_bands * self._number_of_k_points * 2 == len( self.projection_data ):
self._spin_channels = 2 # spin-polarised
self._k_point_blocks = 2
self.calculation[ 'spin_polarised' ] = True
pass
else:
raise
self._number_of_projections = int( self.projection_data.shape[1] / ( self._number_of_ions + 1 ) ) - 1
def parse_k_points( self ):
self._k_points = k_point_parser( self.read_in )[:self._number_of_k_points]
def parse_bands( self ):
band_data = re.findall( r"band\s*(\d+)\s*#\s*energy\s*([-.\d]+)\s?\s*#\s"r"*occ.\s*([-.\d]+)", self.read_in )
<|code_end|>
, generate the next line using the imports in this file:
import numpy as np # type: ignore
import re
import math
import warnings
import fortranformat as ff # type: ignore
from .units import angstrom_to_bohr, ev_to_hartree
from .band import Band
from copy import deepcopy
from functools import reduce
and context (functions, classes, or occasionally code) from other files:
# Path: vasppy/units.py
#
# Path: vasppy/band.py
# class Band():
#
# def __init__( self, index, energy, occupancy, negative_occupancies='warn' ):
# self.index = index
# self.energy = energy
# self.occupancy = handle_occupancy( occupancy, negative_occupancies=negative_occupancies )
#
# def __eq__( self, other ):
# return ( ( self.index == other.index ) &
# ( self.energy == other.energy ) &
# ( self.occupancy == other.occupancy ) )
. Output only the next line. | self._bands = np.array( [ Band( float(i), float(e), float(o), negative_occupancies=self.negative_occupancies ) for i, e, o in band_data ] ) |
Given the code snippet: <|code_start|>#! /usr/bin/env python3
def parse_command_line_arguments():
# command line arguments
parser = argparse.ArgumentParser( description='z-projection of a VASP (grid format) file' )
parser.add_argument( 'gridfile', help="filename of the VASP (grid format) file to be processed" )
parser.add_argument( '-p', '--projection', choices=[ 'x', 'y', 'z' ], help="output averaged projection perpendicular to [x,y,z]" )
parser.add_argument( '-o', '--orthorhombic', help='map grid points onto an orthorhombic (non-space filling) grid', action = 'store_true' )
args = parser.parse_args()
return args
def main():
args = parse_command_line_arguments()
<|code_end|>
, generate the next line using the imports in this file:
from vasppy import grid
import argparse
and context (functions, classes, or occasionally code) from other files:
# Path: vasppy/grid.py
# def interpolate( i, j, x ):
# def trilinear_interpolation( cube, r ):
# def __init__( self, dimensions = [ 1, 1, 1 ] ):
# def read_from_filename( self, filename ):
# def write_to_filename( self, filename ):
# def read_dimensions( self ):
# def write_dimensions( self ):
# def read_grid( self ):
# def write_grid( self ):
# def average( self, normal_axis_label ):
# def by_index( self, index ):
# def fractional_coordinate_at_index( self, index ):
# def cartesian_coordinate_at_index( self, index ):
# def cube_slice( self, x0, y0, z0 ):
# def interpolated_value_at_fractional_coordinate( self, coord ):
# def interpolate_to_orthorhombic_grid( self, dimensions ): # warning. This may need a more robust minimim image function in Cell.py for highly non-orthorhombic cells
# class Grid:
. Output only the next line. | vgrid = grid.Grid() |
Continue the code snippet: <|code_start|>
def interpolate( i, j, x ):
return( ( i * ( 1.0 - x ) ) + ( j * x) )
def trilinear_interpolation( cube, r ):
return( interpolate (
interpolate(
interpolate( cube[ 0, 0, 0 ], cube[ 1, 0, 0 ], r[ 0 ] ), # trilinear interpolation => http://en.wikipedia.org/wiki/Trilinear_interpolation
interpolate( cube[ 0, 1, 0 ], cube[ 1, 1, 0 ], r[ 0 ] ),
r[ 1 ] ),
interpolate(
interpolate( cube[ 0, 0, 1 ], cube[ 1, 0, 1 ], r[ 0 ] ),
interpolate( cube[ 0, 1, 1 ], cube[ 1, 1, 1 ], r[ 0 ] ),
r[ 1 ] ),
r[ 2 ] )
)
class Grid:
projections = { 'x' : 0, 'y' : 1, 'z' : 2 }
def __init__( self, dimensions = [ 1, 1, 1 ] ):
self.filename = None
<|code_end|>
. Use current file imports:
import numpy as np # type: ignore
import sys
import math
from vasppy import poscar, cell
and context (classes, functions, or code) from other files:
# Path: vasppy/poscar.py
# def parity( list ):
# def swap_axes( matrix, axes ):
# def __init__( self ):
# def coordinates_by_species( self, species ):
# def range_by_species( self, species ):
# def atom_number_by_species( self, species ):
# def sorted( self, species ):
# def read_from( self, filename ):
# def from_file( cls, filename ):
# def in_bohr( self ):
# def coords_are_fractional( self ):
# def coords_are_cartesian( self ):
# def fractional_coordinates( self ):
# def cartesian_coordinates( self ):
# def select_coordinates( self, coordinate_type='Direct' ):
# def output_coordinates_only( self, coordinate_type='Direct', opts=None ):
# def output( self, coordinate_type='Direct', opts=None ):
# def output_header( self, coordinate_type='Direct', opts=None ):
# def write_to( self, filename, coordinate_type='Direct', opts=None ):
# def output_as_xtl( self ):
# def output_as_cif( self, symprec = None ):
# def output_as_pimaim( self, to_bohr = True ):
# def cell_coordinates( self ):
# def labels( self ):
# def replicate( self, h, k, l, group=False ):
# def cell_lengths( self ):
# def cell_angles( self ):
# def to_configuration( self ):
# def swap_axes( self, axes ):
# def to_pymatgen_structure( self ):
# def stoichiometry( self ):
# class Poscar:
#
# Path: vasppy/cell.py
# def angle( x, y ):
# def rotation_matrix(axis, theta):
# def __init__( self, matrix ):
# def dr( self, r1, r2, cutoff=None ):
# def nearest_image( self, origin, point ):
# def minimum_image( self, r1, r2 ):
# def minimum_image_dr( self, r1, r2, cutoff=None ):
# def lengths( self ):
# def angles( self ):
# def cartesian_to_fractional_coordinates( self, coordinates ):
# def fractional_to_cartesian_coordinates( self, coordinates ):
# def inside_cell( self, r ):
# def volume( self ):
# def unit_vectors( self ):
# def rotate( self, axis, theta ):
# class Cell:
. Output only the next line. | self.poscar = poscar.Poscar() |
Next line prediction: <|code_start|> break
def write_dimensions( self ):
print( "\n" + ' '.join( [ str(i) for i in self.dimensions ] ) )
def read_grid( self ):
grid_data = []
grid_data_lines = math.ceil( ( self.dimensions[0] * self.dimensions[1] * self.dimensions[2] ) / 5 )
with open( self.filename ) as file_in:
for i, line in enumerate( file_in ):
if ( i > self.number_of_header_lines ) and ( i <= self.number_of_header_lines + grid_data_lines ):
grid_data.append( line.strip() )
grid_data = np.array( [ float( s ) for s in ' '.join( grid_data ).split() ] )
self.grid = np.reshape( grid_data, tuple( self.dimensions ), order = 'F' )
def write_grid( self ):
np.savetxt( sys.stdout.buffer, np.swapaxes( self.grid, 0, 2 ).reshape( -1, 5 ), fmt='%.11E' )
def average( self, normal_axis_label ):
axes = [ 0, 1, 2 ]
axes.remove( Grid.projections[ normal_axis_label ] )
return( np.sum( np.sum( self.grid, axis=axes[1] ), axis=axes[0] ) / ( self.dimensions[0] * self.dimensions[1] ) )
def by_index( self, index ):
return self.grid[ index[0], index[1], index[2] ]
def fractional_coordinate_at_index( self, index ):
return( np.multiply( self.spacing, index ) )
def cartesian_coordinate_at_index( self, index ):
<|code_end|>
. Use current file imports:
(import numpy as np # type: ignore
import sys
import math
from vasppy import poscar, cell)
and context including class names, function names, or small code snippets from other files:
# Path: vasppy/poscar.py
# def parity( list ):
# def swap_axes( matrix, axes ):
# def __init__( self ):
# def coordinates_by_species( self, species ):
# def range_by_species( self, species ):
# def atom_number_by_species( self, species ):
# def sorted( self, species ):
# def read_from( self, filename ):
# def from_file( cls, filename ):
# def in_bohr( self ):
# def coords_are_fractional( self ):
# def coords_are_cartesian( self ):
# def fractional_coordinates( self ):
# def cartesian_coordinates( self ):
# def select_coordinates( self, coordinate_type='Direct' ):
# def output_coordinates_only( self, coordinate_type='Direct', opts=None ):
# def output( self, coordinate_type='Direct', opts=None ):
# def output_header( self, coordinate_type='Direct', opts=None ):
# def write_to( self, filename, coordinate_type='Direct', opts=None ):
# def output_as_xtl( self ):
# def output_as_cif( self, symprec = None ):
# def output_as_pimaim( self, to_bohr = True ):
# def cell_coordinates( self ):
# def labels( self ):
# def replicate( self, h, k, l, group=False ):
# def cell_lengths( self ):
# def cell_angles( self ):
# def to_configuration( self ):
# def swap_axes( self, axes ):
# def to_pymatgen_structure( self ):
# def stoichiometry( self ):
# class Poscar:
#
# Path: vasppy/cell.py
# def angle( x, y ):
# def rotation_matrix(axis, theta):
# def __init__( self, matrix ):
# def dr( self, r1, r2, cutoff=None ):
# def nearest_image( self, origin, point ):
# def minimum_image( self, r1, r2 ):
# def minimum_image_dr( self, r1, r2, cutoff=None ):
# def lengths( self ):
# def angles( self ):
# def cartesian_to_fractional_coordinates( self, coordinates ):
# def fractional_to_cartesian_coordinates( self, coordinates ):
# def inside_cell( self, r ):
# def volume( self ):
# def unit_vectors( self ):
# def rotate( self, axis, theta ):
# class Cell:
. Output only the next line. | return( self.fractional_coordinate_at_index( index ).dot( self.poscar.cell.matrix ) ) |
Continue the code snippet: <|code_start|>
class Test_Optics(unittest.TestCase):
def test_matrix_eigvals(self):
matrix = np.array( [ [ 2, 0, 3 ],
[ 0, 3, 0 ],
[ 0, 0, 3 ] ] )
expected_eigenvalues = np.array( [ 2, 3, 3 ] )
<|code_end|>
. Use current file imports:
import unittest
import numpy as np
from vasppy.optics import matrix_eigvals, to_matrix, parse_dielectric_data
from unittest.mock import Mock, patch, call
and context (classes, functions, or code) from other files:
# Path: vasppy/optics.py
# def matrix_eigvals(matrix):
# """
# Calculate the eigenvalues of a matrix.
#
# Args:
# matrix (np.array): The matrix to diagonalise.
#
# Returns:
# (np.array): Array of the matrix eigenvalues.
# """
# eigvals, eigvecs = np.linalg.eig(matrix)
# return eigvals
#
# def to_matrix( xx, yy, zz, xy, yz, xz ):
# """
# Convert a list of matrix components to a symmetric 3x3 matrix.
# Inputs should be in the order xx, yy, zz, xy, yz, xz.
#
# Args:
# xx (float): xx component of the matrix.
# yy (float): yy component of the matrix.
# zz (float): zz component of the matrix.
# xy (float): xy component of the matrix.
# yz (float): yz component of the matrix.
# xz (float): xz component of the matrix.
#
# Returns:
# (np.array): The matrix, as a 3x3 numpy array.
# """
# matrix = np.array( [[xx, xy, xz], [xy, yy, yz], [xz, yz, zz]] )
# return matrix
#
# def parse_dielectric_data( data ):
# """
# Convert a set of 2D vasprun formatted dielectric data to
# the eigenvalues of each corresponding 3x3 symmetric numpy matrices.
#
# Args:
# data (list): length N list of dielectric data. Each entry should be
# a list of ``[xx, yy, zz, xy, xz, yz ]`` dielectric
# tensor elements.
#
# Returns:
# (np.array): a Nx3 numpy array. Each row contains the eigenvalues
# for the corresponding row in `data`.
# """
# return np.array( [ matrix_eigvals( to_matrix( *e ) ) for e in data ] )
. Output only the next line. | np.testing.assert_array_equal( matrix_eigvals( matrix ), expected_eigenvalues ) |
Given the code snippet: <|code_start|>
class Test_Optics(unittest.TestCase):
def test_matrix_eigvals(self):
matrix = np.array( [ [ 2, 0, 3 ],
[ 0, 3, 0 ],
[ 0, 0, 3 ] ] )
expected_eigenvalues = np.array( [ 2, 3, 3 ] )
np.testing.assert_array_equal( matrix_eigvals( matrix ), expected_eigenvalues )
def test_to_matrix(self):
expected_matrix = np.array( [ [ 1, 2, 3 ],
[ 2, 4, 5 ],
[ 3, 5, 6 ] ] )
<|code_end|>
, generate the next line using the imports in this file:
import unittest
import numpy as np
from vasppy.optics import matrix_eigvals, to_matrix, parse_dielectric_data
from unittest.mock import Mock, patch, call
and context (functions, classes, or occasionally code) from other files:
# Path: vasppy/optics.py
# def matrix_eigvals(matrix):
# """
# Calculate the eigenvalues of a matrix.
#
# Args:
# matrix (np.array): The matrix to diagonalise.
#
# Returns:
# (np.array): Array of the matrix eigenvalues.
# """
# eigvals, eigvecs = np.linalg.eig(matrix)
# return eigvals
#
# def to_matrix( xx, yy, zz, xy, yz, xz ):
# """
# Convert a list of matrix components to a symmetric 3x3 matrix.
# Inputs should be in the order xx, yy, zz, xy, yz, xz.
#
# Args:
# xx (float): xx component of the matrix.
# yy (float): yy component of the matrix.
# zz (float): zz component of the matrix.
# xy (float): xy component of the matrix.
# yz (float): yz component of the matrix.
# xz (float): xz component of the matrix.
#
# Returns:
# (np.array): The matrix, as a 3x3 numpy array.
# """
# matrix = np.array( [[xx, xy, xz], [xy, yy, yz], [xz, yz, zz]] )
# return matrix
#
# def parse_dielectric_data( data ):
# """
# Convert a set of 2D vasprun formatted dielectric data to
# the eigenvalues of each corresponding 3x3 symmetric numpy matrices.
#
# Args:
# data (list): length N list of dielectric data. Each entry should be
# a list of ``[xx, yy, zz, xy, xz, yz ]`` dielectric
# tensor elements.
#
# Returns:
# (np.array): a Nx3 numpy array. Each row contains the eigenvalues
# for the corresponding row in `data`.
# """
# return np.array( [ matrix_eigvals( to_matrix( *e ) ) for e in data ] )
. Output only the next line. | np.testing.assert_array_equal( to_matrix( xx=1, yy=4, zz=6, xy=2, yz=5, xz=3 ), |
Continue the code snippet: <|code_start|>
class Test_Optics(unittest.TestCase):
def test_matrix_eigvals(self):
matrix = np.array( [ [ 2, 0, 3 ],
[ 0, 3, 0 ],
[ 0, 0, 3 ] ] )
expected_eigenvalues = np.array( [ 2, 3, 3 ] )
np.testing.assert_array_equal( matrix_eigvals( matrix ), expected_eigenvalues )
def test_to_matrix(self):
expected_matrix = np.array( [ [ 1, 2, 3 ],
[ 2, 4, 5 ],
[ 3, 5, 6 ] ] )
np.testing.assert_array_equal( to_matrix( xx=1, yy=4, zz=6, xy=2, yz=5, xz=3 ),
expected_matrix )
@patch('vasppy.optics.to_matrix')
@patch('vasppy.optics.matrix_eigvals')
def test_parse_dielectric_data(self, mock_matrix_eigvals, mock_to_matrix):
input_data = [ [ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6 ],
[ 1.1, 1.2, 1.3, 1.4, 1.5, 1.6 ] ]
matrix_a = np.array( [ [ 0.1, 0.4, 0.6 ], [ 0.4, 0.2, 0.5 ], [ 0.6, 0.5, 0.3 ] ] )
matrix_b = np.array( [ [ 1.1, 1.4, 1.6 ], [ 1.4, 1.2, 1.5 ], [ 1.6, 1.5, 1.3 ] ] )
mock_to_matrix.side_effect = [ matrix_a, matrix_b ]
mock_matrix_eigvals.side_effect = [ np.array( [ 1, 2, 3 ] ), np.array( [ 4, 5, 6 ] ) ]
expected_data = np.array( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] )
<|code_end|>
. Use current file imports:
import unittest
import numpy as np
from vasppy.optics import matrix_eigvals, to_matrix, parse_dielectric_data
from unittest.mock import Mock, patch, call
and context (classes, functions, or code) from other files:
# Path: vasppy/optics.py
# def matrix_eigvals(matrix):
# """
# Calculate the eigenvalues of a matrix.
#
# Args:
# matrix (np.array): The matrix to diagonalise.
#
# Returns:
# (np.array): Array of the matrix eigenvalues.
# """
# eigvals, eigvecs = np.linalg.eig(matrix)
# return eigvals
#
# def to_matrix( xx, yy, zz, xy, yz, xz ):
# """
# Convert a list of matrix components to a symmetric 3x3 matrix.
# Inputs should be in the order xx, yy, zz, xy, yz, xz.
#
# Args:
# xx (float): xx component of the matrix.
# yy (float): yy component of the matrix.
# zz (float): zz component of the matrix.
# xy (float): xy component of the matrix.
# yz (float): yz component of the matrix.
# xz (float): xz component of the matrix.
#
# Returns:
# (np.array): The matrix, as a 3x3 numpy array.
# """
# matrix = np.array( [[xx, xy, xz], [xy, yy, yz], [xz, yz, zz]] )
# return matrix
#
# def parse_dielectric_data( data ):
# """
# Convert a set of 2D vasprun formatted dielectric data to
# the eigenvalues of each corresponding 3x3 symmetric numpy matrices.
#
# Args:
# data (list): length N list of dielectric data. Each entry should be
# a list of ``[xx, yy, zz, xy, xz, yz ]`` dielectric
# tensor elements.
#
# Returns:
# (np.array): a Nx3 numpy array. Each row contains the eigenvalues
# for the corresponding row in `data`.
# """
# return np.array( [ matrix_eigvals( to_matrix( *e ) ) for e in data ] )
. Output only the next line. | np.testing.assert_array_equal( parse_dielectric_data( input_data ), expected_data ) |
Predict the next line for this snippet: <|code_start|>
class AtomTestCase( unittest.TestCase ):
def test_init_atom( self ):
label = 'A'
r = np.array( [ 0.1, 0.2, 0.3 ] )
<|code_end|>
with the help of current file imports:
import unittest
import numpy as np
from vasppy.atom import Atom
and context from other files:
# Path: vasppy/atom.py
# class Atom:
# """
# Class for individual atoms
# """
#
# def __init__( self, label, r ): # currently assume fractional coordinates
# """
# Initialise an Atom instance
#
# Args:
# label (Str): a label for this atom
# r (numpy.array): the atom coordinates
#
# Returns:
# None
# """
# self.label = label
# self.r = r
, which may contain function names, class names, or code. Output only the next line. | atom = Atom( label=label, r=r ) |
Predict the next line after this snippet: <|code_start|>
class VASPMetaTestCase( unittest.TestCase ):
def test_init_vaspmeta( self ):
title = 'title'
description = 'description'
notes = 'notes'
valid_status = [ 'to-run', 'incomplete', 'finished', 'dropped' ]
for s in valid_status:
<|code_end|>
using the current file's imports:
import unittest
from unittest.mock import Mock, patch, mock_open
from vasppy.vaspmeta import VASPMeta
and any relevant context from other files:
# Path: vasppy/vaspmeta.py
# class VASPMeta:
# """
# VASPMeta class for storing additional VASP calculation metadata
# """
#
# def __init__( self, title, description, status, notes=None, type=None, track=None ):
# """
# Initialise a VASPMeta object.
#
# Args:
# title (Str): The title string for this calculation
# description (Str): Long description
# status (Str): Current status of the calculation.
# Expected strings are (to-run, incomplete, finished, dropped)
# notes (:obj:Str, optional): Any additional notes. Defaults to None.
# type (:obj:Str, optional): Can be used to describe the calculation type.
# Defaults to None.
# track (:obj:dict(str: str), optional): An optional dict of pairs of filenames
# for files to track. For each key: value pair, the key is the current filename
# in the directory. The value is the new filename that list of filenames to calculate md5 hashes
# files to calculate hashes for when summarising the calculation output.
# Defaults to None.
#
# Returns:
# None
# """
# self.title = title
# self.description = description
# self.notes = notes
# expected_status = [ 'to-run', 'incomplete', 'finished', 'dropped' ]
# if status not in expected_status:
# raise ValueError(f'Unexpected calculations status: "{status}"'
# f' for calculation {title}')
# self.status = status
# expected_types = [ 'single-point', 'neb' ]
# if type:
# if type not in expected_types:
# raise ValueError(f'Unexpected calculation type: "{type}"'
# f' for calculation {title}')
# self.type = type
# else:
# self.type = None
# self.track = track
#
# @classmethod
# def from_file( cls, filename ):
# """
# Create a VASPMeta object by reading a `vaspmeta.yaml` file
#
# Args:
# filename (Str): filename to read in.
#
# Returns:
# (vasppy.VASPMeta): the VASPMeta object
# """
# with open( filename, 'r' ) as stream:
# data = yaml.load( stream, Loader=yaml.SafeLoader )
# notes = data.get( 'notes' )
# v_type = data.get( 'type' )
# track = data.get( 'track' )
# xargs = {}
# if track:
# if type( track ) is str:
# track = [ track ]
# xargs['track'] = track
# vaspmeta = VASPMeta( data['title'],
# data['description'],
# data['status'],
# notes=notes,
# type=v_type,
# **xargs )
# return vaspmeta
. Output only the next line. | vaspmeta = VASPMeta( title, description, status=s, notes=notes ) |
Predict the next line for this snippet: <|code_start|>
class BandTestCase( unittest.TestCase ):
"""Tests for procar.Band class"""
def test_band_is_initialised( self ):
"""Test Band object is initialised"""
index = 2
energy = 1.0
occupancy = 0.5
with patch( 'vasppy.band.handle_occupancy' ) as mock_handle_occupancy:
mock_handle_occupancy.return_value = 0.5
<|code_end|>
with the help of current file imports:
import warnings
import unittest
from unittest.mock import patch, call
from vasppy.band import Band, handle_occupancy
and context from other files:
# Path: vasppy/band.py
# class Band():
#
# def __init__( self, index, energy, occupancy, negative_occupancies='warn' ):
# self.index = index
# self.energy = energy
# self.occupancy = handle_occupancy( occupancy, negative_occupancies=negative_occupancies )
#
# def __eq__( self, other ):
# return ( ( self.index == other.index ) &
# ( self.energy == other.energy ) &
# ( self.occupancy == other.occupancy ) )
#
# def handle_occupancy( occupancy, negative_occupancies='warn' ):
# valid_negative_occupancies = [ 'warn', 'raise', 'ignore', 'zero' ]
# if negative_occupancies not in valid_negative_occupancies:
# raise ValueError( "valid options for negative_occupancies are {}".format( valid_negative_occupancies ) )
# if occupancy < 0:
# if negative_occupancies == 'warn':
# warnings.warn( "One or more occupancies in your PROCAR file are negative." )
# elif negative_occupancies == 'raise':
# raise ValueError( "One or more occupancies in your PROCAR file are negative." )
# elif negative_occupancies == 'ignore':
# pass
# elif negative_occupancies == 'zero':
# occupancy = 0.0
# return occupancy
, which may contain function names, class names, or code. Output only the next line. | band = Band( index=index, energy=energy, occupancy=occupancy ) |
Given the code snippet: <|code_start|>
class BandTestCase( unittest.TestCase ):
"""Tests for procar.Band class"""
def test_band_is_initialised( self ):
"""Test Band object is initialised"""
index = 2
energy = 1.0
occupancy = 0.5
with patch( 'vasppy.band.handle_occupancy' ) as mock_handle_occupancy:
mock_handle_occupancy.return_value = 0.5
band = Band( index=index, energy=energy, occupancy=occupancy )
self.assertEqual( index, band.index )
self.assertEqual( energy, band.energy )
self.assertEqual( occupancy, band.occupancy )
mock_handle_occupancy.assert_has_calls( [call(0.5, negative_occupancies='warn')] )
def test_handle_occupancy_raises_valuerror_if_negative_occupancies_is_invalid_keyword( self ):
with self.assertRaises( ValueError ):
<|code_end|>
, generate the next line using the imports in this file:
import warnings
import unittest
from unittest.mock import patch, call
from vasppy.band import Band, handle_occupancy
and context (functions, classes, or occasionally code) from other files:
# Path: vasppy/band.py
# class Band():
#
# def __init__( self, index, energy, occupancy, negative_occupancies='warn' ):
# self.index = index
# self.energy = energy
# self.occupancy = handle_occupancy( occupancy, negative_occupancies=negative_occupancies )
#
# def __eq__( self, other ):
# return ( ( self.index == other.index ) &
# ( self.energy == other.energy ) &
# ( self.occupancy == other.occupancy ) )
#
# def handle_occupancy( occupancy, negative_occupancies='warn' ):
# valid_negative_occupancies = [ 'warn', 'raise', 'ignore', 'zero' ]
# if negative_occupancies not in valid_negative_occupancies:
# raise ValueError( "valid options for negative_occupancies are {}".format( valid_negative_occupancies ) )
# if occupancy < 0:
# if negative_occupancies == 'warn':
# warnings.warn( "One or more occupancies in your PROCAR file are negative." )
# elif negative_occupancies == 'raise':
# raise ValueError( "One or more occupancies in your PROCAR file are negative." )
# elif negative_occupancies == 'ignore':
# pass
# elif negative_occupancies == 'zero':
# occupancy = 0.0
# return occupancy
. Output only the next line. | handle_occupancy( 0.5, negative_occupancies='foo' ) |
Based on the snippet: <|code_start|>#! /usr/bin/env python3
def minimum_length( nmin ):
class MinimumLength( argparse.Action ):
def __call__( self, parser, args, values, option_string=None ):
if not nmin <= len( values ):
msg = 'argument "{f}" requires at least {nmin} arguments'.format( f = self.dest, nmin = nmin )
raise argparse.ArgumentError( self, msg )
setattr( args, self.dest, values )
return MinimumLength
def main():
parser = argparse.ArgumentParser( description='Calculate an effective mass from a VASP PROCAR using a fitted quadratic' )
parser.add_argument( '-k', '--k-points', help='index of k-points for calculating effective mass', nargs='+', type=int, required=True, action=minimum_length( 2 ) )
parser.add_argument( '-b', '--band-index', help='index of band for calculating effective mass', type=int, required=True )
parser.add_argument( '-f', '--procar', help='PROCAR filename (default PROCAR)', type=str, default='PROCAR' )
parser.add_argument( '-v', '--verbose', help='Verbose output', action='store_true' )
parser.add_argument( '-o', '--outcar', help='OUTCAR filename (default OUTCAR)', type=str, default='OUTCAR' )
parser.add_argument( '-s', '--spin', help='select spin channel (default 1 / non-spin-polarised)', type=int, default='1' )
args = parser.parse_args()
reciprocal_lattice = reciprocal_lattice_from_outcar( 'OUTCAR' ) # Move reading the reciprocal lattice to procar.py
<|code_end|>
, predict the immediate next line with the help of imports:
from vasppy import procar
from vasppy.outcar import reciprocal_lattice_from_outcar
import argparse
and context (classes, functions, sometimes code) from other files:
# Path: vasppy/procar.py
# class KPoint():
# class Procar:
# def __init__( self, index, frac_coords, weight ):
# def cart_coords( self, reciprocal_lattice ):
# def __eq__( self, other ):
# def __repr__( self ):
# def get_numbers_from_string( string ):
# def k_point_parser( string ):
# def projections_parser( string ):
# def area_of_a_triangle_in_cartesian_space( a, b, c ):
# def points_are_in_a_straight_line( points, tolerance=1e-7 ):
# def two_point_effective_mass( cartesian_k_points, eigenvalues ):
# def least_squares_effective_mass( cartesian_k_points, eigenvalues ):
# def __init__( self, spin=1, negative_occupancies='warn' ):
# def occupancy( self ):
# def __add__( self, other ):
# def parse_projections( self ):
# def parse_k_points( self ):
# def parse_bands( self ):
# def sanity_check( self ):
# def from_files( cls, filenames, **kwargs ):
# def from_file( cls, filename, negative_occupancies='warn',
# select_zero_weighted_k_points=False ):
# def read_from_file( self, filename ):
# def _read_from_file( self, filename ):
# def number_of_k_points( self ):
# def number_of_bands( self ):
# def spin_channels( self ):
# def number_of_ions( self ):
# def number_of_projections( self ):
# def print_weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def effective_mass_calc( self, k_point_indices, band_index, reciprocal_lattice, spin=1, printing=False ):
# def x_axis( self, reciprocal_lattice=None ):
# def bands( self ):
# def k_points( self ):
# def select_bands_by_kpoint( self, band_indices ):
# def select_k_points( self, band_indices ):
#
# Path: vasppy/outcar.py
# def reciprocal_lattice_from_outcar( filename ): # from https://github.com/MaterialsDiscovery/PyChemia
# """
# Finds and returns the reciprocal lattice vectors, if more than
# one set present, it just returns the last one.
# Args:
# filename (Str): The name of the outcar file to be read
#
# Returns:
# List(Float): The reciprocal lattice vectors.
# """
# outcar = open(filename, "r").read()
# # just keeping the last component
# recLat = re.findall(r"reciprocal\s*lattice\s*vectors\s*([-.\s\d]*)",
# outcar)[-1]
# recLat = recLat.split()
# recLat = np.array(recLat, dtype=float)
# # up to now I have, both direct and rec. lattices (3+3=6 columns)
# recLat.shape = (3, 6)
# recLat = recLat[:, 3:]
# return recLat
. Output only the next line. | pcar = procar.Procar() |
Using the snippet: <|code_start|>#! /usr/bin/env python3
def minimum_length( nmin ):
class MinimumLength( argparse.Action ):
def __call__( self, parser, args, values, option_string=None ):
if not nmin <= len( values ):
msg = 'argument "{f}" requires at least {nmin} arguments'.format( f = self.dest, nmin = nmin )
raise argparse.ArgumentError( self, msg )
setattr( args, self.dest, values )
return MinimumLength
def main():
parser = argparse.ArgumentParser( description='Calculate an effective mass from a VASP PROCAR using a fitted quadratic' )
parser.add_argument( '-k', '--k-points', help='index of k-points for calculating effective mass', nargs='+', type=int, required=True, action=minimum_length( 2 ) )
parser.add_argument( '-b', '--band-index', help='index of band for calculating effective mass', type=int, required=True )
parser.add_argument( '-f', '--procar', help='PROCAR filename (default PROCAR)', type=str, default='PROCAR' )
parser.add_argument( '-v', '--verbose', help='Verbose output', action='store_true' )
parser.add_argument( '-o', '--outcar', help='OUTCAR filename (default OUTCAR)', type=str, default='OUTCAR' )
parser.add_argument( '-s', '--spin', help='select spin channel (default 1 / non-spin-polarised)', type=int, default='1' )
args = parser.parse_args()
<|code_end|>
, determine the next line of code. You have imports:
from vasppy import procar
from vasppy.outcar import reciprocal_lattice_from_outcar
import argparse
and context (class names, function names, or code) available:
# Path: vasppy/procar.py
# class KPoint():
# class Procar:
# def __init__( self, index, frac_coords, weight ):
# def cart_coords( self, reciprocal_lattice ):
# def __eq__( self, other ):
# def __repr__( self ):
# def get_numbers_from_string( string ):
# def k_point_parser( string ):
# def projections_parser( string ):
# def area_of_a_triangle_in_cartesian_space( a, b, c ):
# def points_are_in_a_straight_line( points, tolerance=1e-7 ):
# def two_point_effective_mass( cartesian_k_points, eigenvalues ):
# def least_squares_effective_mass( cartesian_k_points, eigenvalues ):
# def __init__( self, spin=1, negative_occupancies='warn' ):
# def occupancy( self ):
# def __add__( self, other ):
# def parse_projections( self ):
# def parse_k_points( self ):
# def parse_bands( self ):
# def sanity_check( self ):
# def from_files( cls, filenames, **kwargs ):
# def from_file( cls, filename, negative_occupancies='warn',
# select_zero_weighted_k_points=False ):
# def read_from_file( self, filename ):
# def _read_from_file( self, filename ):
# def number_of_k_points( self ):
# def number_of_bands( self ):
# def spin_channels( self ):
# def number_of_ions( self ):
# def number_of_projections( self ):
# def print_weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def effective_mass_calc( self, k_point_indices, band_index, reciprocal_lattice, spin=1, printing=False ):
# def x_axis( self, reciprocal_lattice=None ):
# def bands( self ):
# def k_points( self ):
# def select_bands_by_kpoint( self, band_indices ):
# def select_k_points( self, band_indices ):
#
# Path: vasppy/outcar.py
# def reciprocal_lattice_from_outcar( filename ): # from https://github.com/MaterialsDiscovery/PyChemia
# """
# Finds and returns the reciprocal lattice vectors, if more than
# one set present, it just returns the last one.
# Args:
# filename (Str): The name of the outcar file to be read
#
# Returns:
# List(Float): The reciprocal lattice vectors.
# """
# outcar = open(filename, "r").read()
# # just keeping the last component
# recLat = re.findall(r"reciprocal\s*lattice\s*vectors\s*([-.\s\d]*)",
# outcar)[-1]
# recLat = recLat.split()
# recLat = np.array(recLat, dtype=float)
# # up to now I have, both direct and rec. lattices (3+3=6 columns)
# recLat.shape = (3, 6)
# recLat = recLat[:, 3:]
# return recLat
. Output only the next line. | reciprocal_lattice = reciprocal_lattice_from_outcar( 'OUTCAR' ) # Move reading the reciprocal lattice to procar.py |
Predict the next line after this snippet: <|code_start|># return x_axis
def orbitals_with_l( l ):
to_return = { 's' : [ 0 ],
'p' : [ 1, 2, 3 ],
'd' : [ 4, 5, 6, 7, 8 ],
'f' : [ 9, 10, 11, 12, 13 ],
'all' : None }
return to_return[ l ]
def main():
parser = argparse.ArgumentParser()
parser.add_argument( '-i', '--ions', help='ion indices for band projection (default: sum over all ions)', nargs='+', type=int )
parser.add_argument( '-s', '--spins', help='spin indices for band projection (default [ 1 ])', nargs='+', type=int, default=[ 1 ] )
parser.add_argument( '-o', '--orbitals', help='orbital indices for band projection (default: sum over all orbitals)', nargs='+', type=int )
parser.add_argument( '-e', '--efermi', help='set fermi energy as reference for energy scale', type=float, default=0.0 )
parser.add_argument( '-l', '--l-angular-momentum', help='select all orbitals with angular momentum L for band projection. This supercedes the --orbitals option', choices=[ 's', 'p', 'd', 'f', 'all' ] )
parser.add_argument( '-f', '--procar', help='PROCAR filename (default PROCAR)', type=str, default='PROCAR' )
parser.add_argument( '--scaling', help='Energy scaling for band widths (default 0.2 eV)', type=float, default=0.2 )
parser.add_argument( '-x', '--xscaling', help='Automatic scaling of x-axis using reciprocal lattice vectors read from OUTCAR', action='store_true', default=False )
args = parser.parse_args()
if args.l_angular_momentum:
args.orbitals = orbitals_with_l( args.l_angular_momentum )
if args.xscaling:
reciprocal_lattice = reciprocal_lattice_from_outcar( 'OUTCAR' ) # Move reading the reciprocal lattice to procar.py
else:
reciprocal_lattice = None
<|code_end|>
using the current file's imports:
from vasppy import procar
from vasppy.outcar import reciprocal_lattice_from_outcar
import argparse
and any relevant context from other files:
# Path: vasppy/procar.py
# class KPoint():
# class Procar:
# def __init__( self, index, frac_coords, weight ):
# def cart_coords( self, reciprocal_lattice ):
# def __eq__( self, other ):
# def __repr__( self ):
# def get_numbers_from_string( string ):
# def k_point_parser( string ):
# def projections_parser( string ):
# def area_of_a_triangle_in_cartesian_space( a, b, c ):
# def points_are_in_a_straight_line( points, tolerance=1e-7 ):
# def two_point_effective_mass( cartesian_k_points, eigenvalues ):
# def least_squares_effective_mass( cartesian_k_points, eigenvalues ):
# def __init__( self, spin=1, negative_occupancies='warn' ):
# def occupancy( self ):
# def __add__( self, other ):
# def parse_projections( self ):
# def parse_k_points( self ):
# def parse_bands( self ):
# def sanity_check( self ):
# def from_files( cls, filenames, **kwargs ):
# def from_file( cls, filename, negative_occupancies='warn',
# select_zero_weighted_k_points=False ):
# def read_from_file( self, filename ):
# def _read_from_file( self, filename ):
# def number_of_k_points( self ):
# def number_of_bands( self ):
# def spin_channels( self ):
# def number_of_ions( self ):
# def number_of_projections( self ):
# def print_weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def effective_mass_calc( self, k_point_indices, band_index, reciprocal_lattice, spin=1, printing=False ):
# def x_axis( self, reciprocal_lattice=None ):
# def bands( self ):
# def k_points( self ):
# def select_bands_by_kpoint( self, band_indices ):
# def select_k_points( self, band_indices ):
#
# Path: vasppy/outcar.py
# def reciprocal_lattice_from_outcar( filename ): # from https://github.com/MaterialsDiscovery/PyChemia
# """
# Finds and returns the reciprocal lattice vectors, if more than
# one set present, it just returns the last one.
# Args:
# filename (Str): The name of the outcar file to be read
#
# Returns:
# List(Float): The reciprocal lattice vectors.
# """
# outcar = open(filename, "r").read()
# # just keeping the last component
# recLat = re.findall(r"reciprocal\s*lattice\s*vectors\s*([-.\s\d]*)",
# outcar)[-1]
# recLat = recLat.split()
# recLat = np.array(recLat, dtype=float)
# # up to now I have, both direct and rec. lattices (3+3=6 columns)
# recLat.shape = (3, 6)
# recLat = recLat[:, 3:]
# return recLat
. Output only the next line. | pcar = procar.Procar() |
Given the code snippet: <|code_start|># x_axis.append( d + x_axis[-1] )
# x_axis = np.array( x_axis )
# else:
# x_axis = np.arange( len( cartesian_k_points ) )
# return x_axis
def orbitals_with_l( l ):
to_return = { 's' : [ 0 ],
'p' : [ 1, 2, 3 ],
'd' : [ 4, 5, 6, 7, 8 ],
'f' : [ 9, 10, 11, 12, 13 ],
'all' : None }
return to_return[ l ]
def main():
parser = argparse.ArgumentParser()
parser.add_argument( '-i', '--ions', help='ion indices for band projection (default: sum over all ions)', nargs='+', type=int )
parser.add_argument( '-s', '--spins', help='spin indices for band projection (default [ 1 ])', nargs='+', type=int, default=[ 1 ] )
parser.add_argument( '-o', '--orbitals', help='orbital indices for band projection (default: sum over all orbitals)', nargs='+', type=int )
parser.add_argument( '-e', '--efermi', help='set fermi energy as reference for energy scale', type=float, default=0.0 )
parser.add_argument( '-l', '--l-angular-momentum', help='select all orbitals with angular momentum L for band projection. This supercedes the --orbitals option', choices=[ 's', 'p', 'd', 'f', 'all' ] )
parser.add_argument( '-f', '--procar', help='PROCAR filename (default PROCAR)', type=str, default='PROCAR' )
parser.add_argument( '--scaling', help='Energy scaling for band widths (default 0.2 eV)', type=float, default=0.2 )
parser.add_argument( '-x', '--xscaling', help='Automatic scaling of x-axis using reciprocal lattice vectors read from OUTCAR', action='store_true', default=False )
args = parser.parse_args()
if args.l_angular_momentum:
args.orbitals = orbitals_with_l( args.l_angular_momentum )
if args.xscaling:
<|code_end|>
, generate the next line using the imports in this file:
from vasppy import procar
from vasppy.outcar import reciprocal_lattice_from_outcar
import argparse
and context (functions, classes, or occasionally code) from other files:
# Path: vasppy/procar.py
# class KPoint():
# class Procar:
# def __init__( self, index, frac_coords, weight ):
# def cart_coords( self, reciprocal_lattice ):
# def __eq__( self, other ):
# def __repr__( self ):
# def get_numbers_from_string( string ):
# def k_point_parser( string ):
# def projections_parser( string ):
# def area_of_a_triangle_in_cartesian_space( a, b, c ):
# def points_are_in_a_straight_line( points, tolerance=1e-7 ):
# def two_point_effective_mass( cartesian_k_points, eigenvalues ):
# def least_squares_effective_mass( cartesian_k_points, eigenvalues ):
# def __init__( self, spin=1, negative_occupancies='warn' ):
# def occupancy( self ):
# def __add__( self, other ):
# def parse_projections( self ):
# def parse_k_points( self ):
# def parse_bands( self ):
# def sanity_check( self ):
# def from_files( cls, filenames, **kwargs ):
# def from_file( cls, filename, negative_occupancies='warn',
# select_zero_weighted_k_points=False ):
# def read_from_file( self, filename ):
# def _read_from_file( self, filename ):
# def number_of_k_points( self ):
# def number_of_bands( self ):
# def spin_channels( self ):
# def number_of_ions( self ):
# def number_of_projections( self ):
# def print_weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def effective_mass_calc( self, k_point_indices, band_index, reciprocal_lattice, spin=1, printing=False ):
# def x_axis( self, reciprocal_lattice=None ):
# def bands( self ):
# def k_points( self ):
# def select_bands_by_kpoint( self, band_indices ):
# def select_k_points( self, band_indices ):
#
# Path: vasppy/outcar.py
# def reciprocal_lattice_from_outcar( filename ): # from https://github.com/MaterialsDiscovery/PyChemia
# """
# Finds and returns the reciprocal lattice vectors, if more than
# one set present, it just returns the last one.
# Args:
# filename (Str): The name of the outcar file to be read
#
# Returns:
# List(Float): The reciprocal lattice vectors.
# """
# outcar = open(filename, "r").read()
# # just keeping the last component
# recLat = re.findall(r"reciprocal\s*lattice\s*vectors\s*([-.\s\d]*)",
# outcar)[-1]
# recLat = recLat.split()
# recLat = np.array(recLat, dtype=float)
# # up to now I have, both direct and rec. lattices (3+3=6 columns)
# recLat.shape = (3, 6)
# recLat = recLat[:, 3:]
# return recLat
. Output only the next line. | reciprocal_lattice = reciprocal_lattice_from_outcar( 'OUTCAR' ) # Move reading the reciprocal lattice to procar.py |
Predict the next line after this snippet: <|code_start|>
class OutcarTestCase( unittest.TestCase ):
def test_final_energy_from_outcar( self ):
example_file = """energy without entropy = -2997.63294724 energy(sigma->0) = -2997.63294724\n
energy without entropy= -2997.63294724 energy(sigma->0) = -2997.63294724\n
energy without entropy = -2997.63289805 energy(sigma->0) = -2997.63289805\n"""
with patch( 'builtins.open', mock_open( read_data=example_file ), create=True ) as m:
<|code_end|>
using the current file's imports:
import unittest
import numpy as np
from unittest.mock import Mock, patch, mock_open, call
from vasppy.outcar import final_energy_from_outcar, potcar_eatom_list_from_outcar
and any relevant context from other files:
# Path: vasppy/outcar.py
# def final_energy_from_outcar( filename='OUTCAR' ):
# """
# Finds and returns the energy from a VASP OUTCAR file, by searching for the last `energy(sigma->0)` entry.
#
# Args:
# filename (Str, optional): OUTCAR filename. Defaults to 'OUTCAR'.
#
# Returns:
# (Float): The last energy read from the OUTCAR file.
# """
# with open( filename ) as f:
# outcar = f.read()
# energy_re = re.compile( "energy\(sigma->0\) =\s+([-\d\.]+)" )
# energy = float( energy_re.findall( outcar )[-1] )
# return energy
#
# def potcar_eatom_list_from_outcar( filename='OUTCAR' ):
# """
# Returns a list of EATOM values for the pseudopotentials used.
#
# Args:
# filename (Str, optional): OUTCAR filename. Defaults to 'OUTCAR'.
#
# Returns:
# (List(Float)): A list of EATOM values, in the order they appear in the OUTCAR.
# """
# with open( filename ) as f:
# outcar = f.read()
# eatom_re = re.compile( "energy of atom\s+\d+\s+EATOM=\s*([-\d\.]+)" )
# eatom = [ float( e ) for e in eatom_re.findall( outcar ) ]
# return eatom
. Output only the next line. | self.assertEqual( final_energy_from_outcar(), -2997.63289805 ) |
Next line prediction: <|code_start|>
class OutcarTestCase( unittest.TestCase ):
def test_final_energy_from_outcar( self ):
example_file = """energy without entropy = -2997.63294724 energy(sigma->0) = -2997.63294724\n
energy without entropy= -2997.63294724 energy(sigma->0) = -2997.63294724\n
energy without entropy = -2997.63289805 energy(sigma->0) = -2997.63289805\n"""
with patch( 'builtins.open', mock_open( read_data=example_file ), create=True ) as m:
self.assertEqual( final_energy_from_outcar(), -2997.63289805 )
def test_final_energy_from_outcar_with_filename(self):
example_file = """energy without entropy = -2997.63294724 energy(sigma->0) = -2997.63294724\n
energy without entropy= -2997.63294724 energy(sigma->0) = -2997.63294724\n
energy without entropy = -2997.63289805 energy(sigma->0) = -2997.63289805\n"""
with patch('builtins.open', mock_open(read_data=example_file), create=True) as m:
final_energy_from_outcar(filename='foo')
self.assertEqual( m.mock_calls[0], call('foo') )
def test_potcar_eatom_list_from_potcar( self ):
example_file = """energy of atom 1 EATOM=-1042.3781\n
kinetic energy error for atom= 0.0024 (will be added to EATOM!!)\n
energy of atom 2 EATOM= -432.3788\n
kinetic energy error for atom= 0.0224 (will be added to EATOM!!)\n
energy of atom 3 EATOM= -659.6475\n
kinetic energy error for atom= 0.0354 (will be added to EATOM!!)\n"""
with patch( 'builtins.open', mock_open( read_data=example_file ), create=True ) as m:
<|code_end|>
. Use current file imports:
(import unittest
import numpy as np
from unittest.mock import Mock, patch, mock_open, call
from vasppy.outcar import final_energy_from_outcar, potcar_eatom_list_from_outcar)
and context including class names, function names, or small code snippets from other files:
# Path: vasppy/outcar.py
# def final_energy_from_outcar( filename='OUTCAR' ):
# """
# Finds and returns the energy from a VASP OUTCAR file, by searching for the last `energy(sigma->0)` entry.
#
# Args:
# filename (Str, optional): OUTCAR filename. Defaults to 'OUTCAR'.
#
# Returns:
# (Float): The last energy read from the OUTCAR file.
# """
# with open( filename ) as f:
# outcar = f.read()
# energy_re = re.compile( "energy\(sigma->0\) =\s+([-\d\.]+)" )
# energy = float( energy_re.findall( outcar )[-1] )
# return energy
#
# def potcar_eatom_list_from_outcar( filename='OUTCAR' ):
# """
# Returns a list of EATOM values for the pseudopotentials used.
#
# Args:
# filename (Str, optional): OUTCAR filename. Defaults to 'OUTCAR'.
#
# Returns:
# (List(Float)): A list of EATOM values, in the order they appear in the OUTCAR.
# """
# with open( filename ) as f:
# outcar = f.read()
# eatom_re = re.compile( "energy of atom\s+\d+\s+EATOM=\s*([-\d\.]+)" )
# eatom = [ float( e ) for e in eatom_re.findall( outcar ) ]
# return eatom
. Output only the next line. | self.assertEqual( potcar_eatom_list_from_outcar(), [ -1042.3781, -432.3788, -659.6475 ] ) |
Using the snippet: <|code_start|>
class UtilsTestCase( unittest.TestCase ):
def test_md5sum( self ):
string = 'abcdefg'
h = hashlib.new( 'md5' )
h.update( string.encode( 'utf-8' ) )
<|code_end|>
, determine the next line of code. You have imports:
import unittest
import hashlib
from vasppy.utils import md5sum, file_md5, validate_checksum
from unittest.mock import patch, mock_open
and context (class names, function names, or code) available:
# Path: vasppy/utils.py
# def md5sum( string ):
# """
# Generate the md5 checksum for a string
#
# Args:
# string (Str): The string to be checksummed.
#
# Returns:
# (Str): The hex checksum.
# """
# h = hashlib.new( 'md5' )
# h.update( string.encode( 'utf-8' ) )
# return h.hexdigest()
#
# def file_md5( filename ):
# """
# Generate the md5 checksum for a file
#
# Args:
# filename (Str): The file to be checksummed.
#
# Returns:
# (Str): The hex checksum
#
# Notes:
# If the file is gzipped, the md5 checksum returned is
# for the uncompressed ASCII file.
# """
# with zopen( filename, 'r' ) as f:
# file_string = f.read()
# try: # attempt to decode byte object
# file_string = file_string.decode()
# except AttributeError:
# pass
# return( md5sum( file_string ) )
#
# def validate_checksum( filename, md5sum ):
# """
# Compares the md5 checksum of a file with an expected value.
# If the calculated and expected checksum values are not equal,
# ValueError is raised.
# If the filename `foo` is not found, will try to read a gzipped file named
# `foo.gz`. In this case, the checksum is calculated for the unzipped file.
#
# Args:
# filename (str): Path for the file to be checksummed.
# md5sum (str): The expected hex checksum.
#
# Returns:
# None
# """
# filename = match_filename( filename )
# md5_hash = file_md5( filename=filename )
# if md5_hash != md5sum:
# raise ValueError('md5 checksums are inconsistent: {}'.format( filename ))
. Output only the next line. | self.assertEqual( md5sum( string ), h.hexdigest() ) |
Predict the next line for this snippet: <|code_start|>
class UtilsTestCase( unittest.TestCase ):
def test_md5sum( self ):
string = 'abcdefg'
h = hashlib.new( 'md5' )
h.update( string.encode( 'utf-8' ) )
self.assertEqual( md5sum( string ), h.hexdigest() )
def test_file_md5( self ):
example_file = "abc\nabc\n"
with patch( 'vasppy.utils.md5sum' ) as mock_md5sum:
mock_md5sum.return_value = 'foo'
with patch( 'vasppy.utils.zopen', mock_open( read_data=example_file ), create=True ) as m:
<|code_end|>
with the help of current file imports:
import unittest
import hashlib
from vasppy.utils import md5sum, file_md5, validate_checksum
from unittest.mock import patch, mock_open
and context from other files:
# Path: vasppy/utils.py
# def md5sum( string ):
# """
# Generate the md5 checksum for a string
#
# Args:
# string (Str): The string to be checksummed.
#
# Returns:
# (Str): The hex checksum.
# """
# h = hashlib.new( 'md5' )
# h.update( string.encode( 'utf-8' ) )
# return h.hexdigest()
#
# def file_md5( filename ):
# """
# Generate the md5 checksum for a file
#
# Args:
# filename (Str): The file to be checksummed.
#
# Returns:
# (Str): The hex checksum
#
# Notes:
# If the file is gzipped, the md5 checksum returned is
# for the uncompressed ASCII file.
# """
# with zopen( filename, 'r' ) as f:
# file_string = f.read()
# try: # attempt to decode byte object
# file_string = file_string.decode()
# except AttributeError:
# pass
# return( md5sum( file_string ) )
#
# def validate_checksum( filename, md5sum ):
# """
# Compares the md5 checksum of a file with an expected value.
# If the calculated and expected checksum values are not equal,
# ValueError is raised.
# If the filename `foo` is not found, will try to read a gzipped file named
# `foo.gz`. In this case, the checksum is calculated for the unzipped file.
#
# Args:
# filename (str): Path for the file to be checksummed.
# md5sum (str): The expected hex checksum.
#
# Returns:
# None
# """
# filename = match_filename( filename )
# md5_hash = file_md5( filename=filename )
# if md5_hash != md5sum:
# raise ValueError('md5 checksums are inconsistent: {}'.format( filename ))
, which may contain function names, class names, or code. Output only the next line. | self.assertEqual( file_md5( m ), 'foo' ) |
Given the following code snippet before the placeholder: <|code_start|>
class UtilsTestCase( unittest.TestCase ):
def test_md5sum( self ):
string = 'abcdefg'
h = hashlib.new( 'md5' )
h.update( string.encode( 'utf-8' ) )
self.assertEqual( md5sum( string ), h.hexdigest() )
def test_file_md5( self ):
example_file = "abc\nabc\n"
with patch( 'vasppy.utils.md5sum' ) as mock_md5sum:
mock_md5sum.return_value = 'foo'
with patch( 'vasppy.utils.zopen', mock_open( read_data=example_file ), create=True ) as m:
self.assertEqual( file_md5( m ), 'foo' )
mock_md5sum.assert_called_with( example_file )
def test_validate_checksum( self ):
with patch( 'vasppy.utils.match_filename' ) as mock_match_filename:
with patch( 'vasppy.utils.file_md5' ) as mock_file_md5:
mock_file_md5.return_value='abcdef'
<|code_end|>
, predict the next line using imports from the current file:
import unittest
import hashlib
from vasppy.utils import md5sum, file_md5, validate_checksum
from unittest.mock import patch, mock_open
and context including class names, function names, and sometimes code from other files:
# Path: vasppy/utils.py
# def md5sum( string ):
# """
# Generate the md5 checksum for a string
#
# Args:
# string (Str): The string to be checksummed.
#
# Returns:
# (Str): The hex checksum.
# """
# h = hashlib.new( 'md5' )
# h.update( string.encode( 'utf-8' ) )
# return h.hexdigest()
#
# def file_md5( filename ):
# """
# Generate the md5 checksum for a file
#
# Args:
# filename (Str): The file to be checksummed.
#
# Returns:
# (Str): The hex checksum
#
# Notes:
# If the file is gzipped, the md5 checksum returned is
# for the uncompressed ASCII file.
# """
# with zopen( filename, 'r' ) as f:
# file_string = f.read()
# try: # attempt to decode byte object
# file_string = file_string.decode()
# except AttributeError:
# pass
# return( md5sum( file_string ) )
#
# def validate_checksum( filename, md5sum ):
# """
# Compares the md5 checksum of a file with an expected value.
# If the calculated and expected checksum values are not equal,
# ValueError is raised.
# If the filename `foo` is not found, will try to read a gzipped file named
# `foo.gz`. In this case, the checksum is calculated for the unzipped file.
#
# Args:
# filename (str): Path for the file to be checksummed.
# md5sum (str): The expected hex checksum.
#
# Returns:
# None
# """
# filename = match_filename( filename )
# md5_hash = file_md5( filename=filename )
# if md5_hash != md5sum:
# raise ValueError('md5 checksums are inconsistent: {}'.format( filename ))
. Output only the next line. | validate_checksum( filename='foo', md5sum='abcdef' ) |
Based on the snippet: <|code_start|>#! /usr/bin/env python3
def parse_command_line_arguments():
parser = argparse.ArgumentParser( description='Generate POTCAR specification based on hashing individual pseudopotential strings' )
parser.add_argument('potcar', help="filename of the VASP POTCAR to be processed", nargs='?', default='POTCAR' )
parser.add_argument('--hash', help="return the md5 hashes of the individual pseudopotential strings", action='store_true')
args = parser.parse_args()
return args
def main():
args = parse_command_line_arguments()
if args.hash:
hashes = {}
<|code_end|>
, predict the immediate next line with the help of imports:
from vasppy.summary import potcar_spec
import argparse
and context (classes, functions, sometimes code) from other files:
# Path: vasppy/summary.py
# def potcar_spec(filename, return_hashes=False):
# """
# Returns a dictionary specifying the pseudopotentials contained in a POTCAR file.
#
# Args:
# filename (str): The name of the POTCAR file to process.
# return_hash (bool): If True the return dictionary values will be the md5 hashes of
# the component pseudopotential files.
#
# Returns:
# (Dict): A dictionary of pseudopotential filename: dataset pairs, e.g.
# {'Fe_pv': 'PBE_54', 'O', 'PBE_54'}
# """
# p_spec = {}
# with open(filename, 'r') as f:
# potcars = re.split('(End of Dataset\n)', f.read() )
# potcar_md5sums = [md5sum(''.join(pair)) for pair in zip(potcars[::2], potcars[1:-1:2])]
# for this_md5sum in potcar_md5sums:
# for ps in potcar_sets:
# for p, p_md5sum in potcar_md5sum_data[ps].items():
# if this_md5sum == p_md5sum:
# if return_hashes:
# p_spec[p] = this_md5sum
# else:
# p_spec[p] = ps
# if len(set(p_spec)) != len(set(potcar_md5sums)):
# raise ValueError( 'One or more POTCARs did not have matching md5 hashes' )
# return p_spec
. Output only the next line. | for p, md5hash in potcar_spec(args.potcar, return_hashes=True).items(): |
Based on the snippet: <|code_start|>
test_data_dir = 'test_data'
test_procar_filename = os.path.join( os.path.dirname( __file__ ), test_data_dir, 'PROCAR_test' )
test_procar_spin_polarised_filename = os.path.join( os.path.dirname( __file__ ), test_data_dir, 'PROCAR_spin_polarised_test' )
class KPointTestCase( unittest.TestCase ):
"""Test for procar.KPoint class"""
def setUp( self ):
index = 1
frac_coords = np.array( [ 0.1, 0.2, 0.3 ] )
weight = 0.1
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
import os
import numpy as np
import warnings
from vasppy import procar
from unittest.mock import patch, call
from copy import deepcopy
and context (classes, functions, sometimes code) from other files:
# Path: vasppy/procar.py
# class KPoint():
# class Procar:
# def __init__( self, index, frac_coords, weight ):
# def cart_coords( self, reciprocal_lattice ):
# def __eq__( self, other ):
# def __repr__( self ):
# def get_numbers_from_string( string ):
# def k_point_parser( string ):
# def projections_parser( string ):
# def area_of_a_triangle_in_cartesian_space( a, b, c ):
# def points_are_in_a_straight_line( points, tolerance=1e-7 ):
# def two_point_effective_mass( cartesian_k_points, eigenvalues ):
# def least_squares_effective_mass( cartesian_k_points, eigenvalues ):
# def __init__( self, spin=1, negative_occupancies='warn' ):
# def occupancy( self ):
# def __add__( self, other ):
# def parse_projections( self ):
# def parse_k_points( self ):
# def parse_bands( self ):
# def sanity_check( self ):
# def from_files( cls, filenames, **kwargs ):
# def from_file( cls, filename, negative_occupancies='warn',
# select_zero_weighted_k_points=False ):
# def read_from_file( self, filename ):
# def _read_from_file( self, filename ):
# def number_of_k_points( self ):
# def number_of_bands( self ):
# def spin_channels( self ):
# def number_of_ions( self ):
# def number_of_projections( self ):
# def print_weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def weighted_band_structure( self, spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None ):
# def effective_mass_calc( self, k_point_indices, band_index, reciprocal_lattice, spin=1, printing=False ):
# def x_axis( self, reciprocal_lattice=None ):
# def bands( self ):
# def k_points( self ):
# def select_bands_by_kpoint( self, band_indices ):
# def select_k_points( self, band_indices ):
. Output only the next line. | self.k_point = procar.KPoint( index=index, frac_coords=frac_coords, weight=weight ) |
Predict the next line after this snippet: <|code_start|> new_poscar.atom_numbers = [ int( num * h * k * l / 2 ) for num in self.atom_numbers for __ in ( 0, 1 )]
else:
new_poscar.atoms = self.atoms
new_poscar.atom_numbers = [ num * h * k * l for num in self.atom_numbers ]
# generate grouped / ungrouped atoms coordinates for supercell
if group:
for row in self.coordinates:
pos_in_origin_cell = row / lattice_scaling
for odd_even in ( 0, 1 ):
for ( a, b, c ) in [ cell_shift for cell_shift in cell_shift_indices if parity(cell_shift) == odd_even ]:
new_coordinate_list.append( [ pos_in_origin_cell + np.array( [ a, b, c ] * lattice_shift ) ][0].tolist() )
else:
for row in self.coordinates:
pos_in_origin_cell = row / lattice_scaling
for ( a, b, c ) in cell_shift_indices:
new_coordinate_list.append( [ pos_in_origin_cell + np.array( [ a, b, c ] * lattice_shift ) ][0].tolist() )
new_poscar.coordinates = np.array( new_coordinate_list )
return new_poscar
def cell_lengths( self ):
return( ( self.cell.lengths() * self.scaling ).tolist() )
# return [ np.linalg.norm( row ) for row in self.cell.matrix * self.scaling ]
def cell_angles( self ):
return( self.cell.angles() )
# ( a, b, c ) = [ row for row in self.cell.matrix ]
# return [ angle( b, c ), angle( a, c ), angle( a, b ) ]
def to_configuration( self ):
atoms = [ atom.Atom( label, coordinates ) for ( label, coordinates ) in zip( self.labels(), self.fractional_coordinates() ) ]
<|code_end|>
using the current file's imports:
import numpy as np # type: ignore
import sys
import re
import copy
from vasppy import configuration, atom, cell
from vasppy.units import angstrom_to_bohr
from pymatgen import Lattice as pmg_Lattice # type: ignore
from pymatgen import Structure as pmg_Structure # type: ignore
from pymatgen.io.cif import CifWriter # type: ignore
from collections import Counter
from signal import signal, SIGPIPE, SIG_DFL
and any relevant context from other files:
# Path: vasppy/configuration.py
# class Configuration:
# def __init__( self, cell, atoms ):
# def dr( self, atom1, atom2 ):
# def minimum_image_dr( self, atom1, atom2, cutoff=None ):
# def interatomic_distances( self, minimum_image_convention = True ):
# def interatomic_distances_for_atom( self, atom1, minimum_image_convention = True ):
# def atoms_with_label( self, label ):
# def partial_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
# def per_atom_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
#
# Path: vasppy/atom.py
# class Atom:
# def __init__( self, label, r ): # currently assume fractional coordinates
#
# Path: vasppy/cell.py
# def angle( x, y ):
# def rotation_matrix(axis, theta):
# def __init__( self, matrix ):
# def dr( self, r1, r2, cutoff=None ):
# def nearest_image( self, origin, point ):
# def minimum_image( self, r1, r2 ):
# def minimum_image_dr( self, r1, r2, cutoff=None ):
# def lengths( self ):
# def angles( self ):
# def cartesian_to_fractional_coordinates( self, coordinates ):
# def fractional_to_cartesian_coordinates( self, coordinates ):
# def inside_cell( self, r ):
# def volume( self ):
# def unit_vectors( self ):
# def rotate( self, axis, theta ):
# class Cell:
#
# Path: vasppy/units.py
. Output only the next line. | config = configuration.Configuration( cell.Cell( matrix = self.cell.matrix * self.scaling ), atoms ) |
Given snippet: <|code_start|> new_poscar.atoms = [ label + group for label in self.atoms for group in ('a','b') ]
new_poscar.atom_numbers = [ int( num * h * k * l / 2 ) for num in self.atom_numbers for __ in ( 0, 1 )]
else:
new_poscar.atoms = self.atoms
new_poscar.atom_numbers = [ num * h * k * l for num in self.atom_numbers ]
# generate grouped / ungrouped atoms coordinates for supercell
if group:
for row in self.coordinates:
pos_in_origin_cell = row / lattice_scaling
for odd_even in ( 0, 1 ):
for ( a, b, c ) in [ cell_shift for cell_shift in cell_shift_indices if parity(cell_shift) == odd_even ]:
new_coordinate_list.append( [ pos_in_origin_cell + np.array( [ a, b, c ] * lattice_shift ) ][0].tolist() )
else:
for row in self.coordinates:
pos_in_origin_cell = row / lattice_scaling
for ( a, b, c ) in cell_shift_indices:
new_coordinate_list.append( [ pos_in_origin_cell + np.array( [ a, b, c ] * lattice_shift ) ][0].tolist() )
new_poscar.coordinates = np.array( new_coordinate_list )
return new_poscar
def cell_lengths( self ):
return( ( self.cell.lengths() * self.scaling ).tolist() )
# return [ np.linalg.norm( row ) for row in self.cell.matrix * self.scaling ]
def cell_angles( self ):
return( self.cell.angles() )
# ( a, b, c ) = [ row for row in self.cell.matrix ]
# return [ angle( b, c ), angle( a, c ), angle( a, b ) ]
def to_configuration( self ):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy as np # type: ignore
import sys
import re
import copy
from vasppy import configuration, atom, cell
from vasppy.units import angstrom_to_bohr
from pymatgen import Lattice as pmg_Lattice # type: ignore
from pymatgen import Structure as pmg_Structure # type: ignore
from pymatgen.io.cif import CifWriter # type: ignore
from collections import Counter
from signal import signal, SIGPIPE, SIG_DFL
and context:
# Path: vasppy/configuration.py
# class Configuration:
# def __init__( self, cell, atoms ):
# def dr( self, atom1, atom2 ):
# def minimum_image_dr( self, atom1, atom2, cutoff=None ):
# def interatomic_distances( self, minimum_image_convention = True ):
# def interatomic_distances_for_atom( self, atom1, minimum_image_convention = True ):
# def atoms_with_label( self, label ):
# def partial_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
# def per_atom_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
#
# Path: vasppy/atom.py
# class Atom:
# def __init__( self, label, r ): # currently assume fractional coordinates
#
# Path: vasppy/cell.py
# def angle( x, y ):
# def rotation_matrix(axis, theta):
# def __init__( self, matrix ):
# def dr( self, r1, r2, cutoff=None ):
# def nearest_image( self, origin, point ):
# def minimum_image( self, r1, r2 ):
# def minimum_image_dr( self, r1, r2, cutoff=None ):
# def lengths( self ):
# def angles( self ):
# def cartesian_to_fractional_coordinates( self, coordinates ):
# def fractional_to_cartesian_coordinates( self, coordinates ):
# def inside_cell( self, r ):
# def volume( self ):
# def unit_vectors( self ):
# def rotate( self, axis, theta ):
# class Cell:
#
# Path: vasppy/units.py
which might include code, classes, or functions. Output only the next line. | atoms = [ atom.Atom( label, coordinates ) for ( label, coordinates ) in zip( self.labels(), self.fractional_coordinates() ) ] |
Predict the next line for this snippet: <|code_start|>
# Ignore SIG_PIPE and don't throw exceptions on it...
# http://newbebweb.blogspot.co.uk/2012/02/python-head-ioerror-errno-32-broken.html
signal( SIGPIPE, SIG_DFL )
def parity( list ):
return( sum( list )%2 )
def swap_axes( matrix, axes ):
axes_index = { 'x': 0, 'y': 1, 'z': 2 }
matrix[:, [ axes_index[ axes[ 0 ] ], axes_index[ axes[ 1 ] ] ] ] = matrix[:, [ axes_index[ axes[ 1 ] ], axes_index[ axes[ 0 ] ] ] ]
return matrix
class Poscar:
lines_offset = 9
def __init__( self ):
self.title = "Title"
self.scaling = 1.0
<|code_end|>
with the help of current file imports:
import numpy as np # type: ignore
import sys
import re
import copy
from vasppy import configuration, atom, cell
from vasppy.units import angstrom_to_bohr
from pymatgen import Lattice as pmg_Lattice # type: ignore
from pymatgen import Structure as pmg_Structure # type: ignore
from pymatgen.io.cif import CifWriter # type: ignore
from collections import Counter
from signal import signal, SIGPIPE, SIG_DFL
and context from other files:
# Path: vasppy/configuration.py
# class Configuration:
# def __init__( self, cell, atoms ):
# def dr( self, atom1, atom2 ):
# def minimum_image_dr( self, atom1, atom2, cutoff=None ):
# def interatomic_distances( self, minimum_image_convention = True ):
# def interatomic_distances_for_atom( self, atom1, minimum_image_convention = True ):
# def atoms_with_label( self, label ):
# def partial_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
# def per_atom_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
#
# Path: vasppy/atom.py
# class Atom:
# def __init__( self, label, r ): # currently assume fractional coordinates
#
# Path: vasppy/cell.py
# def angle( x, y ):
# def rotation_matrix(axis, theta):
# def __init__( self, matrix ):
# def dr( self, r1, r2, cutoff=None ):
# def nearest_image( self, origin, point ):
# def minimum_image( self, r1, r2 ):
# def minimum_image_dr( self, r1, r2, cutoff=None ):
# def lengths( self ):
# def angles( self ):
# def cartesian_to_fractional_coordinates( self, coordinates ):
# def fractional_to_cartesian_coordinates( self, coordinates ):
# def inside_cell( self, r ):
# def volume( self ):
# def unit_vectors( self ):
# def rotate( self, axis, theta ):
# class Cell:
#
# Path: vasppy/units.py
, which may contain function names, class names, or code. Output only the next line. | self.cell = cell.Cell( np.identity( 3 ) ) |
Given the following code snippet before the placeholder: <|code_start|> print( ''.join( [' {: .10f}'.format( element ) for element in row ] ) )
print( ' '.join( self.atoms ) )
print( ' '.join( [ str(n) for n in self.atom_numbers ] ) )
if opts.get('selective'):
print( 'Selective Dynamics' )
print( coordinate_type )
def write_to( self, filename, coordinate_type='Direct', opts=None ):
if opts is None:
opts = {}
with open( filename, 'w' ) as sys.stdout:
self.output( coordinate_type=coordinate_type, opts=opts )
sys.stdout = sys.__stdout__ # make sure sys.stdout is reset
def output_as_xtl( self ):
print( self.title )
print( "CELL" )
cell_lengths = self.cell_lengths()
cell_angles = self.cell_angles()
cell_data = cell_lengths + cell_angles
print( ''.join( [' {: .8f}'.format( element ) for element in cell_data ] ) )
print( " Symmetry label P1\n\nATOMS\nNAME X Y Z" )
output_opts = { 'label' : True }
self.output_coordinates_only( coordinate_type='Direct', opts = output_opts )
def output_as_cif( self, symprec = None ):
print( CifWriter( self.to_pymatgen_structure(), symprec ) )
def output_as_pimaim( self, to_bohr = True ):
if to_bohr is True:
<|code_end|>
, predict the next line using imports from the current file:
import numpy as np # type: ignore
import sys
import re
import copy
from vasppy import configuration, atom, cell
from vasppy.units import angstrom_to_bohr
from pymatgen import Lattice as pmg_Lattice # type: ignore
from pymatgen import Structure as pmg_Structure # type: ignore
from pymatgen.io.cif import CifWriter # type: ignore
from collections import Counter
from signal import signal, SIGPIPE, SIG_DFL
and context including class names, function names, and sometimes code from other files:
# Path: vasppy/configuration.py
# class Configuration:
# def __init__( self, cell, atoms ):
# def dr( self, atom1, atom2 ):
# def minimum_image_dr( self, atom1, atom2, cutoff=None ):
# def interatomic_distances( self, minimum_image_convention = True ):
# def interatomic_distances_for_atom( self, atom1, minimum_image_convention = True ):
# def atoms_with_label( self, label ):
# def partial_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
# def per_atom_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
#
# Path: vasppy/atom.py
# class Atom:
# def __init__( self, label, r ): # currently assume fractional coordinates
#
# Path: vasppy/cell.py
# def angle( x, y ):
# def rotation_matrix(axis, theta):
# def __init__( self, matrix ):
# def dr( self, r1, r2, cutoff=None ):
# def nearest_image( self, origin, point ):
# def minimum_image( self, r1, r2 ):
# def minimum_image_dr( self, r1, r2, cutoff=None ):
# def lengths( self ):
# def angles( self ):
# def cartesian_to_fractional_coordinates( self, coordinates ):
# def fractional_to_cartesian_coordinates( self, coordinates ):
# def inside_cell( self, r ):
# def volume( self ):
# def unit_vectors( self ):
# def rotate( self, axis, theta ):
# class Cell:
#
# Path: vasppy/units.py
. Output only the next line. | unit_scaling = angstrom_to_bohr |
Given the following code snippet before the placeholder: <|code_start|> A Configuration object stores a single structure.
"""
def __init__( self, cell, atoms ):
self.cell = cell
self.atoms = atoms
def dr( self, atom1, atom2 ):
"""
Calculate the distance between two atoms.
Args:
atom1 (vasppy.Atom): Atom 1.
atom2 (vasppy.Atom): Atom 2.
Returns:
(float): The distance between Atom 1 and Atom 2.
"""
return self.cell.dr( atom1.r, atom2.r )
def minimum_image_dr( self, atom1, atom2, cutoff=None ):
return self.cell.minimum_image_dr( atom1.r, atom2.r, cutoff=cutoff )
def interatomic_distances( self, minimum_image_convention = True ):
return np.array( [ [ self.minimum_image_dr( atom_i, atom_j ) for atom_j in self.atoms ] for atom_i in self.atoms ] )
def interatomic_distances_for_atom( self, atom1, minimum_image_convention = True ):
return np.array( [ self.minimum_image_dr( atom1, atom2 ) for atom2 in self.atoms ] )
def atoms_with_label( self, label ):
<|code_end|>
, predict the next line using imports from the current file:
from vasppy import atom, cell, rdf
import numpy as np # type: ignore
and context including class names, function names, and sometimes code from other files:
# Path: vasppy/atom.py
# class Atom:
# def __init__( self, label, r ): # currently assume fractional coordinates
#
# Path: vasppy/cell.py
# def angle( x, y ):
# def rotation_matrix(axis, theta):
# def __init__( self, matrix ):
# def dr( self, r1, r2, cutoff=None ):
# def nearest_image( self, origin, point ):
# def minimum_image( self, r1, r2 ):
# def minimum_image_dr( self, r1, r2, cutoff=None ):
# def lengths( self ):
# def angles( self ):
# def cartesian_to_fractional_coordinates( self, coordinates ):
# def fractional_to_cartesian_coordinates( self, coordinates ):
# def inside_cell( self, r ):
# def volume( self ):
# def unit_vectors( self ):
# def rotate( self, axis, theta ):
# class Cell:
#
# Path: vasppy/rdf.py
# RDF = TypeVar('RDF', bound='RadialDistributionFunction')
# VHA = TypeVar('VHA', bound='VanHoveAnalysis')
# class RadialDistributionFunction(object):
# class VanHoveAnalysis(object):
# def __init__(self,
# structures: List[Structure],
# indices_i: List[int],
# indices_j: Optional[List[int]] = None,
# nbins: int = 500,
# r_min: float = 0.0,
# r_max: float = 10.0,
# weights: Optional[List[float]] = None) -> None:
# def smeared_rdf(self,
# sigma: float = 0.1) -> np.ndarray:
# def from_species_strings(cls: Type[RDF],
# structures: List[Structure],
# species_i: str,
# species_j: Optional[str] = None,
# **kwargs) -> RDF:
# def __dr_ij(self,
# structure: Structure) -> np.ndarray:
# def __init__(self,
# structures: List[Structure],
# indices: List[int],
# d_steps: int,
# nbins: int = 500,
# r_min: float = 0.0,
# r_max: float = 10.0):
# def self(self,
# sigma: Optional[float] = None) -> np.ndarray:
# def distinct(self,
# sigma: Optional[float] = None) -> np.ndarray:
# def smeared_gsrt(self,
# sigma: float = 0.1) -> np.ndarray:
# def smeared_gdrt(self,
# sigma: float = 0.1) -> np.ndarray:
# def shell_volumes(intervals: np.ndarray) -> np.ndarray:
. Output only the next line. | return filter( lambda atom: atom.label == label, self.atoms ) |
Next line prediction: <|code_start|> def __init__( self, cell, atoms ):
self.cell = cell
self.atoms = atoms
def dr( self, atom1, atom2 ):
"""
Calculate the distance between two atoms.
Args:
atom1 (vasppy.Atom): Atom 1.
atom2 (vasppy.Atom): Atom 2.
Returns:
(float): The distance between Atom 1 and Atom 2.
"""
return self.cell.dr( atom1.r, atom2.r )
def minimum_image_dr( self, atom1, atom2, cutoff=None ):
return self.cell.minimum_image_dr( atom1.r, atom2.r, cutoff=cutoff )
def interatomic_distances( self, minimum_image_convention = True ):
return np.array( [ [ self.minimum_image_dr( atom_i, atom_j ) for atom_j in self.atoms ] for atom_i in self.atoms ] )
def interatomic_distances_for_atom( self, atom1, minimum_image_convention = True ):
return np.array( [ self.minimum_image_dr( atom1, atom2 ) for atom2 in self.atoms ] )
def atoms_with_label( self, label ):
return filter( lambda atom: atom.label == label, self.atoms )
def partial_rdf( self, spec_i, spec_j, max_r, number_of_bins ):
<|code_end|>
. Use current file imports:
(from vasppy import atom, cell, rdf
import numpy as np # type: ignore)
and context including class names, function names, or small code snippets from other files:
# Path: vasppy/atom.py
# class Atom:
# def __init__( self, label, r ): # currently assume fractional coordinates
#
# Path: vasppy/cell.py
# def angle( x, y ):
# def rotation_matrix(axis, theta):
# def __init__( self, matrix ):
# def dr( self, r1, r2, cutoff=None ):
# def nearest_image( self, origin, point ):
# def minimum_image( self, r1, r2 ):
# def minimum_image_dr( self, r1, r2, cutoff=None ):
# def lengths( self ):
# def angles( self ):
# def cartesian_to_fractional_coordinates( self, coordinates ):
# def fractional_to_cartesian_coordinates( self, coordinates ):
# def inside_cell( self, r ):
# def volume( self ):
# def unit_vectors( self ):
# def rotate( self, axis, theta ):
# class Cell:
#
# Path: vasppy/rdf.py
# RDF = TypeVar('RDF', bound='RadialDistributionFunction')
# VHA = TypeVar('VHA', bound='VanHoveAnalysis')
# class RadialDistributionFunction(object):
# class VanHoveAnalysis(object):
# def __init__(self,
# structures: List[Structure],
# indices_i: List[int],
# indices_j: Optional[List[int]] = None,
# nbins: int = 500,
# r_min: float = 0.0,
# r_max: float = 10.0,
# weights: Optional[List[float]] = None) -> None:
# def smeared_rdf(self,
# sigma: float = 0.1) -> np.ndarray:
# def from_species_strings(cls: Type[RDF],
# structures: List[Structure],
# species_i: str,
# species_j: Optional[str] = None,
# **kwargs) -> RDF:
# def __dr_ij(self,
# structure: Structure) -> np.ndarray:
# def __init__(self,
# structures: List[Structure],
# indices: List[int],
# d_steps: int,
# nbins: int = 500,
# r_min: float = 0.0,
# r_max: float = 10.0):
# def self(self,
# sigma: Optional[float] = None) -> np.ndarray:
# def distinct(self,
# sigma: Optional[float] = None) -> np.ndarray:
# def smeared_gsrt(self,
# sigma: float = 0.1) -> np.ndarray:
# def smeared_gdrt(self,
# sigma: float = 0.1) -> np.ndarray:
# def shell_volumes(intervals: np.ndarray) -> np.ndarray:
. Output only the next line. | this_rdf = rdf.Rdf( max_r, number_of_bins ) |
Here is a snippet: <|code_start|>
mock_potcar_string = """foo
End of Dataset
bar
End of Dataset
sds
End of Dataset
"""
mock_potcar_data = { 'PBE': { 'A': '12',
'B': '34' },
'PBE_52': { 'C': '01',
'D': '23' },
'PBE_54': { 'E': '56',
'F': '78' },
'LDA': { 'G': '89' },
'LDA_52': { 'H': '101' },
'LDA_54': { 'I': '202' },
'GGA': { 'J': '303' },
'USPP_GGA': { 'K': '404' },
'USPP_LDA': { 'L': '505' },
'PBE_54r': { 'M': '123' },
'LDA_54r': { 'N': '456' } }
class SummaryInitTestCase( unittest.TestCase ):
@patch('vasppy.summary.VASPMeta')
@patch('vasppy.summary.Summary.parse_vasprun')
def test_summary_is_initialised( self, mock_parse_vasprun, MockVASPMeta ):
MockVASPMeta.from_file = Mock( return_value='foo' )
<|code_end|>
. Write the next line using the current file imports:
import unittest
import numpy as np
import io
import inspect
import os
from unittest.mock import Mock, patch, call
from io import StringIO
from vasppy.summary import (Summary, md5sum, potcar_spec, find_vasp_calculations,
load_vasp_summary)
from vasppy.vaspmeta import VASPMeta
from pymatgen.io.vasp.outputs import Vasprun
and context from other files:
# Path: vasppy/summary.py
# def load_vasp_summary( filename ):
# def potcar_spec(filename, return_hashes=False):
# def find_vasp_calculations():
# def __init__( self, directory='.' ):
# def parse_vasprun( self ):
# def stoich( self ):
# def functional( self ):
# def potcars_are_pbe( self ):
# def output( self, to_print ):
# def print_type( self ):
# def print_title( self ):
# def print_description( self ):
# def print_notes( self ):
# def print_status( self ):
# def print_lreal( self ):
# def print_stoichiometry( self ):
# def print_potcar( self ):
# def print_energy( self ):
# def print_neb_energy( self ):
# def print_version( self ):
# def print_eatom( self ):
# def print_kpoints( self ):
# def print_functional( self ):
# def print_ibrion( self ):
# def print_ediffg( self ):
# def print_encut( self ):
# def print_converged( self ):
# def print_vasprun_md5( self ):
# def print_file_tracking( self ):
# def print_directory( self ):
# def print_plus_u( self ):
# def print_cbm( self ):
# def print_vbm( self ):
# def print_nelect( self ):
# class Summary:
#
# Path: vasppy/vaspmeta.py
# class VASPMeta:
# """
# VASPMeta class for storing additional VASP calculation metadata
# """
#
# def __init__( self, title, description, status, notes=None, type=None, track=None ):
# """
# Initialise a VASPMeta object.
#
# Args:
# title (Str): The title string for this calculation
# description (Str): Long description
# status (Str): Current status of the calculation.
# Expected strings are (to-run, incomplete, finished, dropped)
# notes (:obj:Str, optional): Any additional notes. Defaults to None.
# type (:obj:Str, optional): Can be used to describe the calculation type.
# Defaults to None.
# track (:obj:dict(str: str), optional): An optional dict of pairs of filenames
# for files to track. For each key: value pair, the key is the current filename
# in the directory. The value is the new filename that list of filenames to calculate md5 hashes
# files to calculate hashes for when summarising the calculation output.
# Defaults to None.
#
# Returns:
# None
# """
# self.title = title
# self.description = description
# self.notes = notes
# expected_status = [ 'to-run', 'incomplete', 'finished', 'dropped' ]
# if status not in expected_status:
# raise ValueError(f'Unexpected calculations status: "{status}"'
# f' for calculation {title}')
# self.status = status
# expected_types = [ 'single-point', 'neb' ]
# if type:
# if type not in expected_types:
# raise ValueError(f'Unexpected calculation type: "{type}"'
# f' for calculation {title}')
# self.type = type
# else:
# self.type = None
# self.track = track
#
# @classmethod
# def from_file( cls, filename ):
# """
# Create a VASPMeta object by reading a `vaspmeta.yaml` file
#
# Args:
# filename (Str): filename to read in.
#
# Returns:
# (vasppy.VASPMeta): the VASPMeta object
# """
# with open( filename, 'r' ) as stream:
# data = yaml.load( stream, Loader=yaml.SafeLoader )
# notes = data.get( 'notes' )
# v_type = data.get( 'type' )
# track = data.get( 'track' )
# xargs = {}
# if track:
# if type( track ) is str:
# track = [ track ]
# xargs['track'] = track
# vaspmeta = VASPMeta( data['title'],
# data['description'],
# data['status'],
# notes=notes,
# type=v_type,
# **xargs )
# return vaspmeta
, which may include functions, classes, or code. Output only the next line. | summary = Summary() |
Given snippet: <|code_start|> self.summary.meta.type = 'TYPE'
self.summary.print_type()
self.assertEqual( mock_stdout.getvalue(), 'type: TYPE\n' )
@patch('sys.stdout', new_callable=StringIO)
def test_print_type_if_type_is_not_set( self, mock_stdout ):
self.summary.meta.type = None
self.summary.print_type()
self.assertEqual( mock_stdout.getvalue(), '' )
@patch('sys.stdout', new_callable=StringIO)
def test_print_title( self, mock_stdout ):
self.summary.meta.title = 'TITLE'
self.summary.print_title()
self.assertEqual( mock_stdout.getvalue(), 'title: TITLE\n' )
@patch('sys.stdout', new_callable=StringIO)
def test_print_notes( self, mock_stdout ):
self.summary.meta.notes = 'NOTES'
self.summary.print_notes()
self.assertEqual( mock_stdout.getvalue(), 'notes: NOTES\n' )
@patch('sys.stdout', new_callable=StringIO)
def test_print_notes_handles_empty_notes_attribute( self, mock_stdout ):
self.summary.print_notes()
self.assertEqual( mock_stdout.getvalue(), 'notes: ~\n' )
class SummaryHelperFunctionsTestCase( unittest.TestCase ):
def test_md5sum( self ):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
import numpy as np
import io
import inspect
import os
from unittest.mock import Mock, patch, call
from io import StringIO
from vasppy.summary import (Summary, md5sum, potcar_spec, find_vasp_calculations,
load_vasp_summary)
from vasppy.vaspmeta import VASPMeta
from pymatgen.io.vasp.outputs import Vasprun
and context:
# Path: vasppy/summary.py
# def load_vasp_summary( filename ):
# def potcar_spec(filename, return_hashes=False):
# def find_vasp_calculations():
# def __init__( self, directory='.' ):
# def parse_vasprun( self ):
# def stoich( self ):
# def functional( self ):
# def potcars_are_pbe( self ):
# def output( self, to_print ):
# def print_type( self ):
# def print_title( self ):
# def print_description( self ):
# def print_notes( self ):
# def print_status( self ):
# def print_lreal( self ):
# def print_stoichiometry( self ):
# def print_potcar( self ):
# def print_energy( self ):
# def print_neb_energy( self ):
# def print_version( self ):
# def print_eatom( self ):
# def print_kpoints( self ):
# def print_functional( self ):
# def print_ibrion( self ):
# def print_ediffg( self ):
# def print_encut( self ):
# def print_converged( self ):
# def print_vasprun_md5( self ):
# def print_file_tracking( self ):
# def print_directory( self ):
# def print_plus_u( self ):
# def print_cbm( self ):
# def print_vbm( self ):
# def print_nelect( self ):
# class Summary:
#
# Path: vasppy/vaspmeta.py
# class VASPMeta:
# """
# VASPMeta class for storing additional VASP calculation metadata
# """
#
# def __init__( self, title, description, status, notes=None, type=None, track=None ):
# """
# Initialise a VASPMeta object.
#
# Args:
# title (Str): The title string for this calculation
# description (Str): Long description
# status (Str): Current status of the calculation.
# Expected strings are (to-run, incomplete, finished, dropped)
# notes (:obj:Str, optional): Any additional notes. Defaults to None.
# type (:obj:Str, optional): Can be used to describe the calculation type.
# Defaults to None.
# track (:obj:dict(str: str), optional): An optional dict of pairs of filenames
# for files to track. For each key: value pair, the key is the current filename
# in the directory. The value is the new filename that list of filenames to calculate md5 hashes
# files to calculate hashes for when summarising the calculation output.
# Defaults to None.
#
# Returns:
# None
# """
# self.title = title
# self.description = description
# self.notes = notes
# expected_status = [ 'to-run', 'incomplete', 'finished', 'dropped' ]
# if status not in expected_status:
# raise ValueError(f'Unexpected calculations status: "{status}"'
# f' for calculation {title}')
# self.status = status
# expected_types = [ 'single-point', 'neb' ]
# if type:
# if type not in expected_types:
# raise ValueError(f'Unexpected calculation type: "{type}"'
# f' for calculation {title}')
# self.type = type
# else:
# self.type = None
# self.track = track
#
# @classmethod
# def from_file( cls, filename ):
# """
# Create a VASPMeta object by reading a `vaspmeta.yaml` file
#
# Args:
# filename (Str): filename to read in.
#
# Returns:
# (vasppy.VASPMeta): the VASPMeta object
# """
# with open( filename, 'r' ) as stream:
# data = yaml.load( stream, Loader=yaml.SafeLoader )
# notes = data.get( 'notes' )
# v_type = data.get( 'type' )
# track = data.get( 'track' )
# xargs = {}
# if track:
# if type( track ) is str:
# track = [ track ]
# xargs['track'] = track
# vaspmeta = VASPMeta( data['title'],
# data['description'],
# data['status'],
# notes=notes,
# type=v_type,
# **xargs )
# return vaspmeta
which might include code, classes, or functions. Output only the next line. | self.assertEqual( md5sum('hello\n'), 'b1946ac92492d2347c6235b4d2611184' ) |
Given the following code snippet before the placeholder: <|code_start|> self.assertEqual( mock_stdout.getvalue(), '' )
@patch('sys.stdout', new_callable=StringIO)
def test_print_title( self, mock_stdout ):
self.summary.meta.title = 'TITLE'
self.summary.print_title()
self.assertEqual( mock_stdout.getvalue(), 'title: TITLE\n' )
@patch('sys.stdout', new_callable=StringIO)
def test_print_notes( self, mock_stdout ):
self.summary.meta.notes = 'NOTES'
self.summary.print_notes()
self.assertEqual( mock_stdout.getvalue(), 'notes: NOTES\n' )
@patch('sys.stdout', new_callable=StringIO)
def test_print_notes_handles_empty_notes_attribute( self, mock_stdout ):
self.summary.print_notes()
self.assertEqual( mock_stdout.getvalue(), 'notes: ~\n' )
class SummaryHelperFunctionsTestCase( unittest.TestCase ):
def test_md5sum( self ):
self.assertEqual( md5sum('hello\n'), 'b1946ac92492d2347c6235b4d2611184' )
def test_potcar_spec(self):
mock_potcar_filename = 'POTCAR'
md5sum_return_values = ('12', '56', '23')
with patch('builtins.open', return_value=io.StringIO(mock_potcar_string)) as mock_open:
with patch('vasppy.summary.md5sum', side_effect=md5sum_return_values) as mock_md5sum:
with patch.dict('vasppy.data.potcar_data.potcar_md5sum_data', mock_potcar_data, clear=True):
<|code_end|>
, predict the next line using imports from the current file:
import unittest
import numpy as np
import io
import inspect
import os
from unittest.mock import Mock, patch, call
from io import StringIO
from vasppy.summary import (Summary, md5sum, potcar_spec, find_vasp_calculations,
load_vasp_summary)
from vasppy.vaspmeta import VASPMeta
from pymatgen.io.vasp.outputs import Vasprun
and context including class names, function names, and sometimes code from other files:
# Path: vasppy/summary.py
# def load_vasp_summary( filename ):
# def potcar_spec(filename, return_hashes=False):
# def find_vasp_calculations():
# def __init__( self, directory='.' ):
# def parse_vasprun( self ):
# def stoich( self ):
# def functional( self ):
# def potcars_are_pbe( self ):
# def output( self, to_print ):
# def print_type( self ):
# def print_title( self ):
# def print_description( self ):
# def print_notes( self ):
# def print_status( self ):
# def print_lreal( self ):
# def print_stoichiometry( self ):
# def print_potcar( self ):
# def print_energy( self ):
# def print_neb_energy( self ):
# def print_version( self ):
# def print_eatom( self ):
# def print_kpoints( self ):
# def print_functional( self ):
# def print_ibrion( self ):
# def print_ediffg( self ):
# def print_encut( self ):
# def print_converged( self ):
# def print_vasprun_md5( self ):
# def print_file_tracking( self ):
# def print_directory( self ):
# def print_plus_u( self ):
# def print_cbm( self ):
# def print_vbm( self ):
# def print_nelect( self ):
# class Summary:
#
# Path: vasppy/vaspmeta.py
# class VASPMeta:
# """
# VASPMeta class for storing additional VASP calculation metadata
# """
#
# def __init__( self, title, description, status, notes=None, type=None, track=None ):
# """
# Initialise a VASPMeta object.
#
# Args:
# title (Str): The title string for this calculation
# description (Str): Long description
# status (Str): Current status of the calculation.
# Expected strings are (to-run, incomplete, finished, dropped)
# notes (:obj:Str, optional): Any additional notes. Defaults to None.
# type (:obj:Str, optional): Can be used to describe the calculation type.
# Defaults to None.
# track (:obj:dict(str: str), optional): An optional dict of pairs of filenames
# for files to track. For each key: value pair, the key is the current filename
# in the directory. The value is the new filename that list of filenames to calculate md5 hashes
# files to calculate hashes for when summarising the calculation output.
# Defaults to None.
#
# Returns:
# None
# """
# self.title = title
# self.description = description
# self.notes = notes
# expected_status = [ 'to-run', 'incomplete', 'finished', 'dropped' ]
# if status not in expected_status:
# raise ValueError(f'Unexpected calculations status: "{status}"'
# f' for calculation {title}')
# self.status = status
# expected_types = [ 'single-point', 'neb' ]
# if type:
# if type not in expected_types:
# raise ValueError(f'Unexpected calculation type: "{type}"'
# f' for calculation {title}')
# self.type = type
# else:
# self.type = None
# self.track = track
#
# @classmethod
# def from_file( cls, filename ):
# """
# Create a VASPMeta object by reading a `vaspmeta.yaml` file
#
# Args:
# filename (Str): filename to read in.
#
# Returns:
# (vasppy.VASPMeta): the VASPMeta object
# """
# with open( filename, 'r' ) as stream:
# data = yaml.load( stream, Loader=yaml.SafeLoader )
# notes = data.get( 'notes' )
# v_type = data.get( 'type' )
# track = data.get( 'track' )
# xargs = {}
# if track:
# if type( track ) is str:
# track = [ track ]
# xargs['track'] = track
# vaspmeta = VASPMeta( data['title'],
# data['description'],
# data['status'],
# notes=notes,
# type=v_type,
# **xargs )
# return vaspmeta
. Output only the next line. | p_spec = potcar_spec(mock_potcar_filename) |
Next line prediction: <|code_start|> @patch('vasppy.summary.VASPMeta')
@patch('vasppy.summary.Summary.parse_vasprun')
def test_summary_is_initialised( self, mock_parse_vasprun, MockVASPMeta ):
MockVASPMeta.from_file = Mock( return_value='foo' )
summary = Summary()
self.assertEqual( mock_parse_vasprun.call_count, 1 )
expected_print_methods = [ 'title', 'type', 'status', 'stoichiometry',
'potcar', 'eatom', 'energy', 'k-points',
'functional', 'encut', 'plus_u', 'ediffg',
'ibrion', 'converged', 'version', 'md5',
'directory', 'lreal', 'vbm', 'cbm' ]
for key in expected_print_methods:
self.assertTrue(key in summary.print_methods)
self.assertTrue( inspect.ismethod( summary.print_methods[ key ] ) )
@patch('vasppy.summary.VASPMeta')
@patch('vasppy.summary.Summary.parse_vasprun')
def test_summary_init_raises_filenotfounderror_if_file_is_not_found( self, mock_parse_vasprun, MockVASPMeta ):
MockVASPMeta.from_file = Mock( side_effect=FileNotFoundError )
with self.assertRaises( FileNotFoundError ):
summary = Summary()
class SummaryTestCase( unittest.TestCase ):
@patch('vasppy.summary.VASPMeta')
@patch('vasppy.summary.Summary.parse_vasprun')
def setUp( self, mock_parse_vaspun, MockVASPMeta ):
MockVASPMeta.from_file = Mock( return_value='foo' )
self.summary = Summary()
self.summary.vasprun = Mock( spec=Vasprun )
<|code_end|>
. Use current file imports:
(import unittest
import numpy as np
import io
import inspect
import os
from unittest.mock import Mock, patch, call
from io import StringIO
from vasppy.summary import (Summary, md5sum, potcar_spec, find_vasp_calculations,
load_vasp_summary)
from vasppy.vaspmeta import VASPMeta
from pymatgen.io.vasp.outputs import Vasprun)
and context including class names, function names, or small code snippets from other files:
# Path: vasppy/summary.py
# def load_vasp_summary( filename ):
# def potcar_spec(filename, return_hashes=False):
# def find_vasp_calculations():
# def __init__( self, directory='.' ):
# def parse_vasprun( self ):
# def stoich( self ):
# def functional( self ):
# def potcars_are_pbe( self ):
# def output( self, to_print ):
# def print_type( self ):
# def print_title( self ):
# def print_description( self ):
# def print_notes( self ):
# def print_status( self ):
# def print_lreal( self ):
# def print_stoichiometry( self ):
# def print_potcar( self ):
# def print_energy( self ):
# def print_neb_energy( self ):
# def print_version( self ):
# def print_eatom( self ):
# def print_kpoints( self ):
# def print_functional( self ):
# def print_ibrion( self ):
# def print_ediffg( self ):
# def print_encut( self ):
# def print_converged( self ):
# def print_vasprun_md5( self ):
# def print_file_tracking( self ):
# def print_directory( self ):
# def print_plus_u( self ):
# def print_cbm( self ):
# def print_vbm( self ):
# def print_nelect( self ):
# class Summary:
#
# Path: vasppy/vaspmeta.py
# class VASPMeta:
# """
# VASPMeta class for storing additional VASP calculation metadata
# """
#
# def __init__( self, title, description, status, notes=None, type=None, track=None ):
# """
# Initialise a VASPMeta object.
#
# Args:
# title (Str): The title string for this calculation
# description (Str): Long description
# status (Str): Current status of the calculation.
# Expected strings are (to-run, incomplete, finished, dropped)
# notes (:obj:Str, optional): Any additional notes. Defaults to None.
# type (:obj:Str, optional): Can be used to describe the calculation type.
# Defaults to None.
# track (:obj:dict(str: str), optional): An optional dict of pairs of filenames
# for files to track. For each key: value pair, the key is the current filename
# in the directory. The value is the new filename that list of filenames to calculate md5 hashes
# files to calculate hashes for when summarising the calculation output.
# Defaults to None.
#
# Returns:
# None
# """
# self.title = title
# self.description = description
# self.notes = notes
# expected_status = [ 'to-run', 'incomplete', 'finished', 'dropped' ]
# if status not in expected_status:
# raise ValueError(f'Unexpected calculations status: "{status}"'
# f' for calculation {title}')
# self.status = status
# expected_types = [ 'single-point', 'neb' ]
# if type:
# if type not in expected_types:
# raise ValueError(f'Unexpected calculation type: "{type}"'
# f' for calculation {title}')
# self.type = type
# else:
# self.type = None
# self.track = track
#
# @classmethod
# def from_file( cls, filename ):
# """
# Create a VASPMeta object by reading a `vaspmeta.yaml` file
#
# Args:
# filename (Str): filename to read in.
#
# Returns:
# (vasppy.VASPMeta): the VASPMeta object
# """
# with open( filename, 'r' ) as stream:
# data = yaml.load( stream, Loader=yaml.SafeLoader )
# notes = data.get( 'notes' )
# v_type = data.get( 'type' )
# track = data.get( 'track' )
# xargs = {}
# if track:
# if type( track ) is str:
# track = [ track ]
# xargs['track'] = track
# vaspmeta = VASPMeta( data['title'],
# data['description'],
# data['status'],
# notes=notes,
# type=v_type,
# **xargs )
# return vaspmeta
. Output only the next line. | self.summary.meta = Mock( spec=VASPMeta ) |
Given snippet: <|code_start|>
class AutoKPointsTestCase( unittest.TestCase ):
def test_init_auto_kpoints( self ):
title = 'title'
subdivisions = np.array( [ 2, 2, 2 ] )
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
import numpy as np
from unittest.mock import Mock, patch, mock_open
from vasppy.kpoints import AutoKPoints
and context:
# Path: vasppy/kpoints.py
# class AutoKPoints:
# """
# class for automatic k-point generation data in KPOINTS.
# """
#
# def __init__(self,
# title: str,
# subdivisions: np.ndarray,
# grid_centering: Optional[str] = 'G',
# shift: Optional[np.ndarray] = np.array([0., 0., 0.])) -> None:
# """
# Initialise an AutoKPoints object
#
# Args:
# title (Str): The first line of the file, treated as a comment by VASP.
# subdivisions: (np.Array( Int, Int, Int )): Numbers of subdivisions along each reciprocal lattice vector.
# grid_centering (Str, optional): Specify gamma-centered (G) or the original Monkhorst-Pack scheme (MP). Default is 'G'.
# shift: (np.Array( Float, Float, Float ), optional): Optional shift of the mesh (s_1, s_2, s_3). Default is ( [ 0., 0., 0. ] ).
#
# Returns:
# None
# """
# accepted_grid_centerings = ['G', 'MP']
# if grid_centering not in accepted_grid_centerings:
# raise ValueError
# self.title = title
# self.grid_centering = grid_centering
# self.subdivisions = subdivisions
# self.shift = shift
which might include code, classes, or functions. Output only the next line. | auto_kpoints = AutoKPoints( title, subdivisions ) |
Given the code snippet: <|code_start|>#! /usr/bin/env python3
def parse_command_line_arguments():
# command line arguments
parser = argparse.ArgumentParser()
parser.add_argument( 'xdatcar' )
args = parser.parse_args()
return( args )
def main():
args = parse_command_line_arguments()
<|code_end|>
, generate the next line using the imports in this file:
from vasppy.xdatcar import Xdatcar
import argparse
import copy
and context (functions, classes, or occasionally code) from other files:
# Path: vasppy/xdatcar.py
# class Xdatcar:
#
# lines_offset = 9
#
# def __init__( self ):
# """
# Initialise a Xdatcar object.
#
# Args:
# None
#
# Returns:
# None
# """
# self.poscar = []
# self.poscar.append( Poscar() )
#
# def read_from( self, filename ):
# self.poscar[ 0 ].read_from( filename )
# with open( filename ) as f:
# lines = f.read()
# frame_header = re.compile( '\nDirect configuration=\s+\d+\n' )
# frame_coordinates = [ frame.split("\n") for frame in frame_header.split( lines )[2:] ]
# for f, frame in enumerate( frame_coordinates ):
# self.poscar.append( copy.deepcopy( self.poscar[ 0 ] ) )
# self.poscar[-1].coordinates = np.array( [ [ float( e ) for e in frame.pop(0).split()[0:3] ] for i in range( sum( self.poscar[0].atom_numbers ) ) ] )
. Output only the next line. | xdatcar = Xdatcar() |
Based on the snippet: <|code_start|>
log = logging.getLogger(__name__)
default_message = """Deployed {sha} with MkDocs version: {version}"""
def _is_cwd_git_repo():
try:
proc = subprocess.Popen(
['git', 'rev-parse', '--is-inside-work-tree'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
except FileNotFoundError:
log.error("Could not find git - is it installed and on your path?")
<|code_end|>
, predict the immediate next line with the help of imports:
import logging
import subprocess
import os
import re
import mkdocs
import ghp_import
from packaging import version
from mkdocs.exceptions import Abort
and context (classes, functions, sometimes code) from other files:
# Path: mkdocs/exceptions.py
# class Abort(MkDocsException):
# """Abort the build"""
# def show(self, **kwargs):
# echo(self.format_message())
. Output only the next line. | raise Abort('Deployment Aborted!') |
Predict the next line after this snippet: <|code_start|> temp_dir.cleanup()
def test_load_default_file_prefer_yml(self):
"""
test that `mkdocs.yml` will be loaded when '--config' is not set.
"""
temp_dir = TemporaryDirectory()
config_file1 = open(os.path.join(temp_dir.name, 'mkdocs.yml'), 'w')
config_file2 = open(os.path.join(temp_dir.name, 'mkdocs.yaml'), 'w')
os.mkdir(os.path.join(temp_dir.name, 'docs'))
old_dir = os.getcwd()
try:
os.chdir(temp_dir.name)
config_file1.write("site_name: MkDocs Test1\n")
config_file1.flush()
config_file1.close()
config_file2.write("site_name: MkDocs Test2\n")
config_file2.flush()
config_file2.close()
cfg = base.load_config(config_file=None)
self.assertTrue(isinstance(cfg, base.Config))
self.assertEqual(cfg['site_name'], 'MkDocs Test1')
finally:
os.chdir(old_dir)
temp_dir.cleanup()
def test_load_from_missing_file(self):
<|code_end|>
using the current file's imports:
import os
import tempfile
import unittest
from tempfile import TemporaryDirectory
from mkdocs import exceptions
from mkdocs.config import base, defaults
from mkdocs.config.config_options import BaseConfigOption
and any relevant context from other files:
# Path: mkdocs/exceptions.py
# class MkDocsException(ClickException):
# class Abort(MkDocsException):
# class ConfigurationError(MkDocsException):
# class BuildError(MkDocsException):
# class PluginError(BuildError):
# def show(self, **kwargs):
#
# Path: mkdocs/config/base.py
# class ValidationError(Exception):
# class Config(UserDict):
# def __init__(self, schema, config_file_path=None):
# def set_defaults(self):
# def _validate(self):
# def _pre_validate(self):
# def _post_validate(self):
# def validate(self):
# def load_dict(self, patch):
# def load_file(self, config_file):
# def _open_config_file(config_file):
# def load_config(config_file=None, **kwargs):
#
# Path: mkdocs/config/defaults.py
# def get_schema():
#
# Path: mkdocs/config/config_options.py
# class BaseConfigOption:
#
# def __init__(self):
# self.warnings = []
# self.default = None
#
# def is_required(self):
# return False
#
# def validate(self, value):
# return self.run_validation(value)
#
# def reset_warnings(self):
# self.warnings = []
#
# def pre_validation(self, config, key_name):
# """
# Before all options are validated, perform a pre-validation process.
#
# The pre-validation process method should be implemented by subclasses.
# """
#
# def run_validation(self, value):
# """
# Perform validation for a value.
#
# The run_validation method should be implemented by subclasses.
# """
# return value
#
# def post_validation(self, config, key_name):
# """
# After all options have passed validation, perform a post-validation
# process to do any additional changes dependent on other config values.
#
# The post-validation process method should be implemented by subclasses.
# """
. Output only the next line. | with self.assertRaises(exceptions.ConfigurationError): |
Using the snippet: <|code_start|> """
config_file = tempfile.NamedTemporaryFile('w', delete=False)
try:
config_file.write("site_name: MkDocs Test\n")
config_file.flush()
config_file.close()
finally:
os.remove(config_file.name)
with self.assertRaises(exceptions.ConfigurationError):
base.load_config(config_file=config_file)
def test_load_missing_required(self):
"""
`site_name` is a required setting.
"""
config_file = tempfile.NamedTemporaryFile('w', delete=False)
try:
config_file.write(
"site_dir: output\nsite_uri: https://www.mkdocs.org\n")
config_file.flush()
config_file.close()
with self.assertRaises(exceptions.Abort):
base.load_config(config_file=config_file.name)
finally:
os.remove(config_file.name)
def test_pre_validation_error(self):
<|code_end|>
, determine the next line of code. You have imports:
import os
import tempfile
import unittest
from tempfile import TemporaryDirectory
from mkdocs import exceptions
from mkdocs.config import base, defaults
from mkdocs.config.config_options import BaseConfigOption
and context (class names, function names, or code) available:
# Path: mkdocs/exceptions.py
# class MkDocsException(ClickException):
# class Abort(MkDocsException):
# class ConfigurationError(MkDocsException):
# class BuildError(MkDocsException):
# class PluginError(BuildError):
# def show(self, **kwargs):
#
# Path: mkdocs/config/base.py
# class ValidationError(Exception):
# class Config(UserDict):
# def __init__(self, schema, config_file_path=None):
# def set_defaults(self):
# def _validate(self):
# def _pre_validate(self):
# def _post_validate(self):
# def validate(self):
# def load_dict(self, patch):
# def load_file(self, config_file):
# def _open_config_file(config_file):
# def load_config(config_file=None, **kwargs):
#
# Path: mkdocs/config/defaults.py
# def get_schema():
#
# Path: mkdocs/config/config_options.py
# class BaseConfigOption:
#
# def __init__(self):
# self.warnings = []
# self.default = None
#
# def is_required(self):
# return False
#
# def validate(self, value):
# return self.run_validation(value)
#
# def reset_warnings(self):
# self.warnings = []
#
# def pre_validation(self, config, key_name):
# """
# Before all options are validated, perform a pre-validation process.
#
# The pre-validation process method should be implemented by subclasses.
# """
#
# def run_validation(self, value):
# """
# Perform validation for a value.
#
# The run_validation method should be implemented by subclasses.
# """
# return value
#
# def post_validation(self, config, key_name):
# """
# After all options have passed validation, perform a post-validation
# process to do any additional changes dependent on other config values.
#
# The post-validation process method should be implemented by subclasses.
# """
. Output only the next line. | class InvalidConfigOption(BaseConfigOption): |
Predict the next line for this snippet: <|code_start|> ],
'mkdocs.themes': [
'mkdocs = mkdocs.themes.mkdocs',
'readthedocs = mkdocs.themes.readthedocs',
],
'mkdocs.plugins': [
'search = mkdocs.contrib.search:SearchPlugin',
],
},
classifiers=[
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
'Programming Language :: Python :: 3.9',
'Programming Language :: Python :: 3.10',
'Programming Language :: Python :: 3 :: Only',
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy",
'Topic :: Documentation',
'Topic :: Text Processing',
],
zip_safe=False,
<|code_end|>
with the help of current file imports:
from setuptools import setup
from mkdocs.commands.setup import babel_cmdclass
import re
import os
import sys
and context from other files:
# Path: mkdocs/commands/setup.py
, which may contain function names, class names, or code. Output only the next line. | cmdclass=babel_cmdclass, |
Given the following code snippet before the placeholder: <|code_start|>
BASE_DIR = path.normpath(path.join(path.abspath(path.dirname(__file__)), '../../'))
class ThemeMixinTests(unittest.TestCase):
def test_dict_entry_point(self):
<|code_end|>
, predict the next line using imports from the current file:
import unittest
from distutils.dist import Distribution
from distutils.errors import DistutilsOptionError
from os import path
from mkdocs.commands import babel
and context including class names, function names, and sometimes code from other files:
# Path: mkdocs/commands/babel.py
# DEFAULT_MAPPING_FILE = path.normpath(path.join(
# path.abspath(path.dirname(__file__)), '../themes/babel.cfg'
# ))
# class ThemeMixin:
# class compile_catalog(babel.compile_catalog, ThemeMixin):
# class extract_messages(babel.extract_messages, ThemeMixin):
# class init_catalog(babel.init_catalog, ThemeMixin):
# class update_catalog(babel.update_catalog, ThemeMixin):
# def get_theme_dir(self):
# def initialize_options(self):
# def finalize_options(self):
# def initialize_options(self):
# def finalize_options(self):
# def initialize_options(self):
# def finalize_options(self):
# def initialize_options(self):
# def finalize_options(self):
. Output only the next line. | inst = babel.ThemeMixin() |
Given the code snippet: <|code_start|>#!/usr/bin/env python
class LocalizationTests(unittest.TestCase):
def setUp(self):
self.env = unittest.mock.Mock()
def test_jinja_extension_installed(self):
<|code_end|>
, generate the next line using the imports in this file:
import unittest
from mkdocs.localization import install_translations, parse_locale
from mkdocs.tests.base import tempdir
from mkdocs.config.base import ValidationError
and context (functions, classes, or occasionally code) from other files:
# Path: mkdocs/localization.py
# def install_translations(env, locale, theme_dirs):
# if has_babel:
# env.add_extension('jinja2.ext.i18n')
# translations = _get_merged_translations(theme_dirs, 'locales', locale)
# if translations is not None:
# env.install_gettext_translations(translations)
# else:
# env.install_null_translations()
# if locale.language != 'en':
# log.warning(
# f"No translations could be found for the locale '{locale}'. "
# 'Defaulting to English.'
# )
# else: # pragma: no cover
# # no babel installed, add dummy support for trans/endtrans blocks
# env.add_extension(NoBabelExtension)
# env.install_null_translations()
#
# def parse_locale(locale):
# try:
# return Locale.parse(locale, sep='_')
# except (ValueError, UnknownLocaleError, TypeError) as e:
# raise ValidationError(f'Invalid value for locale: {str(e)}')
#
# Path: mkdocs/tests/base.py
# def tempdir(files=None, **kw):
# """
# A decorator for building a temporary directory with prepopulated files.
#
# The temporary directory and files are created just before the wrapped function is called and are destroyed
# immediately after the wrapped function returns.
#
# The `files` keyword should be a dict of file paths as keys and strings of file content as values.
# If `files` is a list, then each item is assumed to be a path of an empty file. All other
# keywords are passed to `tempfile.TemporaryDirectory` to create the parent directory.
#
# In the following example, two files are created in the temporary directory and then are destroyed when
# the function exits:
#
# @tempdir(files={
# 'foo.txt': 'foo content',
# 'bar.txt': 'bar content'
# })
# def example(self, tdir):
# assert os.path.isfile(os.path.join(tdir, 'foo.txt'))
# pth = os.path.join(tdir, 'bar.txt')
# assert os.path.isfile(pth)
# with open(pth, 'r', encoding='utf-8') as f:
# assert f.read() == 'bar content'
# """
# files = {f: '' for f in files} if isinstance(files, (list, tuple)) else files or {}
#
# kw['prefix'] = 'mkdocs_test-' + kw.get('prefix', '')
#
# def decorator(fn):
# @wraps(fn)
# def wrapper(self, *args):
# with TemporaryDirectory(**kw) as td:
# for path, content in files.items():
# pth = os.path.join(td, path)
# utils.write_file(content.encode(encoding='utf-8'), pth)
# return fn(self, td, *args)
# return wrapper
# return decorator
#
# Path: mkdocs/config/base.py
# class ValidationError(Exception):
# """Raised during the validation process of the config on errors."""
. Output only the next line. | install_translations(self.env, parse_locale('en'), []) |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python
class LocalizationTests(unittest.TestCase):
def setUp(self):
self.env = unittest.mock.Mock()
def test_jinja_extension_installed(self):
<|code_end|>
with the help of current file imports:
import unittest
from mkdocs.localization import install_translations, parse_locale
from mkdocs.tests.base import tempdir
from mkdocs.config.base import ValidationError
and context from other files:
# Path: mkdocs/localization.py
# def install_translations(env, locale, theme_dirs):
# if has_babel:
# env.add_extension('jinja2.ext.i18n')
# translations = _get_merged_translations(theme_dirs, 'locales', locale)
# if translations is not None:
# env.install_gettext_translations(translations)
# else:
# env.install_null_translations()
# if locale.language != 'en':
# log.warning(
# f"No translations could be found for the locale '{locale}'. "
# 'Defaulting to English.'
# )
# else: # pragma: no cover
# # no babel installed, add dummy support for trans/endtrans blocks
# env.add_extension(NoBabelExtension)
# env.install_null_translations()
#
# def parse_locale(locale):
# try:
# return Locale.parse(locale, sep='_')
# except (ValueError, UnknownLocaleError, TypeError) as e:
# raise ValidationError(f'Invalid value for locale: {str(e)}')
#
# Path: mkdocs/tests/base.py
# def tempdir(files=None, **kw):
# """
# A decorator for building a temporary directory with prepopulated files.
#
# The temporary directory and files are created just before the wrapped function is called and are destroyed
# immediately after the wrapped function returns.
#
# The `files` keyword should be a dict of file paths as keys and strings of file content as values.
# If `files` is a list, then each item is assumed to be a path of an empty file. All other
# keywords are passed to `tempfile.TemporaryDirectory` to create the parent directory.
#
# In the following example, two files are created in the temporary directory and then are destroyed when
# the function exits:
#
# @tempdir(files={
# 'foo.txt': 'foo content',
# 'bar.txt': 'bar content'
# })
# def example(self, tdir):
# assert os.path.isfile(os.path.join(tdir, 'foo.txt'))
# pth = os.path.join(tdir, 'bar.txt')
# assert os.path.isfile(pth)
# with open(pth, 'r', encoding='utf-8') as f:
# assert f.read() == 'bar content'
# """
# files = {f: '' for f in files} if isinstance(files, (list, tuple)) else files or {}
#
# kw['prefix'] = 'mkdocs_test-' + kw.get('prefix', '')
#
# def decorator(fn):
# @wraps(fn)
# def wrapper(self, *args):
# with TemporaryDirectory(**kw) as td:
# for path, content in files.items():
# pth = os.path.join(td, path)
# utils.write_file(content.encode(encoding='utf-8'), pth)
# return fn(self, td, *args)
# return wrapper
# return decorator
#
# Path: mkdocs/config/base.py
# class ValidationError(Exception):
# """Raised during the validation process of the config on errors."""
, which may contain function names, class names, or code. Output only the next line. | install_translations(self.env, parse_locale('en'), []) |
Predict the next line after this snippet: <|code_start|>
class LocalizationTests(unittest.TestCase):
def setUp(self):
self.env = unittest.mock.Mock()
def test_jinja_extension_installed(self):
install_translations(self.env, parse_locale('en'), [])
self.env.add_extension.assert_called_once_with('jinja2.ext.i18n')
def test_valid_language(self):
locale = parse_locale('en')
self.assertEqual(locale.language, 'en')
def test_valid_language_territory(self):
locale = parse_locale('en_US')
self.assertEqual(locale.language, 'en')
self.assertEqual(locale.territory, 'US')
self.assertEqual(str(locale), 'en_US')
def test_unknown_locale(self):
self.assertRaises(ValidationError, parse_locale, 'foo')
def test_invalid_locale(self):
self.assertRaises(ValidationError, parse_locale, '42')
<|code_end|>
using the current file's imports:
import unittest
from mkdocs.localization import install_translations, parse_locale
from mkdocs.tests.base import tempdir
from mkdocs.config.base import ValidationError
and any relevant context from other files:
# Path: mkdocs/localization.py
# def install_translations(env, locale, theme_dirs):
# if has_babel:
# env.add_extension('jinja2.ext.i18n')
# translations = _get_merged_translations(theme_dirs, 'locales', locale)
# if translations is not None:
# env.install_gettext_translations(translations)
# else:
# env.install_null_translations()
# if locale.language != 'en':
# log.warning(
# f"No translations could be found for the locale '{locale}'. "
# 'Defaulting to English.'
# )
# else: # pragma: no cover
# # no babel installed, add dummy support for trans/endtrans blocks
# env.add_extension(NoBabelExtension)
# env.install_null_translations()
#
# def parse_locale(locale):
# try:
# return Locale.parse(locale, sep='_')
# except (ValueError, UnknownLocaleError, TypeError) as e:
# raise ValidationError(f'Invalid value for locale: {str(e)}')
#
# Path: mkdocs/tests/base.py
# def tempdir(files=None, **kw):
# """
# A decorator for building a temporary directory with prepopulated files.
#
# The temporary directory and files are created just before the wrapped function is called and are destroyed
# immediately after the wrapped function returns.
#
# The `files` keyword should be a dict of file paths as keys and strings of file content as values.
# If `files` is a list, then each item is assumed to be a path of an empty file. All other
# keywords are passed to `tempfile.TemporaryDirectory` to create the parent directory.
#
# In the following example, two files are created in the temporary directory and then are destroyed when
# the function exits:
#
# @tempdir(files={
# 'foo.txt': 'foo content',
# 'bar.txt': 'bar content'
# })
# def example(self, tdir):
# assert os.path.isfile(os.path.join(tdir, 'foo.txt'))
# pth = os.path.join(tdir, 'bar.txt')
# assert os.path.isfile(pth)
# with open(pth, 'r', encoding='utf-8') as f:
# assert f.read() == 'bar content'
# """
# files = {f: '' for f in files} if isinstance(files, (list, tuple)) else files or {}
#
# kw['prefix'] = 'mkdocs_test-' + kw.get('prefix', '')
#
# def decorator(fn):
# @wraps(fn)
# def wrapper(self, *args):
# with TemporaryDirectory(**kw) as td:
# for path, content in files.items():
# pth = os.path.join(td, path)
# utils.write_file(content.encode(encoding='utf-8'), pth)
# return fn(self, td, *args)
# return wrapper
# return decorator
#
# Path: mkdocs/config/base.py
# class ValidationError(Exception):
# """Raised during the validation process of the config on errors."""
. Output only the next line. | @tempdir() |
Next line prediction: <|code_start|>#!/usr/bin/env python
class LocalizationTests(unittest.TestCase):
def setUp(self):
self.env = unittest.mock.Mock()
def test_jinja_extension_installed(self):
install_translations(self.env, parse_locale('en'), [])
self.env.add_extension.assert_called_once_with('jinja2.ext.i18n')
def test_valid_language(self):
locale = parse_locale('en')
self.assertEqual(locale.language, 'en')
def test_valid_language_territory(self):
locale = parse_locale('en_US')
self.assertEqual(locale.language, 'en')
self.assertEqual(locale.territory, 'US')
self.assertEqual(str(locale), 'en_US')
def test_unknown_locale(self):
<|code_end|>
. Use current file imports:
(import unittest
from mkdocs.localization import install_translations, parse_locale
from mkdocs.tests.base import tempdir
from mkdocs.config.base import ValidationError)
and context including class names, function names, or small code snippets from other files:
# Path: mkdocs/localization.py
# def install_translations(env, locale, theme_dirs):
# if has_babel:
# env.add_extension('jinja2.ext.i18n')
# translations = _get_merged_translations(theme_dirs, 'locales', locale)
# if translations is not None:
# env.install_gettext_translations(translations)
# else:
# env.install_null_translations()
# if locale.language != 'en':
# log.warning(
# f"No translations could be found for the locale '{locale}'. "
# 'Defaulting to English.'
# )
# else: # pragma: no cover
# # no babel installed, add dummy support for trans/endtrans blocks
# env.add_extension(NoBabelExtension)
# env.install_null_translations()
#
# def parse_locale(locale):
# try:
# return Locale.parse(locale, sep='_')
# except (ValueError, UnknownLocaleError, TypeError) as e:
# raise ValidationError(f'Invalid value for locale: {str(e)}')
#
# Path: mkdocs/tests/base.py
# def tempdir(files=None, **kw):
# """
# A decorator for building a temporary directory with prepopulated files.
#
# The temporary directory and files are created just before the wrapped function is called and are destroyed
# immediately after the wrapped function returns.
#
# The `files` keyword should be a dict of file paths as keys and strings of file content as values.
# If `files` is a list, then each item is assumed to be a path of an empty file. All other
# keywords are passed to `tempfile.TemporaryDirectory` to create the parent directory.
#
# In the following example, two files are created in the temporary directory and then are destroyed when
# the function exits:
#
# @tempdir(files={
# 'foo.txt': 'foo content',
# 'bar.txt': 'bar content'
# })
# def example(self, tdir):
# assert os.path.isfile(os.path.join(tdir, 'foo.txt'))
# pth = os.path.join(tdir, 'bar.txt')
# assert os.path.isfile(pth)
# with open(pth, 'r', encoding='utf-8') as f:
# assert f.read() == 'bar content'
# """
# files = {f: '' for f in files} if isinstance(files, (list, tuple)) else files or {}
#
# kw['prefix'] = 'mkdocs_test-' + kw.get('prefix', '')
#
# def decorator(fn):
# @wraps(fn)
# def wrapper(self, *args):
# with TemporaryDirectory(**kw) as td:
# for path, content in files.items():
# pth = os.path.join(td, path)
# utils.write_file(content.encode(encoding='utf-8'), pth)
# return fn(self, td, *args)
# return wrapper
# return decorator
#
# Path: mkdocs/config/base.py
# class ValidationError(Exception):
# """Raised during the validation process of the config on errors."""
. Output only the next line. | self.assertRaises(ValidationError, parse_locale, 'foo') |
Given snippet: <|code_start|>
def get_plugins():
""" Return a dict of all installed Plugins as {name: EntryPoint}. """
plugins = importlib_metadata.entry_points(group='mkdocs.plugins')
# Allow third-party plugins to override core plugins
pluginmap = {}
for plugin in plugins:
if plugin.name in pluginmap and plugin.value.startswith("mkdocs.contrib."):
continue
pluginmap[plugin.name] = plugin
return pluginmap
class BasePlugin:
"""
Plugin base class.
All plugins should subclass this class.
"""
config_scheme = ()
config = {}
def load_config(self, options, config_file_path=None):
""" Load config from a dict of options. Returns a tuple of (errors, warnings)."""
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
import importlib_metadata
from collections import OrderedDict
from mkdocs.config.base import Config
and context:
# Path: mkdocs/config/base.py
# class Config(UserDict):
# """
# MkDocs Configuration dict
#
# This is a fairly simple extension of a standard dictionary. It adds methods
# for running validation on the structure and contents.
# """
#
# def __init__(self, schema, config_file_path=None):
# """
# The schema is a Python dict which maps the config name to a validator.
# """
#
# self._schema = schema
# self._schema_keys = set(dict(schema).keys())
# # Ensure config_file_path is a Unicode string
# if config_file_path is not None and not isinstance(config_file_path, str):
# try:
# # Assume config_file_path is encoded with the file system encoding.
# config_file_path = config_file_path.decode(encoding=sys.getfilesystemencoding())
# except UnicodeDecodeError:
# raise ValidationError("config_file_path is not a Unicode string.")
# self.config_file_path = config_file_path
# self.data = {}
#
# self.user_configs = []
# self.set_defaults()
#
# def set_defaults(self):
# """
# Set the base config by going through each validator and getting the
# default if it has one.
# """
#
# for key, config_option in self._schema:
# self[key] = config_option.default
#
# def _validate(self):
#
# failed, warnings = [], []
#
# for key, config_option in self._schema:
# try:
# value = self.get(key)
# self[key] = config_option.validate(value)
# warnings.extend([(key, w) for w in config_option.warnings])
# config_option.reset_warnings()
# except ValidationError as e:
# failed.append((key, e))
#
# for key in (set(self.keys()) - self._schema_keys):
# warnings.append((
# key, f"Unrecognised configuration name: {key}"
# ))
#
# return failed, warnings
#
# def _pre_validate(self):
#
# failed, warnings = [], []
#
# for key, config_option in self._schema:
# try:
# config_option.pre_validation(self, key_name=key)
# warnings.extend([(key, w) for w in config_option.warnings])
# config_option.reset_warnings()
# except ValidationError as e:
# failed.append((key, e))
#
# return failed, warnings
#
# def _post_validate(self):
#
# failed, warnings = [], []
#
# for key, config_option in self._schema:
# try:
# config_option.post_validation(self, key_name=key)
# warnings.extend([(key, w) for w in config_option.warnings])
# config_option.reset_warnings()
# except ValidationError as e:
# failed.append((key, e))
#
# return failed, warnings
#
# def validate(self):
#
# failed, warnings = self._pre_validate()
#
# run_failed, run_warnings = self._validate()
#
# failed.extend(run_failed)
# warnings.extend(run_warnings)
#
# # Only run the post validation steps if there are no failures, warnings
# # are okay.
# if len(failed) == 0:
# post_failed, post_warnings = self._post_validate()
# failed.extend(post_failed)
# warnings.extend(post_warnings)
#
# return failed, warnings
#
# def load_dict(self, patch):
# """ Load config options from a dictionary. """
#
# if not isinstance(patch, dict):
# raise exceptions.ConfigurationError(
# "The configuration is invalid. The expected type was a key "
# "value mapping (a python dict) but we got an object of type: "
# f"{type(patch)}")
#
# self.user_configs.append(patch)
# self.data.update(patch)
#
# def load_file(self, config_file):
# """ Load config options from the open file descriptor of a YAML file. """
# try:
# return self.load_dict(utils.yaml_load(config_file))
# except YAMLError as e:
# # MkDocs knows and understands ConfigurationErrors
# raise exceptions.ConfigurationError(
# f"MkDocs encountered an error parsing the configuration file: {e}"
# )
which might include code, classes, or functions. Output only the next line. | self.config = Config(schema=self.config_scheme, config_file_path=config_file_path) |
Next line prediction: <|code_start|>
def test_parse_locale_language_territory(self):
locale = Locale.parse('fr_FR', '_')
self.assertEqual(locale.language, 'fr')
self.assertEqual(locale.territory, 'FR')
self.assertEqual(str(locale), 'fr_FR')
def test_parse_locale_language_territory_sep(self):
locale = Locale.parse('fr-FR', '-')
self.assertEqual(locale.language, 'fr')
self.assertEqual(locale.territory, 'FR')
self.assertEqual(str(locale), 'fr_FR')
def test_parse_locale_bad_type(self):
with self.assertRaises(TypeError):
Locale.parse(['list'], '_')
def test_parse_locale_invalid_characters(self):
with self.assertRaises(ValueError):
Locale.parse('42', '_')
def test_parse_locale_bad_format(self):
with self.assertRaises(ValueError):
Locale.parse('en-GB', '_')
def test_parse_locale_bad_format_sep(self):
with self.assertRaises(ValueError):
Locale.parse('en_GB', '-')
def test_parse_locale_unknown_locale(self):
<|code_end|>
. Use current file imports:
(import unittest
from mkdocs.utils.babel_stub import Locale, UnknownLocaleError)
and context including class names, function names, or small code snippets from other files:
# Path: mkdocs/utils/babel_stub.py
# class Locale(NamedTuple):
# language: str
# territory: str = ''
#
# def __str__(self):
# if self.territory:
# return f'{self.language}_{self.territory}'
# return self.language
#
# @classmethod
# def parse(cls, identifier, sep):
# if not isinstance(identifier, str):
# raise TypeError(f"Unexpected value for identifier: '{identifier}'")
# locale = cls(*identifier.split(sep, 1))
# if not all(x in ascii_letters for x in locale.language):
# raise ValueError(f"expected only letters, got '{locale.language}'")
# if len(locale.language) != 2:
# raise UnknownLocaleError(f"unknown locale '{locale.language}'")
# return locale
#
# class UnknownLocaleError(Exception):
# pass
. Output only the next line. | with self.assertRaises(UnknownLocaleError): |
Based on the snippet: <|code_start|>
abs_path = os.path.abspath(os.path.dirname(__file__))
mkdocs_dir = os.path.abspath(os.path.dirname(mkdocs.__file__))
mkdocs_templates_dir = os.path.join(mkdocs_dir, 'templates')
theme_dir = os.path.abspath(os.path.join(mkdocs_dir, 'themes'))
def get_vars(theme):
""" Return dict of theme vars. """
return {k: theme[k] for k in iter(theme)}
class ThemeTests(unittest.TestCase):
def test_simple_theme(self):
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import tempfile
import unittest
import mkdocs
from unittest import mock
from mkdocs.theme import Theme
from mkdocs.localization import parse_locale
and context (classes, functions, sometimes code) from other files:
# Path: mkdocs/theme.py
# class Theme:
# """
# A Theme object.
#
# Keywords:
#
# name: The name of the theme as defined by its entrypoint.
#
# custom_dir: User defined directory for custom templates.
#
# static_templates: A list of templates to render as static pages.
#
# All other keywords are passed as-is and made available as a key/value mapping.
#
# """
#
# def __init__(self, name=None, **user_config):
# self.name = name
# self._vars = {'locale': 'en'}
#
# # MkDocs provided static templates are always included
# package_dir = os.path.abspath(os.path.dirname(__file__))
# mkdocs_templates = os.path.join(package_dir, 'templates')
# self.static_templates = set(os.listdir(mkdocs_templates))
#
# # Build self.dirs from various sources in order of precedence
# self.dirs = []
#
# if 'custom_dir' in user_config:
# self.dirs.append(user_config.pop('custom_dir'))
#
# if self.name:
# self._load_theme_config(name)
#
# # Include templates provided directly by MkDocs (outside any theme)
# self.dirs.append(mkdocs_templates)
#
# # Handle remaining user configs. Override theme configs (if set)
# self.static_templates.update(user_config.pop('static_templates', []))
# self._vars.update(user_config)
#
# # Validate locale and convert to Locale object
# self._vars['locale'] = localization.parse_locale(self._vars['locale'])
#
# def __repr__(self):
# return "{}(name='{}', dirs={}, static_templates={}, {})".format(
# self.__class__.__name__, self.name, self.dirs, list(self.static_templates),
# ', '.join(f'{k}={v!r}' for k, v in self._vars.items())
# )
#
# def __getitem__(self, key):
# return self._vars[key]
#
# def __setitem__(self, key, value):
# self._vars[key] = value
#
# def __contains__(self, item):
# return item in self._vars
#
# def __iter__(self):
# return iter(self._vars)
#
# def _load_theme_config(self, name):
# """ Recursively load theme and any parent themes. """
#
# theme_dir = utils.get_theme_dir(name)
# self.dirs.append(theme_dir)
#
# try:
# file_path = os.path.join(theme_dir, 'mkdocs_theme.yml')
# with open(file_path, 'rb') as f:
# theme_config = utils.yaml_load(f)
# if theme_config is None:
# theme_config = {}
# except OSError as e:
# log.debug(e)
# raise ValidationError(
# f"The theme '{name}' does not appear to have a configuration file. "
# f"Please upgrade to a current version of the theme."
# )
#
# log.debug(f"Loaded theme configuration for '{name}' from '{file_path}': {theme_config}")
#
# parent_theme = theme_config.pop('extends', None)
# if parent_theme:
# themes = utils.get_theme_names()
# if parent_theme not in themes:
# raise ValidationError(
# f"The theme '{name}' inherits from '{parent_theme}', which does not appear to be installed. "
# f"The available installed themes are: {', '.join(themes)}"
# )
# self._load_theme_config(parent_theme)
#
# self.static_templates.update(theme_config.pop('static_templates', []))
# self._vars.update(theme_config)
#
# def get_env(self):
# """ Return a Jinja environment for the theme. """
#
# loader = jinja2.FileSystemLoader(self.dirs)
# # No autoreload because editing a template in the middle of a build is not useful.
# env = jinja2.Environment(loader=loader, auto_reload=False)
# env.filters['url'] = filters.url_filter
# localization.install_translations(env, self._vars['locale'], self.dirs)
# return env
#
# Path: mkdocs/localization.py
# def parse_locale(locale):
# try:
# return Locale.parse(locale, sep='_')
# except (ValueError, UnknownLocaleError, TypeError) as e:
# raise ValidationError(f'Invalid value for locale: {str(e)}')
. Output only the next line. | theme = Theme(name='mkdocs') |
Predict the next line for this snippet: <|code_start|>
abs_path = os.path.abspath(os.path.dirname(__file__))
mkdocs_dir = os.path.abspath(os.path.dirname(mkdocs.__file__))
mkdocs_templates_dir = os.path.join(mkdocs_dir, 'templates')
theme_dir = os.path.abspath(os.path.join(mkdocs_dir, 'themes'))
def get_vars(theme):
""" Return dict of theme vars. """
return {k: theme[k] for k in iter(theme)}
class ThemeTests(unittest.TestCase):
def test_simple_theme(self):
theme = Theme(name='mkdocs')
self.assertEqual(
theme.dirs,
[os.path.join(theme_dir, 'mkdocs'), mkdocs_templates_dir]
)
self.assertEqual(theme.static_templates, {'404.html', 'sitemap.xml'})
self.assertEqual(get_vars(theme), {
<|code_end|>
with the help of current file imports:
import os
import tempfile
import unittest
import mkdocs
from unittest import mock
from mkdocs.theme import Theme
from mkdocs.localization import parse_locale
and context from other files:
# Path: mkdocs/theme.py
# class Theme:
# """
# A Theme object.
#
# Keywords:
#
# name: The name of the theme as defined by its entrypoint.
#
# custom_dir: User defined directory for custom templates.
#
# static_templates: A list of templates to render as static pages.
#
# All other keywords are passed as-is and made available as a key/value mapping.
#
# """
#
# def __init__(self, name=None, **user_config):
# self.name = name
# self._vars = {'locale': 'en'}
#
# # MkDocs provided static templates are always included
# package_dir = os.path.abspath(os.path.dirname(__file__))
# mkdocs_templates = os.path.join(package_dir, 'templates')
# self.static_templates = set(os.listdir(mkdocs_templates))
#
# # Build self.dirs from various sources in order of precedence
# self.dirs = []
#
# if 'custom_dir' in user_config:
# self.dirs.append(user_config.pop('custom_dir'))
#
# if self.name:
# self._load_theme_config(name)
#
# # Include templates provided directly by MkDocs (outside any theme)
# self.dirs.append(mkdocs_templates)
#
# # Handle remaining user configs. Override theme configs (if set)
# self.static_templates.update(user_config.pop('static_templates', []))
# self._vars.update(user_config)
#
# # Validate locale and convert to Locale object
# self._vars['locale'] = localization.parse_locale(self._vars['locale'])
#
# def __repr__(self):
# return "{}(name='{}', dirs={}, static_templates={}, {})".format(
# self.__class__.__name__, self.name, self.dirs, list(self.static_templates),
# ', '.join(f'{k}={v!r}' for k, v in self._vars.items())
# )
#
# def __getitem__(self, key):
# return self._vars[key]
#
# def __setitem__(self, key, value):
# self._vars[key] = value
#
# def __contains__(self, item):
# return item in self._vars
#
# def __iter__(self):
# return iter(self._vars)
#
# def _load_theme_config(self, name):
# """ Recursively load theme and any parent themes. """
#
# theme_dir = utils.get_theme_dir(name)
# self.dirs.append(theme_dir)
#
# try:
# file_path = os.path.join(theme_dir, 'mkdocs_theme.yml')
# with open(file_path, 'rb') as f:
# theme_config = utils.yaml_load(f)
# if theme_config is None:
# theme_config = {}
# except OSError as e:
# log.debug(e)
# raise ValidationError(
# f"The theme '{name}' does not appear to have a configuration file. "
# f"Please upgrade to a current version of the theme."
# )
#
# log.debug(f"Loaded theme configuration for '{name}' from '{file_path}': {theme_config}")
#
# parent_theme = theme_config.pop('extends', None)
# if parent_theme:
# themes = utils.get_theme_names()
# if parent_theme not in themes:
# raise ValidationError(
# f"The theme '{name}' inherits from '{parent_theme}', which does not appear to be installed. "
# f"The available installed themes are: {', '.join(themes)}"
# )
# self._load_theme_config(parent_theme)
#
# self.static_templates.update(theme_config.pop('static_templates', []))
# self._vars.update(theme_config)
#
# def get_env(self):
# """ Return a Jinja environment for the theme. """
#
# loader = jinja2.FileSystemLoader(self.dirs)
# # No autoreload because editing a template in the middle of a build is not useful.
# env = jinja2.Environment(loader=loader, auto_reload=False)
# env.filters['url'] = filters.url_filter
# localization.install_translations(env, self._vars['locale'], self.dirs)
# return env
#
# Path: mkdocs/localization.py
# def parse_locale(locale):
# try:
# return Locale.parse(locale, sep='_')
# except (ValueError, UnknownLocaleError, TypeError) as e:
# raise ValidationError(f'Invalid value for locale: {str(e)}')
, which may contain function names, class names, or code. Output only the next line. | 'locale': parse_locale('en'), |
Using the snippet: <|code_start|>#!/usr/bin/env python
class TableOfContentsTests(unittest.TestCase):
def test_indented_toc(self):
md = dedent("""
# Heading 1
## Heading 2
### Heading 3
""")
expected = dedent("""
Heading 1 - #heading-1
Heading 2 - #heading-2
Heading 3 - #heading-3
""")
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from mkdocs.structure.toc import get_toc
from mkdocs.tests.base import dedent, get_markdown_toc
and context (class names, function names, or code) available:
# Path: mkdocs/structure/toc.py
# def get_toc(toc_tokens):
# toc = [_parse_toc_token(i) for i in toc_tokens]
# # For the table of contents, always mark the first element as active
# if len(toc):
# toc[0].active = True
# return TableOfContents(toc)
#
# Path: mkdocs/tests/base.py
# def dedent(text):
# return textwrap.dedent(text).strip()
#
# def get_markdown_toc(markdown_source):
# """ Return TOC generated by Markdown parser from Markdown source text. """
# md = markdown.Markdown(extensions=['toc'])
# md.convert(markdown_source)
# return md.toc_tokens
. Output only the next line. | toc = get_toc(get_markdown_toc(md)) |
Given the following code snippet before the placeholder: <|code_start|>#!/usr/bin/env python
class TableOfContentsTests(unittest.TestCase):
def test_indented_toc(self):
md = dedent("""
# Heading 1
## Heading 2
### Heading 3
""")
expected = dedent("""
Heading 1 - #heading-1
Heading 2 - #heading-2
Heading 3 - #heading-3
""")
<|code_end|>
, predict the next line using imports from the current file:
import unittest
from mkdocs.structure.toc import get_toc
from mkdocs.tests.base import dedent, get_markdown_toc
and context including class names, function names, and sometimes code from other files:
# Path: mkdocs/structure/toc.py
# def get_toc(toc_tokens):
# toc = [_parse_toc_token(i) for i in toc_tokens]
# # For the table of contents, always mark the first element as active
# if len(toc):
# toc[0].active = True
# return TableOfContents(toc)
#
# Path: mkdocs/tests/base.py
# def dedent(text):
# return textwrap.dedent(text).strip()
#
# def get_markdown_toc(markdown_source):
# """ Return TOC generated by Markdown parser from Markdown source text. """
# md = markdown.Markdown(extensions=['toc'])
# md.convert(markdown_source)
# return md.toc_tokens
. Output only the next line. | toc = get_toc(get_markdown_toc(md)) |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
class CLITests(unittest.TestCase):
def setUp(self):
self.runner = CliRunner()
@mock.patch('mkdocs.commands.serve.serve', autospec=True)
def test_serve_default(self, mock_serve):
result = self.runner.invoke(
<|code_end|>
. Use current file imports:
import unittest
import logging
import io
from unittest import mock
from click.testing import CliRunner
from mkdocs import __main__ as cli
and context (classes, functions, or code) from other files:
# Path: mkdocs/__main__.py
# class ColorFormatter(logging.Formatter):
# class State:
# def format(self, record):
# def __init__(self, log_name='mkdocs', level=logging.INFO):
# def add_options(opts):
# def inner(f):
# def verbose_option(f):
# def callback(ctx, param, value):
# def quiet_option(f):
# def callback(ctx, param, value):
# def cli():
# def serve_command(dev_addr, livereload, watch, **kwargs):
# def build_command(clean, **kwargs):
# def gh_deploy_command(clean, message, remote_branch, remote_name, force, ignore_version, shell, **kwargs):
# def new_command(project_directory):
# PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
# PKG_DIR = os.path.dirname(os.path.abspath(__file__))
. Output only the next line. | cli.cli, ["serve"], catch_exceptions=False) |
Next line prediction: <|code_start|>#!/usr/bin/env python
class NewTests(unittest.TestCase):
def test_new(self):
tempdir = tempfile.mkdtemp()
os.chdir(tempdir)
<|code_end|>
. Use current file imports:
(import tempfile
import unittest
import os
from mkdocs.commands import new)
and context including class names, function names, or small code snippets from other files:
# Path: mkdocs/commands/new.py
# def new(output_dir):
#
# docs_dir = os.path.join(output_dir, 'docs')
# config_path = os.path.join(output_dir, 'mkdocs.yml')
# index_path = os.path.join(docs_dir, 'index.md')
#
# if os.path.exists(config_path):
# log.info('Project already exists.')
# return
#
# if not os.path.exists(output_dir):
# log.info(f'Creating project directory: {output_dir}')
# os.mkdir(output_dir)
#
# log.info(f'Writing config file: {config_path}')
# with open(config_path, 'w', encoding='utf-8') as f:
# f.write(config_text)
#
# if os.path.exists(index_path):
# return
#
# log.info(f'Writing initial docs: {index_path}')
# if not os.path.exists(docs_dir):
# os.mkdir(docs_dir)
# with open(index_path, 'w', encoding='utf-8') as f:
# f.write(index_text)
. Output only the next line. | new.new("myproject") |
Continue the code snippet: <|code_start|>
try:
has_babel = True
except ImportError: # pragma: no cover
has_babel = False
log = logging.getLogger(__name__)
base_path = os.path.dirname(os.path.abspath(__file__))
class NoBabelExtension(InternationalizationExtension): # pragma: no cover
def __init__(self, environment):
Extension.__init__(self, environment)
environment.extend(
install_null_translations=self._install_null,
newstyle_gettext=False,
)
def parse_locale(locale):
try:
return Locale.parse(locale, sep='_')
except (ValueError, UnknownLocaleError, TypeError) as e:
<|code_end|>
. Use current file imports:
import os
import logging
from jinja2.ext import Extension, InternationalizationExtension
from mkdocs.config.base import ValidationError
from babel.core import Locale, UnknownLocaleError
from babel.support import Translations, NullTranslations
from mkdocs.utils.babel_stub import Locale, UnknownLocaleError
and context (classes, functions, or code) from other files:
# Path: mkdocs/config/base.py
# class ValidationError(Exception):
# """Raised during the validation process of the config on errors."""
. Output only the next line. | raise ValidationError(f'Invalid value for locale: {str(e)}') |
Given snippet: <|code_start|> queryset = Project.objects.all()
serializer_class = ProjectSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('slug',)
@detail_route(methods=['post'])
def initialize(self, request, pk=None):
project = self.get_object()
if project.modules.exists() or project.directories.exists():
return Response('The project must be empty', status=status.HTTP_400_BAD_REQUEST)
dir_tree_serializer = DirectoryTreeSerializer(data=request.data, many=True)
if dir_tree_serializer.is_valid():
init_project(project, dir_tree_serializer.validated_data)
return Response({'status': 'Project initialized'})
else:
return Response(dir_tree_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@detail_route(methods=['post'])
def sync_issues(self, request, pk=None):
project = self.get_object()
sync_module_serializer = SyncModuleSerializer(data=request.data, many=True, context={'request': request})
if sync_module_serializer.is_valid():
sync_issues(project, sync_module_serializer.validated_data)
return Response({'status': 'Project synchronized'})
else:
return Response(sync_module_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ModuleViewSet(viewsets.ModelViewSet):
queryset = Module.objects.all()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from rest_framework import viewsets, filters, status
from rest_framework.decorators import detail_route
from rest_framework.response import Response
from daprojects_core.models import Project, Module, IssueKind, Issue, Directory
from daprojects_core.services import init_project, sync_issues
from .serializers import (
ProjectSerializer, ModuleSerializer, IssueKindSerializer, IssueSerializer, DirectorySerializer,
DirectoryTreeSerializer, SyncModuleSerializer
)
and context:
# Path: server/daprojects_api/serializers.py
# class ProjectSerializer(serializers.HyperlinkedModelSerializer):
# first_level_modules = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# read_only=True,
# many=True,
# )
# class Meta:
# model = Project
# fields = ('url', 'name', 'slug', 'description', 'first_level_modules')
#
# class ModuleSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Module
# fields = ('url', 'project', 'parent', 'children', 'name', 'slug', 'path', 'description', 'directories', 'issues')
#
# class IssueKindSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = IssueKind
# fields = ('url', 'name')
#
# class IssueSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Issue
# fields = ('url', 'module', 'file_name', 'file_line', 'description', 'kind', 'size')
#
# class DirectorySerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Directory
# fields = ('url', 'project', 'parent', 'children', 'slug', 'path', 'modules', 'is_leaf_node')
#
# class DirectoryTreeSerializer(serializers.Serializer):
# '''For project directory initialization'''
# name = serializers.CharField(max_length=255)
# size = serializers.IntegerField()
#
# class SyncModuleSerializer(serializers.Serializer):
# '''For issues synchronization'''
# module = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# queryset=Module.objects.all(),
# )
# issues = SyncIssueSerializer(many=True)
# class Meta:
# fields = ('module', 'issues', 'submodules')
which might include code, classes, or functions. Output only the next line. | serializer_class = ModuleSerializer |
Next line prediction: <|code_start|> project = self.get_object()
if project.modules.exists() or project.directories.exists():
return Response('The project must be empty', status=status.HTTP_400_BAD_REQUEST)
dir_tree_serializer = DirectoryTreeSerializer(data=request.data, many=True)
if dir_tree_serializer.is_valid():
init_project(project, dir_tree_serializer.validated_data)
return Response({'status': 'Project initialized'})
else:
return Response(dir_tree_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@detail_route(methods=['post'])
def sync_issues(self, request, pk=None):
project = self.get_object()
sync_module_serializer = SyncModuleSerializer(data=request.data, many=True, context={'request': request})
if sync_module_serializer.is_valid():
sync_issues(project, sync_module_serializer.validated_data)
return Response({'status': 'Project synchronized'})
else:
return Response(sync_module_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ModuleViewSet(viewsets.ModelViewSet):
queryset = Module.objects.all()
serializer_class = ModuleSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('slug', 'project', 'parent')
class IssueKindViewSet(viewsets.ModelViewSet):
queryset = IssueKind.objects.all()
<|code_end|>
. Use current file imports:
(from rest_framework import viewsets, filters, status
from rest_framework.decorators import detail_route
from rest_framework.response import Response
from daprojects_core.models import Project, Module, IssueKind, Issue, Directory
from daprojects_core.services import init_project, sync_issues
from .serializers import (
ProjectSerializer, ModuleSerializer, IssueKindSerializer, IssueSerializer, DirectorySerializer,
DirectoryTreeSerializer, SyncModuleSerializer
))
and context including class names, function names, or small code snippets from other files:
# Path: server/daprojects_api/serializers.py
# class ProjectSerializer(serializers.HyperlinkedModelSerializer):
# first_level_modules = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# read_only=True,
# many=True,
# )
# class Meta:
# model = Project
# fields = ('url', 'name', 'slug', 'description', 'first_level_modules')
#
# class ModuleSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Module
# fields = ('url', 'project', 'parent', 'children', 'name', 'slug', 'path', 'description', 'directories', 'issues')
#
# class IssueKindSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = IssueKind
# fields = ('url', 'name')
#
# class IssueSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Issue
# fields = ('url', 'module', 'file_name', 'file_line', 'description', 'kind', 'size')
#
# class DirectorySerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Directory
# fields = ('url', 'project', 'parent', 'children', 'slug', 'path', 'modules', 'is_leaf_node')
#
# class DirectoryTreeSerializer(serializers.Serializer):
# '''For project directory initialization'''
# name = serializers.CharField(max_length=255)
# size = serializers.IntegerField()
#
# class SyncModuleSerializer(serializers.Serializer):
# '''For issues synchronization'''
# module = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# queryset=Module.objects.all(),
# )
# issues = SyncIssueSerializer(many=True)
# class Meta:
# fields = ('module', 'issues', 'submodules')
. Output only the next line. | serializer_class = IssueKindSerializer |
Given the following code snippet before the placeholder: <|code_start|> init_project(project, dir_tree_serializer.validated_data)
return Response({'status': 'Project initialized'})
else:
return Response(dir_tree_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@detail_route(methods=['post'])
def sync_issues(self, request, pk=None):
project = self.get_object()
sync_module_serializer = SyncModuleSerializer(data=request.data, many=True, context={'request': request})
if sync_module_serializer.is_valid():
sync_issues(project, sync_module_serializer.validated_data)
return Response({'status': 'Project synchronized'})
else:
return Response(sync_module_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ModuleViewSet(viewsets.ModelViewSet):
queryset = Module.objects.all()
serializer_class = ModuleSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('slug', 'project', 'parent')
class IssueKindViewSet(viewsets.ModelViewSet):
queryset = IssueKind.objects.all()
serializer_class = IssueKindSerializer
class IssueViewSet(viewsets.ModelViewSet):
queryset = Issue.objects.all()
<|code_end|>
, predict the next line using imports from the current file:
from rest_framework import viewsets, filters, status
from rest_framework.decorators import detail_route
from rest_framework.response import Response
from daprojects_core.models import Project, Module, IssueKind, Issue, Directory
from daprojects_core.services import init_project, sync_issues
from .serializers import (
ProjectSerializer, ModuleSerializer, IssueKindSerializer, IssueSerializer, DirectorySerializer,
DirectoryTreeSerializer, SyncModuleSerializer
)
and context including class names, function names, and sometimes code from other files:
# Path: server/daprojects_api/serializers.py
# class ProjectSerializer(serializers.HyperlinkedModelSerializer):
# first_level_modules = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# read_only=True,
# many=True,
# )
# class Meta:
# model = Project
# fields = ('url', 'name', 'slug', 'description', 'first_level_modules')
#
# class ModuleSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Module
# fields = ('url', 'project', 'parent', 'children', 'name', 'slug', 'path', 'description', 'directories', 'issues')
#
# class IssueKindSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = IssueKind
# fields = ('url', 'name')
#
# class IssueSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Issue
# fields = ('url', 'module', 'file_name', 'file_line', 'description', 'kind', 'size')
#
# class DirectorySerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Directory
# fields = ('url', 'project', 'parent', 'children', 'slug', 'path', 'modules', 'is_leaf_node')
#
# class DirectoryTreeSerializer(serializers.Serializer):
# '''For project directory initialization'''
# name = serializers.CharField(max_length=255)
# size = serializers.IntegerField()
#
# class SyncModuleSerializer(serializers.Serializer):
# '''For issues synchronization'''
# module = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# queryset=Module.objects.all(),
# )
# issues = SyncIssueSerializer(many=True)
# class Meta:
# fields = ('module', 'issues', 'submodules')
. Output only the next line. | serializer_class = IssueSerializer |
Using the snippet: <|code_start|> project = self.get_object()
sync_module_serializer = SyncModuleSerializer(data=request.data, many=True, context={'request': request})
if sync_module_serializer.is_valid():
sync_issues(project, sync_module_serializer.validated_data)
return Response({'status': 'Project synchronized'})
else:
return Response(sync_module_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ModuleViewSet(viewsets.ModelViewSet):
queryset = Module.objects.all()
serializer_class = ModuleSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('slug', 'project', 'parent')
class IssueKindViewSet(viewsets.ModelViewSet):
queryset = IssueKind.objects.all()
serializer_class = IssueKindSerializer
class IssueViewSet(viewsets.ModelViewSet):
queryset = Issue.objects.all()
serializer_class = IssueSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('module', 'kind', 'size')
class DirectoryViewSet(viewsets.ModelViewSet):
queryset = Directory.objects.all()
<|code_end|>
, determine the next line of code. You have imports:
from rest_framework import viewsets, filters, status
from rest_framework.decorators import detail_route
from rest_framework.response import Response
from daprojects_core.models import Project, Module, IssueKind, Issue, Directory
from daprojects_core.services import init_project, sync_issues
from .serializers import (
ProjectSerializer, ModuleSerializer, IssueKindSerializer, IssueSerializer, DirectorySerializer,
DirectoryTreeSerializer, SyncModuleSerializer
)
and context (class names, function names, or code) available:
# Path: server/daprojects_api/serializers.py
# class ProjectSerializer(serializers.HyperlinkedModelSerializer):
# first_level_modules = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# read_only=True,
# many=True,
# )
# class Meta:
# model = Project
# fields = ('url', 'name', 'slug', 'description', 'first_level_modules')
#
# class ModuleSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Module
# fields = ('url', 'project', 'parent', 'children', 'name', 'slug', 'path', 'description', 'directories', 'issues')
#
# class IssueKindSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = IssueKind
# fields = ('url', 'name')
#
# class IssueSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Issue
# fields = ('url', 'module', 'file_name', 'file_line', 'description', 'kind', 'size')
#
# class DirectorySerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Directory
# fields = ('url', 'project', 'parent', 'children', 'slug', 'path', 'modules', 'is_leaf_node')
#
# class DirectoryTreeSerializer(serializers.Serializer):
# '''For project directory initialization'''
# name = serializers.CharField(max_length=255)
# size = serializers.IntegerField()
#
# class SyncModuleSerializer(serializers.Serializer):
# '''For issues synchronization'''
# module = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# queryset=Module.objects.all(),
# )
# issues = SyncIssueSerializer(many=True)
# class Meta:
# fields = ('module', 'issues', 'submodules')
. Output only the next line. | serializer_class = DirectorySerializer |
Predict the next line after this snippet: <|code_start|>
class ProjectViewSet(viewsets.ModelViewSet):
queryset = Project.objects.all()
serializer_class = ProjectSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('slug',)
@detail_route(methods=['post'])
def initialize(self, request, pk=None):
project = self.get_object()
if project.modules.exists() or project.directories.exists():
return Response('The project must be empty', status=status.HTTP_400_BAD_REQUEST)
<|code_end|>
using the current file's imports:
from rest_framework import viewsets, filters, status
from rest_framework.decorators import detail_route
from rest_framework.response import Response
from daprojects_core.models import Project, Module, IssueKind, Issue, Directory
from daprojects_core.services import init_project, sync_issues
from .serializers import (
ProjectSerializer, ModuleSerializer, IssueKindSerializer, IssueSerializer, DirectorySerializer,
DirectoryTreeSerializer, SyncModuleSerializer
)
and any relevant context from other files:
# Path: server/daprojects_api/serializers.py
# class ProjectSerializer(serializers.HyperlinkedModelSerializer):
# first_level_modules = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# read_only=True,
# many=True,
# )
# class Meta:
# model = Project
# fields = ('url', 'name', 'slug', 'description', 'first_level_modules')
#
# class ModuleSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Module
# fields = ('url', 'project', 'parent', 'children', 'name', 'slug', 'path', 'description', 'directories', 'issues')
#
# class IssueKindSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = IssueKind
# fields = ('url', 'name')
#
# class IssueSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Issue
# fields = ('url', 'module', 'file_name', 'file_line', 'description', 'kind', 'size')
#
# class DirectorySerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Directory
# fields = ('url', 'project', 'parent', 'children', 'slug', 'path', 'modules', 'is_leaf_node')
#
# class DirectoryTreeSerializer(serializers.Serializer):
# '''For project directory initialization'''
# name = serializers.CharField(max_length=255)
# size = serializers.IntegerField()
#
# class SyncModuleSerializer(serializers.Serializer):
# '''For issues synchronization'''
# module = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# queryset=Module.objects.all(),
# )
# issues = SyncIssueSerializer(many=True)
# class Meta:
# fields = ('module', 'issues', 'submodules')
. Output only the next line. | dir_tree_serializer = DirectoryTreeSerializer(data=request.data, many=True) |
Here is a snippet: <|code_start|>
class ProjectViewSet(viewsets.ModelViewSet):
queryset = Project.objects.all()
serializer_class = ProjectSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('slug',)
@detail_route(methods=['post'])
def initialize(self, request, pk=None):
project = self.get_object()
if project.modules.exists() or project.directories.exists():
return Response('The project must be empty', status=status.HTTP_400_BAD_REQUEST)
dir_tree_serializer = DirectoryTreeSerializer(data=request.data, many=True)
if dir_tree_serializer.is_valid():
init_project(project, dir_tree_serializer.validated_data)
return Response({'status': 'Project initialized'})
else:
return Response(dir_tree_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@detail_route(methods=['post'])
def sync_issues(self, request, pk=None):
project = self.get_object()
<|code_end|>
. Write the next line using the current file imports:
from rest_framework import viewsets, filters, status
from rest_framework.decorators import detail_route
from rest_framework.response import Response
from daprojects_core.models import Project, Module, IssueKind, Issue, Directory
from daprojects_core.services import init_project, sync_issues
from .serializers import (
ProjectSerializer, ModuleSerializer, IssueKindSerializer, IssueSerializer, DirectorySerializer,
DirectoryTreeSerializer, SyncModuleSerializer
)
and context from other files:
# Path: server/daprojects_api/serializers.py
# class ProjectSerializer(serializers.HyperlinkedModelSerializer):
# first_level_modules = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# read_only=True,
# many=True,
# )
# class Meta:
# model = Project
# fields = ('url', 'name', 'slug', 'description', 'first_level_modules')
#
# class ModuleSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Module
# fields = ('url', 'project', 'parent', 'children', 'name', 'slug', 'path', 'description', 'directories', 'issues')
#
# class IssueKindSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = IssueKind
# fields = ('url', 'name')
#
# class IssueSerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Issue
# fields = ('url', 'module', 'file_name', 'file_line', 'description', 'kind', 'size')
#
# class DirectorySerializer(serializers.HyperlinkedModelSerializer):
# class Meta:
# model = Directory
# fields = ('url', 'project', 'parent', 'children', 'slug', 'path', 'modules', 'is_leaf_node')
#
# class DirectoryTreeSerializer(serializers.Serializer):
# '''For project directory initialization'''
# name = serializers.CharField(max_length=255)
# size = serializers.IntegerField()
#
# class SyncModuleSerializer(serializers.Serializer):
# '''For issues synchronization'''
# module = serializers.HyperlinkedRelatedField(
# view_name='module-detail',
# queryset=Module.objects.all(),
# )
# issues = SyncIssueSerializer(many=True)
# class Meta:
# fields = ('module', 'issues', 'submodules')
, which may include functions, classes, or code. Output only the next line. | sync_module_serializer = SyncModuleSerializer(data=request.data, many=True, context={'request': request}) |
Given the code snippet: <|code_start|>
class HomeView(TemplateView):
template_name = 'daprojects_webapp/home.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['projects_and_maps'] = [
<|code_end|>
, generate the next line using the imports in this file:
from django.views.generic.base import TemplateView
from django.shortcuts import get_object_or_404
from daprojects_core import models
from .maps import get_map_for_project
and context (functions, classes, or occasionally code) from other files:
# Path: server/daprojects_webapp/maps.py
# def get_map_for_project(project):
# # TODO 1: create a model for project visualization options, and let the user choose the map.
# return _maps[(project.id - 1) % len(_maps)]
. Output only the next line. | (project, get_map_for_project(project)) for project in models.Project.objects.all() |
Given the code snippet: <|code_start|>
class DAProjectsAPI():
def __init__(self, *args, **kwargs):
client = APIClient(*args, **kwargs)
self.projects = Projects(client)
self.modules = Modules(client)
self.issue_kinds = IssueKinds(client)
self.issues = Issues(client)
self.directories = Directories(client)
<|code_end|>
, generate the next line using the imports in this file:
from .client import APIClient, APIResourceList, APIResource
and context (functions, classes, or occasionally code) from other files:
# Path: client/daprojects_python/daprojects_python/client.py
# class APIClient:
# def __init__(self, host_url=None, auth_token=None):
# if not host_url:
# host_url = 'http://localhost:8000'
# if not host_url.startswith('http'):
# host_url = 'http://' + host_url
# self.base_url = host_url.lower().strip() + '/api/v1'
# if not auth_token:
# auth_token = ''
# self.auth_token = auth_token
#
# def list_resources(self, resource_url, resource_class, filters={}):
# response = requests.get(
# resource_url,
# params=filters,
# headers={'Authorization': 'Token {}'.format(self.auth_token)}
# )
# response.raise_for_status()
# return [resource_class(**resource_data) for resource_data in response.json()]
#
# def retrieve_resource(self, resource_url, resource_class):
# response = requests.get(
# resource_url,
# headers={'Authorization': 'Token {}'.format(self.auth_token)}
# )
# response.raise_for_status()
# return resource_class(**response.json())
#
# def resource_action(self, action_url, action_data):
# response = requests.post(
# action_url,
# data=json.dumps(action_data),
# headers={
# 'content-type': 'application/json',
# 'Authorization': 'Token {}'.format(self.auth_token)
# }
# )
# response.raise_for_status()
# return response.json()
#
# class APIResourceList:
# resource_class = APIResource # MAY redefine in subclasses
# resource_path = None # MUST redefine in subclasses
#
# def __init__(self, client):
# self._client = client
#
# def _list_url(self):
# return self._client.base_url + self.resource_path
#
# def _list(self, filters={}):
# return self._client.list_resources(self._list_url(), self.resource_class, filters)
#
# def _find_one(self, filters={}):
# resources = self._client.list_resources(self._list_url(), self.resource_class, filters)
# return resources[0] if resources else None
#
# def _retrieve(self, resource_url):
# return self._client.retrieve_resource(resource_url, self.resource_class)
#
# def _list_action(self, action_name, action_data):
# return self._client.resource_action(self._list_url() + action_name, action_data)
#
# def _resource_action(self, resource_url, action_name, action_data):
# return self._client.resource_action(resource_url + action_name, action_data)
#
# class APIResource:
# def __init__(self, **kwargs):
# for key, value in kwargs.items():
# setattr(self, key, value)
. Output only the next line. | class Projects(APIResourceList): |
Continue the code snippet: <|code_start|>
router = routers.DefaultRouter()
router.register(r'projects', ProjectViewSet)
router.register(r'modules', ModuleViewSet)
<|code_end|>
. Use current file imports:
from django.conf.urls import url, include
from rest_framework import routers
from .views import ProjectViewSet, ModuleViewSet, IssueKindViewSet, IssueViewSet, DirectoryViewSet
and context (classes, functions, or code) from other files:
# Path: server/daprojects_api/views.py
# class ProjectViewSet(viewsets.ModelViewSet):
# queryset = Project.objects.all()
# serializer_class = ProjectSerializer
# filter_backends = (filters.DjangoFilterBackend,)
# filter_fields = ('slug',)
#
# @detail_route(methods=['post'])
# def initialize(self, request, pk=None):
# project = self.get_object()
# if project.modules.exists() or project.directories.exists():
# return Response('The project must be empty', status=status.HTTP_400_BAD_REQUEST)
# dir_tree_serializer = DirectoryTreeSerializer(data=request.data, many=True)
# if dir_tree_serializer.is_valid():
# init_project(project, dir_tree_serializer.validated_data)
# return Response({'status': 'Project initialized'})
# else:
# return Response(dir_tree_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
#
# @detail_route(methods=['post'])
# def sync_issues(self, request, pk=None):
# project = self.get_object()
# sync_module_serializer = SyncModuleSerializer(data=request.data, many=True, context={'request': request})
# if sync_module_serializer.is_valid():
# sync_issues(project, sync_module_serializer.validated_data)
# return Response({'status': 'Project synchronized'})
# else:
# return Response(sync_module_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
#
# class ModuleViewSet(viewsets.ModelViewSet):
# queryset = Module.objects.all()
# serializer_class = ModuleSerializer
# filter_backends = (filters.DjangoFilterBackend,)
# filter_fields = ('slug', 'project', 'parent')
#
# class IssueKindViewSet(viewsets.ModelViewSet):
# queryset = IssueKind.objects.all()
# serializer_class = IssueKindSerializer
#
# class IssueViewSet(viewsets.ModelViewSet):
# queryset = Issue.objects.all()
# serializer_class = IssueSerializer
# filter_backends = (filters.DjangoFilterBackend,)
# filter_fields = ('module', 'kind', 'size')
#
# class DirectoryViewSet(viewsets.ModelViewSet):
# queryset = Directory.objects.all()
# serializer_class = DirectorySerializer
# filter_backends = (filters.DjangoFilterBackend,)
# filter_fields = ('slug', 'project', 'parent')
. Output only the next line. | router.register(r'issue_kinds', IssueKindViewSet) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.