repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
sequence | docstring
stringlengths 3
17.3k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 87
242
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
dakrauth/django-swingtime | swingtime/views.py | event_view | def event_view(
request,
pk,
template='swingtime/event_detail.html',
event_form_class=forms.EventForm,
recurrence_form_class=forms.MultipleOccurrenceForm
):
'''
View an ``Event`` instance and optionally update either the event or its
occurrences.
Context parameters:
``event``
the event keyed by ``pk``
``event_form``
a form object for updating the event
``recurrence_form``
a form object for adding occurrences
'''
event = get_object_or_404(Event, pk=pk)
event_form = recurrence_form = None
if request.method == 'POST':
if '_update' in request.POST:
event_form = event_form_class(request.POST, instance=event)
if event_form.is_valid():
event_form.save(event)
return http.HttpResponseRedirect(request.path)
elif '_add' in request.POST:
recurrence_form = recurrence_form_class(request.POST)
if recurrence_form.is_valid():
recurrence_form.save(event)
return http.HttpResponseRedirect(request.path)
else:
return http.HttpResponseBadRequest('Bad Request')
data = {
'event': event,
'event_form': event_form or event_form_class(instance=event),
'recurrence_form': recurrence_form or recurrence_form_class(
initial={'dtstart': datetime.now()}
)
}
return render(request, template, data) | python | def event_view(
request,
pk,
template='swingtime/event_detail.html',
event_form_class=forms.EventForm,
recurrence_form_class=forms.MultipleOccurrenceForm
):
'''
View an ``Event`` instance and optionally update either the event or its
occurrences.
Context parameters:
``event``
the event keyed by ``pk``
``event_form``
a form object for updating the event
``recurrence_form``
a form object for adding occurrences
'''
event = get_object_or_404(Event, pk=pk)
event_form = recurrence_form = None
if request.method == 'POST':
if '_update' in request.POST:
event_form = event_form_class(request.POST, instance=event)
if event_form.is_valid():
event_form.save(event)
return http.HttpResponseRedirect(request.path)
elif '_add' in request.POST:
recurrence_form = recurrence_form_class(request.POST)
if recurrence_form.is_valid():
recurrence_form.save(event)
return http.HttpResponseRedirect(request.path)
else:
return http.HttpResponseBadRequest('Bad Request')
data = {
'event': event,
'event_form': event_form or event_form_class(instance=event),
'recurrence_form': recurrence_form or recurrence_form_class(
initial={'dtstart': datetime.now()}
)
}
return render(request, template, data) | [
"def",
"event_view",
"(",
"request",
",",
"pk",
",",
"template",
"=",
"'swingtime/event_detail.html'",
",",
"event_form_class",
"=",
"forms",
".",
"EventForm",
",",
"recurrence_form_class",
"=",
"forms",
".",
"MultipleOccurrenceForm",
")",
":",
"event",
"=",
"get_object_or_404",
"(",
"Event",
",",
"pk",
"=",
"pk",
")",
"event_form",
"=",
"recurrence_form",
"=",
"None",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"if",
"'_update'",
"in",
"request",
".",
"POST",
":",
"event_form",
"=",
"event_form_class",
"(",
"request",
".",
"POST",
",",
"instance",
"=",
"event",
")",
"if",
"event_form",
".",
"is_valid",
"(",
")",
":",
"event_form",
".",
"save",
"(",
"event",
")",
"return",
"http",
".",
"HttpResponseRedirect",
"(",
"request",
".",
"path",
")",
"elif",
"'_add'",
"in",
"request",
".",
"POST",
":",
"recurrence_form",
"=",
"recurrence_form_class",
"(",
"request",
".",
"POST",
")",
"if",
"recurrence_form",
".",
"is_valid",
"(",
")",
":",
"recurrence_form",
".",
"save",
"(",
"event",
")",
"return",
"http",
".",
"HttpResponseRedirect",
"(",
"request",
".",
"path",
")",
"else",
":",
"return",
"http",
".",
"HttpResponseBadRequest",
"(",
"'Bad Request'",
")",
"data",
"=",
"{",
"'event'",
":",
"event",
",",
"'event_form'",
":",
"event_form",
"or",
"event_form_class",
"(",
"instance",
"=",
"event",
")",
",",
"'recurrence_form'",
":",
"recurrence_form",
"or",
"recurrence_form_class",
"(",
"initial",
"=",
"{",
"'dtstart'",
":",
"datetime",
".",
"now",
"(",
")",
"}",
")",
"}",
"return",
"render",
"(",
"request",
",",
"template",
",",
"data",
")"
] | View an ``Event`` instance and optionally update either the event or its
occurrences.
Context parameters:
``event``
the event keyed by ``pk``
``event_form``
a form object for updating the event
``recurrence_form``
a form object for adding occurrences | [
"View",
"an",
"Event",
"instance",
"and",
"optionally",
"update",
"either",
"the",
"event",
"or",
"its",
"occurrences",
"."
] | d1cdd449bd5c6895c3ff182fd890c4d3452943fe | https://github.com/dakrauth/django-swingtime/blob/d1cdd449bd5c6895c3ff182fd890c4d3452943fe/swingtime/views.py#L43-L88 | train |
dakrauth/django-swingtime | swingtime/views.py | occurrence_view | def occurrence_view(
request,
event_pk,
pk,
template='swingtime/occurrence_detail.html',
form_class=forms.SingleOccurrenceForm
):
'''
View a specific occurrence and optionally handle any updates.
Context parameters:
``occurrence``
the occurrence object keyed by ``pk``
``form``
a form object for updating the occurrence
'''
occurrence = get_object_or_404(Occurrence, pk=pk, event__pk=event_pk)
if request.method == 'POST':
form = form_class(request.POST, instance=occurrence)
if form.is_valid():
form.save()
return http.HttpResponseRedirect(request.path)
else:
form = form_class(instance=occurrence)
return render(request, template, {'occurrence': occurrence, 'form': form}) | python | def occurrence_view(
request,
event_pk,
pk,
template='swingtime/occurrence_detail.html',
form_class=forms.SingleOccurrenceForm
):
'''
View a specific occurrence and optionally handle any updates.
Context parameters:
``occurrence``
the occurrence object keyed by ``pk``
``form``
a form object for updating the occurrence
'''
occurrence = get_object_or_404(Occurrence, pk=pk, event__pk=event_pk)
if request.method == 'POST':
form = form_class(request.POST, instance=occurrence)
if form.is_valid():
form.save()
return http.HttpResponseRedirect(request.path)
else:
form = form_class(instance=occurrence)
return render(request, template, {'occurrence': occurrence, 'form': form}) | [
"def",
"occurrence_view",
"(",
"request",
",",
"event_pk",
",",
"pk",
",",
"template",
"=",
"'swingtime/occurrence_detail.html'",
",",
"form_class",
"=",
"forms",
".",
"SingleOccurrenceForm",
")",
":",
"occurrence",
"=",
"get_object_or_404",
"(",
"Occurrence",
",",
"pk",
"=",
"pk",
",",
"event__pk",
"=",
"event_pk",
")",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"form",
"=",
"form_class",
"(",
"request",
".",
"POST",
",",
"instance",
"=",
"occurrence",
")",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"form",
".",
"save",
"(",
")",
"return",
"http",
".",
"HttpResponseRedirect",
"(",
"request",
".",
"path",
")",
"else",
":",
"form",
"=",
"form_class",
"(",
"instance",
"=",
"occurrence",
")",
"return",
"render",
"(",
"request",
",",
"template",
",",
"{",
"'occurrence'",
":",
"occurrence",
",",
"'form'",
":",
"form",
"}",
")"
] | View a specific occurrence and optionally handle any updates.
Context parameters:
``occurrence``
the occurrence object keyed by ``pk``
``form``
a form object for updating the occurrence | [
"View",
"a",
"specific",
"occurrence",
"and",
"optionally",
"handle",
"any",
"updates",
"."
] | d1cdd449bd5c6895c3ff182fd890c4d3452943fe | https://github.com/dakrauth/django-swingtime/blob/d1cdd449bd5c6895c3ff182fd890c4d3452943fe/swingtime/views.py#L91-L118 | train |
dakrauth/django-swingtime | swingtime/views.py | add_event | def add_event(
request,
template='swingtime/add_event.html',
event_form_class=forms.EventForm,
recurrence_form_class=forms.MultipleOccurrenceForm
):
'''
Add a new ``Event`` instance and 1 or more associated ``Occurrence``s.
Context parameters:
``dtstart``
a datetime.datetime object representing the GET request value if present,
otherwise None
``event_form``
a form object for updating the event
``recurrence_form``
a form object for adding occurrences
'''
dtstart = None
if request.method == 'POST':
event_form = event_form_class(request.POST)
recurrence_form = recurrence_form_class(request.POST)
if event_form.is_valid() and recurrence_form.is_valid():
event = event_form.save()
recurrence_form.save(event)
return http.HttpResponseRedirect(event.get_absolute_url())
else:
if 'dtstart' in request.GET:
try:
dtstart = parser.parse(request.GET['dtstart'])
except(TypeError, ValueError) as exc:
# TODO: A badly formatted date is passed to add_event
logging.warning(exc)
dtstart = dtstart or datetime.now()
event_form = event_form_class()
recurrence_form = recurrence_form_class(initial={'dtstart': dtstart})
return render(
request,
template,
{'dtstart': dtstart, 'event_form': event_form, 'recurrence_form': recurrence_form}
) | python | def add_event(
request,
template='swingtime/add_event.html',
event_form_class=forms.EventForm,
recurrence_form_class=forms.MultipleOccurrenceForm
):
'''
Add a new ``Event`` instance and 1 or more associated ``Occurrence``s.
Context parameters:
``dtstart``
a datetime.datetime object representing the GET request value if present,
otherwise None
``event_form``
a form object for updating the event
``recurrence_form``
a form object for adding occurrences
'''
dtstart = None
if request.method == 'POST':
event_form = event_form_class(request.POST)
recurrence_form = recurrence_form_class(request.POST)
if event_form.is_valid() and recurrence_form.is_valid():
event = event_form.save()
recurrence_form.save(event)
return http.HttpResponseRedirect(event.get_absolute_url())
else:
if 'dtstart' in request.GET:
try:
dtstart = parser.parse(request.GET['dtstart'])
except(TypeError, ValueError) as exc:
# TODO: A badly formatted date is passed to add_event
logging.warning(exc)
dtstart = dtstart or datetime.now()
event_form = event_form_class()
recurrence_form = recurrence_form_class(initial={'dtstart': dtstart})
return render(
request,
template,
{'dtstart': dtstart, 'event_form': event_form, 'recurrence_form': recurrence_form}
) | [
"def",
"add_event",
"(",
"request",
",",
"template",
"=",
"'swingtime/add_event.html'",
",",
"event_form_class",
"=",
"forms",
".",
"EventForm",
",",
"recurrence_form_class",
"=",
"forms",
".",
"MultipleOccurrenceForm",
")",
":",
"dtstart",
"=",
"None",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"event_form",
"=",
"event_form_class",
"(",
"request",
".",
"POST",
")",
"recurrence_form",
"=",
"recurrence_form_class",
"(",
"request",
".",
"POST",
")",
"if",
"event_form",
".",
"is_valid",
"(",
")",
"and",
"recurrence_form",
".",
"is_valid",
"(",
")",
":",
"event",
"=",
"event_form",
".",
"save",
"(",
")",
"recurrence_form",
".",
"save",
"(",
"event",
")",
"return",
"http",
".",
"HttpResponseRedirect",
"(",
"event",
".",
"get_absolute_url",
"(",
")",
")",
"else",
":",
"if",
"'dtstart'",
"in",
"request",
".",
"GET",
":",
"try",
":",
"dtstart",
"=",
"parser",
".",
"parse",
"(",
"request",
".",
"GET",
"[",
"'dtstart'",
"]",
")",
"except",
"(",
"TypeError",
",",
"ValueError",
")",
"as",
"exc",
":",
"# TODO: A badly formatted date is passed to add_event",
"logging",
".",
"warning",
"(",
"exc",
")",
"dtstart",
"=",
"dtstart",
"or",
"datetime",
".",
"now",
"(",
")",
"event_form",
"=",
"event_form_class",
"(",
")",
"recurrence_form",
"=",
"recurrence_form_class",
"(",
"initial",
"=",
"{",
"'dtstart'",
":",
"dtstart",
"}",
")",
"return",
"render",
"(",
"request",
",",
"template",
",",
"{",
"'dtstart'",
":",
"dtstart",
",",
"'event_form'",
":",
"event_form",
",",
"'recurrence_form'",
":",
"recurrence_form",
"}",
")"
] | Add a new ``Event`` instance and 1 or more associated ``Occurrence``s.
Context parameters:
``dtstart``
a datetime.datetime object representing the GET request value if present,
otherwise None
``event_form``
a form object for updating the event
``recurrence_form``
a form object for adding occurrences | [
"Add",
"a",
"new",
"Event",
"instance",
"and",
"1",
"or",
"more",
"associated",
"Occurrence",
"s",
"."
] | d1cdd449bd5c6895c3ff182fd890c4d3452943fe | https://github.com/dakrauth/django-swingtime/blob/d1cdd449bd5c6895c3ff182fd890c4d3452943fe/swingtime/views.py#L121-L168 | train |
dakrauth/django-swingtime | swingtime/views.py | _datetime_view | def _datetime_view(
request,
template,
dt,
timeslot_factory=None,
items=None,
params=None
):
'''
Build a time slot grid representation for the given datetime ``dt``. See
utils.create_timeslot_table documentation for items and params.
Context parameters:
``day``
the specified datetime value (dt)
``next_day``
day + 1 day
``prev_day``
day - 1 day
``timeslots``
time slot grid of (time, cells) rows
'''
timeslot_factory = timeslot_factory or utils.create_timeslot_table
params = params or {}
return render(request, template, {
'day': dt,
'next_day': dt + timedelta(days=+1),
'prev_day': dt + timedelta(days=-1),
'timeslots': timeslot_factory(dt, items, **params)
}) | python | def _datetime_view(
request,
template,
dt,
timeslot_factory=None,
items=None,
params=None
):
'''
Build a time slot grid representation for the given datetime ``dt``. See
utils.create_timeslot_table documentation for items and params.
Context parameters:
``day``
the specified datetime value (dt)
``next_day``
day + 1 day
``prev_day``
day - 1 day
``timeslots``
time slot grid of (time, cells) rows
'''
timeslot_factory = timeslot_factory or utils.create_timeslot_table
params = params or {}
return render(request, template, {
'day': dt,
'next_day': dt + timedelta(days=+1),
'prev_day': dt + timedelta(days=-1),
'timeslots': timeslot_factory(dt, items, **params)
}) | [
"def",
"_datetime_view",
"(",
"request",
",",
"template",
",",
"dt",
",",
"timeslot_factory",
"=",
"None",
",",
"items",
"=",
"None",
",",
"params",
"=",
"None",
")",
":",
"timeslot_factory",
"=",
"timeslot_factory",
"or",
"utils",
".",
"create_timeslot_table",
"params",
"=",
"params",
"or",
"{",
"}",
"return",
"render",
"(",
"request",
",",
"template",
",",
"{",
"'day'",
":",
"dt",
",",
"'next_day'",
":",
"dt",
"+",
"timedelta",
"(",
"days",
"=",
"+",
"1",
")",
",",
"'prev_day'",
":",
"dt",
"+",
"timedelta",
"(",
"days",
"=",
"-",
"1",
")",
",",
"'timeslots'",
":",
"timeslot_factory",
"(",
"dt",
",",
"items",
",",
"*",
"*",
"params",
")",
"}",
")"
] | Build a time slot grid representation for the given datetime ``dt``. See
utils.create_timeslot_table documentation for items and params.
Context parameters:
``day``
the specified datetime value (dt)
``next_day``
day + 1 day
``prev_day``
day - 1 day
``timeslots``
time slot grid of (time, cells) rows | [
"Build",
"a",
"time",
"slot",
"grid",
"representation",
"for",
"the",
"given",
"datetime",
"dt",
".",
"See",
"utils",
".",
"create_timeslot_table",
"documentation",
"for",
"items",
"and",
"params",
"."
] | d1cdd449bd5c6895c3ff182fd890c4d3452943fe | https://github.com/dakrauth/django-swingtime/blob/d1cdd449bd5c6895c3ff182fd890c4d3452943fe/swingtime/views.py#L171-L206 | train |
dakrauth/django-swingtime | swingtime/views.py | month_view | def month_view(
request,
year,
month,
template='swingtime/monthly_view.html',
queryset=None
):
'''
Render a tradional calendar grid view with temporal navigation variables.
Context parameters:
``today``
the current datetime.datetime value
``calendar``
a list of rows containing (day, items) cells, where day is the day of
the month integer and items is a (potentially empty) list of occurrence
for the day
``this_month``
a datetime.datetime representing the first day of the month
``next_month``
this_month + 1 month
``last_month``
this_month - 1 month
'''
year, month = int(year), int(month)
cal = calendar.monthcalendar(year, month)
dtstart = datetime(year, month, 1)
last_day = max(cal[-1])
dtend = datetime(year, month, last_day)
# TODO Whether to include those occurrences that started in the previous
# month but end in this month?
queryset = queryset._clone() if queryset is not None else Occurrence.objects.select_related()
occurrences = queryset.filter(start_time__year=year, start_time__month=month)
def start_day(o):
return o.start_time.day
by_day = dict([(dt, list(o)) for dt, o in itertools.groupby(occurrences, start_day)])
data = {
'today': datetime.now(),
'calendar': [[(d, by_day.get(d, [])) for d in row] for row in cal],
'this_month': dtstart,
'next_month': dtstart + timedelta(days=+last_day),
'last_month': dtstart + timedelta(days=-1),
}
return render(request, template, data) | python | def month_view(
request,
year,
month,
template='swingtime/monthly_view.html',
queryset=None
):
'''
Render a tradional calendar grid view with temporal navigation variables.
Context parameters:
``today``
the current datetime.datetime value
``calendar``
a list of rows containing (day, items) cells, where day is the day of
the month integer and items is a (potentially empty) list of occurrence
for the day
``this_month``
a datetime.datetime representing the first day of the month
``next_month``
this_month + 1 month
``last_month``
this_month - 1 month
'''
year, month = int(year), int(month)
cal = calendar.monthcalendar(year, month)
dtstart = datetime(year, month, 1)
last_day = max(cal[-1])
dtend = datetime(year, month, last_day)
# TODO Whether to include those occurrences that started in the previous
# month but end in this month?
queryset = queryset._clone() if queryset is not None else Occurrence.objects.select_related()
occurrences = queryset.filter(start_time__year=year, start_time__month=month)
def start_day(o):
return o.start_time.day
by_day = dict([(dt, list(o)) for dt, o in itertools.groupby(occurrences, start_day)])
data = {
'today': datetime.now(),
'calendar': [[(d, by_day.get(d, [])) for d in row] for row in cal],
'this_month': dtstart,
'next_month': dtstart + timedelta(days=+last_day),
'last_month': dtstart + timedelta(days=-1),
}
return render(request, template, data) | [
"def",
"month_view",
"(",
"request",
",",
"year",
",",
"month",
",",
"template",
"=",
"'swingtime/monthly_view.html'",
",",
"queryset",
"=",
"None",
")",
":",
"year",
",",
"month",
"=",
"int",
"(",
"year",
")",
",",
"int",
"(",
"month",
")",
"cal",
"=",
"calendar",
".",
"monthcalendar",
"(",
"year",
",",
"month",
")",
"dtstart",
"=",
"datetime",
"(",
"year",
",",
"month",
",",
"1",
")",
"last_day",
"=",
"max",
"(",
"cal",
"[",
"-",
"1",
"]",
")",
"dtend",
"=",
"datetime",
"(",
"year",
",",
"month",
",",
"last_day",
")",
"# TODO Whether to include those occurrences that started in the previous",
"# month but end in this month?",
"queryset",
"=",
"queryset",
".",
"_clone",
"(",
")",
"if",
"queryset",
"is",
"not",
"None",
"else",
"Occurrence",
".",
"objects",
".",
"select_related",
"(",
")",
"occurrences",
"=",
"queryset",
".",
"filter",
"(",
"start_time__year",
"=",
"year",
",",
"start_time__month",
"=",
"month",
")",
"def",
"start_day",
"(",
"o",
")",
":",
"return",
"o",
".",
"start_time",
".",
"day",
"by_day",
"=",
"dict",
"(",
"[",
"(",
"dt",
",",
"list",
"(",
"o",
")",
")",
"for",
"dt",
",",
"o",
"in",
"itertools",
".",
"groupby",
"(",
"occurrences",
",",
"start_day",
")",
"]",
")",
"data",
"=",
"{",
"'today'",
":",
"datetime",
".",
"now",
"(",
")",
",",
"'calendar'",
":",
"[",
"[",
"(",
"d",
",",
"by_day",
".",
"get",
"(",
"d",
",",
"[",
"]",
")",
")",
"for",
"d",
"in",
"row",
"]",
"for",
"row",
"in",
"cal",
"]",
",",
"'this_month'",
":",
"dtstart",
",",
"'next_month'",
":",
"dtstart",
"+",
"timedelta",
"(",
"days",
"=",
"+",
"last_day",
")",
",",
"'last_month'",
":",
"dtstart",
"+",
"timedelta",
"(",
"days",
"=",
"-",
"1",
")",
",",
"}",
"return",
"render",
"(",
"request",
",",
"template",
",",
"data",
")"
] | Render a tradional calendar grid view with temporal navigation variables.
Context parameters:
``today``
the current datetime.datetime value
``calendar``
a list of rows containing (day, items) cells, where day is the day of
the month integer and items is a (potentially empty) list of occurrence
for the day
``this_month``
a datetime.datetime representing the first day of the month
``next_month``
this_month + 1 month
``last_month``
this_month - 1 month | [
"Render",
"a",
"tradional",
"calendar",
"grid",
"view",
"with",
"temporal",
"navigation",
"variables",
"."
] | d1cdd449bd5c6895c3ff182fd890c4d3452943fe | https://github.com/dakrauth/django-swingtime/blob/d1cdd449bd5c6895c3ff182fd890c4d3452943fe/swingtime/views.py#L270-L323 | train |
p1c2u/openapi-core | openapi_core/schema/schemas/models.py | Schema.cast | def cast(self, value, custom_formatters=None, strict=True):
"""Cast value to schema type"""
if value is None:
if not self.nullable:
raise InvalidSchemaValue("Null value for non-nullable schema", value, self.type)
return self.default
cast_mapping = self.get_cast_mapping(
custom_formatters=custom_formatters, strict=strict)
if self.type is not SchemaType.STRING and value == '':
return None
cast_callable = cast_mapping[self.type]
try:
return cast_callable(value)
except ValueError:
raise InvalidSchemaValue(
"Failed to cast value {value} to type {type}", value, self.type) | python | def cast(self, value, custom_formatters=None, strict=True):
"""Cast value to schema type"""
if value is None:
if not self.nullable:
raise InvalidSchemaValue("Null value for non-nullable schema", value, self.type)
return self.default
cast_mapping = self.get_cast_mapping(
custom_formatters=custom_formatters, strict=strict)
if self.type is not SchemaType.STRING and value == '':
return None
cast_callable = cast_mapping[self.type]
try:
return cast_callable(value)
except ValueError:
raise InvalidSchemaValue(
"Failed to cast value {value} to type {type}", value, self.type) | [
"def",
"cast",
"(",
"self",
",",
"value",
",",
"custom_formatters",
"=",
"None",
",",
"strict",
"=",
"True",
")",
":",
"if",
"value",
"is",
"None",
":",
"if",
"not",
"self",
".",
"nullable",
":",
"raise",
"InvalidSchemaValue",
"(",
"\"Null value for non-nullable schema\"",
",",
"value",
",",
"self",
".",
"type",
")",
"return",
"self",
".",
"default",
"cast_mapping",
"=",
"self",
".",
"get_cast_mapping",
"(",
"custom_formatters",
"=",
"custom_formatters",
",",
"strict",
"=",
"strict",
")",
"if",
"self",
".",
"type",
"is",
"not",
"SchemaType",
".",
"STRING",
"and",
"value",
"==",
"''",
":",
"return",
"None",
"cast_callable",
"=",
"cast_mapping",
"[",
"self",
".",
"type",
"]",
"try",
":",
"return",
"cast_callable",
"(",
"value",
")",
"except",
"ValueError",
":",
"raise",
"InvalidSchemaValue",
"(",
"\"Failed to cast value {value} to type {type}\"",
",",
"value",
",",
"self",
".",
"type",
")"
] | Cast value to schema type | [
"Cast",
"value",
"to",
"schema",
"type"
] | f274836c4dd45729b1634aff8758c63323173947 | https://github.com/p1c2u/openapi-core/blob/f274836c4dd45729b1634aff8758c63323173947/openapi_core/schema/schemas/models.py#L171-L189 | train |
p1c2u/openapi-core | openapi_core/schema/schemas/models.py | Schema.unmarshal | def unmarshal(self, value, custom_formatters=None, strict=True):
"""Unmarshal parameter from the value."""
if self.deprecated:
warnings.warn("The schema is deprecated", DeprecationWarning)
casted = self.cast(value, custom_formatters=custom_formatters, strict=strict)
if casted is None and not self.required:
return None
if self.enum and casted not in self.enum:
raise InvalidSchemaValue(
"Value {value} not in enum choices: {type}", value, self.enum)
return casted | python | def unmarshal(self, value, custom_formatters=None, strict=True):
"""Unmarshal parameter from the value."""
if self.deprecated:
warnings.warn("The schema is deprecated", DeprecationWarning)
casted = self.cast(value, custom_formatters=custom_formatters, strict=strict)
if casted is None and not self.required:
return None
if self.enum and casted not in self.enum:
raise InvalidSchemaValue(
"Value {value} not in enum choices: {type}", value, self.enum)
return casted | [
"def",
"unmarshal",
"(",
"self",
",",
"value",
",",
"custom_formatters",
"=",
"None",
",",
"strict",
"=",
"True",
")",
":",
"if",
"self",
".",
"deprecated",
":",
"warnings",
".",
"warn",
"(",
"\"The schema is deprecated\"",
",",
"DeprecationWarning",
")",
"casted",
"=",
"self",
".",
"cast",
"(",
"value",
",",
"custom_formatters",
"=",
"custom_formatters",
",",
"strict",
"=",
"strict",
")",
"if",
"casted",
"is",
"None",
"and",
"not",
"self",
".",
"required",
":",
"return",
"None",
"if",
"self",
".",
"enum",
"and",
"casted",
"not",
"in",
"self",
".",
"enum",
":",
"raise",
"InvalidSchemaValue",
"(",
"\"Value {value} not in enum choices: {type}\"",
",",
"value",
",",
"self",
".",
"enum",
")",
"return",
"casted"
] | Unmarshal parameter from the value. | [
"Unmarshal",
"parameter",
"from",
"the",
"value",
"."
] | f274836c4dd45729b1634aff8758c63323173947 | https://github.com/p1c2u/openapi-core/blob/f274836c4dd45729b1634aff8758c63323173947/openapi_core/schema/schemas/models.py#L191-L205 | train |
p1c2u/openapi-core | openapi_core/validation/util.py | get_operation_pattern | def get_operation_pattern(server_url, request_url_pattern):
"""Return an updated request URL pattern with the server URL removed."""
if server_url[-1] == "/":
# operations have to start with a slash, so do not remove it
server_url = server_url[:-1]
if is_absolute(server_url):
return request_url_pattern.replace(server_url, "", 1)
return path_qs(request_url_pattern).replace(server_url, "", 1) | python | def get_operation_pattern(server_url, request_url_pattern):
"""Return an updated request URL pattern with the server URL removed."""
if server_url[-1] == "/":
# operations have to start with a slash, so do not remove it
server_url = server_url[:-1]
if is_absolute(server_url):
return request_url_pattern.replace(server_url, "", 1)
return path_qs(request_url_pattern).replace(server_url, "", 1) | [
"def",
"get_operation_pattern",
"(",
"server_url",
",",
"request_url_pattern",
")",
":",
"if",
"server_url",
"[",
"-",
"1",
"]",
"==",
"\"/\"",
":",
"# operations have to start with a slash, so do not remove it",
"server_url",
"=",
"server_url",
"[",
":",
"-",
"1",
"]",
"if",
"is_absolute",
"(",
"server_url",
")",
":",
"return",
"request_url_pattern",
".",
"replace",
"(",
"server_url",
",",
"\"\"",
",",
"1",
")",
"return",
"path_qs",
"(",
"request_url_pattern",
")",
".",
"replace",
"(",
"server_url",
",",
"\"\"",
",",
"1",
")"
] | Return an updated request URL pattern with the server URL removed. | [
"Return",
"an",
"updated",
"request",
"URL",
"pattern",
"with",
"the",
"server",
"URL",
"removed",
"."
] | f274836c4dd45729b1634aff8758c63323173947 | https://github.com/p1c2u/openapi-core/blob/f274836c4dd45729b1634aff8758c63323173947/openapi_core/validation/util.py#L17-L24 | train |
nesaro/pydsl | pydsl/check.py | check | def check(definition, data, *args, **kwargs):
"""Checks if the input follows the definition"""
checker = checker_factory(definition)
return checker(data, *args, **kwargs) | python | def check(definition, data, *args, **kwargs):
"""Checks if the input follows the definition"""
checker = checker_factory(definition)
return checker(data, *args, **kwargs) | [
"def",
"check",
"(",
"definition",
",",
"data",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"checker",
"=",
"checker_factory",
"(",
"definition",
")",
"return",
"checker",
"(",
"data",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | Checks if the input follows the definition | [
"Checks",
"if",
"the",
"input",
"follows",
"the",
"definition"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/check.py#L29-L32 | train |
nesaro/pydsl | pydsl/check.py | RegularExpressionChecker.check | def check(self, data):
"""returns True if any match any regexp"""
if isinstance(data, Iterable):
data = "".join(str(x) for x in data)
try:
data = str(data)
except UnicodeDecodeError:
return False
return bool(data and self.__regexp.match(data)) | python | def check(self, data):
"""returns True if any match any regexp"""
if isinstance(data, Iterable):
data = "".join(str(x) for x in data)
try:
data = str(data)
except UnicodeDecodeError:
return False
return bool(data and self.__regexp.match(data)) | [
"def",
"check",
"(",
"self",
",",
"data",
")",
":",
"if",
"isinstance",
"(",
"data",
",",
"Iterable",
")",
":",
"data",
"=",
"\"\"",
".",
"join",
"(",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"data",
")",
"try",
":",
"data",
"=",
"str",
"(",
"data",
")",
"except",
"UnicodeDecodeError",
":",
"return",
"False",
"return",
"bool",
"(",
"data",
"and",
"self",
".",
"__regexp",
".",
"match",
"(",
"data",
")",
")"
] | returns True if any match any regexp | [
"returns",
"True",
"if",
"any",
"match",
"any",
"regexp"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/check.py#L93-L101 | train |
nesaro/pydsl | pydsl/parser/LR0.py | _build_item_closure | def _build_item_closure(itemset, productionset):
"""Build input itemset closure """
#For every item inside current itemset, if we have the following rule:
# xxx <cursor><nonterminalSymbol> xxx append every rule from self._productionruleset that begins with that NonTerminalSymbol
if not isinstance(itemset, LR0ItemSet):
raise TypeError
import copy
resultset = copy.copy(itemset)
changed = True
while changed:
changed = False
for currentitem in resultset.itemlist:
nextsymbol = currentitem.next_symbol()
if nextsymbol is None:
break
for rule in productionset.productions:
newitem = LR0Item(rule)
if rule.leftside[0] == nextsymbol and newitem not in resultset.itemlist:
resultset.append_item(newitem)
changed = True
return resultset | python | def _build_item_closure(itemset, productionset):
"""Build input itemset closure """
#For every item inside current itemset, if we have the following rule:
# xxx <cursor><nonterminalSymbol> xxx append every rule from self._productionruleset that begins with that NonTerminalSymbol
if not isinstance(itemset, LR0ItemSet):
raise TypeError
import copy
resultset = copy.copy(itemset)
changed = True
while changed:
changed = False
for currentitem in resultset.itemlist:
nextsymbol = currentitem.next_symbol()
if nextsymbol is None:
break
for rule in productionset.productions:
newitem = LR0Item(rule)
if rule.leftside[0] == nextsymbol and newitem not in resultset.itemlist:
resultset.append_item(newitem)
changed = True
return resultset | [
"def",
"_build_item_closure",
"(",
"itemset",
",",
"productionset",
")",
":",
"#For every item inside current itemset, if we have the following rule:",
"# xxx <cursor><nonterminalSymbol> xxx append every rule from self._productionruleset that begins with that NonTerminalSymbol",
"if",
"not",
"isinstance",
"(",
"itemset",
",",
"LR0ItemSet",
")",
":",
"raise",
"TypeError",
"import",
"copy",
"resultset",
"=",
"copy",
".",
"copy",
"(",
"itemset",
")",
"changed",
"=",
"True",
"while",
"changed",
":",
"changed",
"=",
"False",
"for",
"currentitem",
"in",
"resultset",
".",
"itemlist",
":",
"nextsymbol",
"=",
"currentitem",
".",
"next_symbol",
"(",
")",
"if",
"nextsymbol",
"is",
"None",
":",
"break",
"for",
"rule",
"in",
"productionset",
".",
"productions",
":",
"newitem",
"=",
"LR0Item",
"(",
"rule",
")",
"if",
"rule",
".",
"leftside",
"[",
"0",
"]",
"==",
"nextsymbol",
"and",
"newitem",
"not",
"in",
"resultset",
".",
"itemlist",
":",
"resultset",
".",
"append_item",
"(",
"newitem",
")",
"changed",
"=",
"True",
"return",
"resultset"
] | Build input itemset closure | [
"Build",
"input",
"itemset",
"closure"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/parser/LR0.py#L34-L54 | train |
nesaro/pydsl | pydsl/parser/LR0.py | item_set_goto | def item_set_goto(itemset, inputsymbol, productionset):
"""returns an itemset
locate inside itemset every element with inputsymbol following cursor
for every located item, append its itemclosure"""
resultset = LR0ItemSet()
for item in itemset.itemlist:
if item.next_symbol() == inputsymbol:
newitem = LR0Item(item.rule, item.position + 1)
resultset.append_item(newitem)
return _build_item_closure(resultset, productionset) | python | def item_set_goto(itemset, inputsymbol, productionset):
"""returns an itemset
locate inside itemset every element with inputsymbol following cursor
for every located item, append its itemclosure"""
resultset = LR0ItemSet()
for item in itemset.itemlist:
if item.next_symbol() == inputsymbol:
newitem = LR0Item(item.rule, item.position + 1)
resultset.append_item(newitem)
return _build_item_closure(resultset, productionset) | [
"def",
"item_set_goto",
"(",
"itemset",
",",
"inputsymbol",
",",
"productionset",
")",
":",
"resultset",
"=",
"LR0ItemSet",
"(",
")",
"for",
"item",
"in",
"itemset",
".",
"itemlist",
":",
"if",
"item",
".",
"next_symbol",
"(",
")",
"==",
"inputsymbol",
":",
"newitem",
"=",
"LR0Item",
"(",
"item",
".",
"rule",
",",
"item",
".",
"position",
"+",
"1",
")",
"resultset",
".",
"append_item",
"(",
"newitem",
")",
"return",
"_build_item_closure",
"(",
"resultset",
",",
"productionset",
")"
] | returns an itemset
locate inside itemset every element with inputsymbol following cursor
for every located item, append its itemclosure | [
"returns",
"an",
"itemset",
"locate",
"inside",
"itemset",
"every",
"element",
"with",
"inputsymbol",
"following",
"cursor",
"for",
"every",
"located",
"item",
"append",
"its",
"itemclosure"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/parser/LR0.py#L56-L65 | train |
nesaro/pydsl | pydsl/parser/LR0.py | _slr_build_parser_table | def _slr_build_parser_table(productionset):
"""SLR method to build parser table"""
result = ParserTable()
statesset = build_states_sets(productionset)
for itemindex, itemset in enumerate(statesset):
LOG.debug("_slr_build_parser_table: Evaluating itemset:" + str(itemset))
for symbol in productionset.getSymbols() + [EndSymbol()]:
numberoptions = 0
for lritem in itemset.itemlist:
#if cursor is before a terminal, and there is a transition to another itemset with the following terminal, append shift rule
if isinstance(symbol, TerminalSymbol) and lritem.next_symbol() == symbol and itemset.has_transition(symbol):
destinationstate = statesset.index(itemset.get_transition(symbol))
result.append(itemindex, symbol, "Shift", destinationstate)
numberoptions += 1
if isinstance(symbol, NonTerminalSymbol) and lritem.next_symbol() == symbol and itemset.has_transition(symbol):
destinationstate = statesset.index(itemset.get_transition(symbol))
result.append_goto(itemindex, symbol, destinationstate)
#if cursor is at the end of the rule, then append reduce rule and go transition
if lritem.previous_symbol() == symbol and lritem.is_last_position() and symbol != Extended_S:
for x in productionset.next_lookup(symbol):
if isinstance(x, Grammar):
result.append(itemindex, TerminalSymbol(x), "Reduce", None, lritem.rule)
elif isinstance(x, Symbol):
result.append(itemindex, x, "Reduce", None, lritem.rule)
else:
raise TypeError(x)
numberoptions += 1
#if cursor is at the end of main rule, and current symbol is end, then append accept rule
if symbol == EndSymbol() and lritem.previous_symbol() == productionset.initialsymbol and lritem.next_symbol() == EndSymbol():
result.append(itemindex, symbol, "Accept", None)
numberoptions += 1
if not numberoptions:
LOG.info("No rule found to generate a new parsertable entry ")
LOG.debug("symbol: " + str(symbol))
LOG.debug("itemset: " + str(itemset))
elif numberoptions > 1: #FIXME can it count duplicated entries?
raise Exception("LR Conflict %s" % symbol)
return result | python | def _slr_build_parser_table(productionset):
"""SLR method to build parser table"""
result = ParserTable()
statesset = build_states_sets(productionset)
for itemindex, itemset in enumerate(statesset):
LOG.debug("_slr_build_parser_table: Evaluating itemset:" + str(itemset))
for symbol in productionset.getSymbols() + [EndSymbol()]:
numberoptions = 0
for lritem in itemset.itemlist:
#if cursor is before a terminal, and there is a transition to another itemset with the following terminal, append shift rule
if isinstance(symbol, TerminalSymbol) and lritem.next_symbol() == symbol and itemset.has_transition(symbol):
destinationstate = statesset.index(itemset.get_transition(symbol))
result.append(itemindex, symbol, "Shift", destinationstate)
numberoptions += 1
if isinstance(symbol, NonTerminalSymbol) and lritem.next_symbol() == symbol and itemset.has_transition(symbol):
destinationstate = statesset.index(itemset.get_transition(symbol))
result.append_goto(itemindex, symbol, destinationstate)
#if cursor is at the end of the rule, then append reduce rule and go transition
if lritem.previous_symbol() == symbol and lritem.is_last_position() and symbol != Extended_S:
for x in productionset.next_lookup(symbol):
if isinstance(x, Grammar):
result.append(itemindex, TerminalSymbol(x), "Reduce", None, lritem.rule)
elif isinstance(x, Symbol):
result.append(itemindex, x, "Reduce", None, lritem.rule)
else:
raise TypeError(x)
numberoptions += 1
#if cursor is at the end of main rule, and current symbol is end, then append accept rule
if symbol == EndSymbol() and lritem.previous_symbol() == productionset.initialsymbol and lritem.next_symbol() == EndSymbol():
result.append(itemindex, symbol, "Accept", None)
numberoptions += 1
if not numberoptions:
LOG.info("No rule found to generate a new parsertable entry ")
LOG.debug("symbol: " + str(symbol))
LOG.debug("itemset: " + str(itemset))
elif numberoptions > 1: #FIXME can it count duplicated entries?
raise Exception("LR Conflict %s" % symbol)
return result | [
"def",
"_slr_build_parser_table",
"(",
"productionset",
")",
":",
"result",
"=",
"ParserTable",
"(",
")",
"statesset",
"=",
"build_states_sets",
"(",
"productionset",
")",
"for",
"itemindex",
",",
"itemset",
"in",
"enumerate",
"(",
"statesset",
")",
":",
"LOG",
".",
"debug",
"(",
"\"_slr_build_parser_table: Evaluating itemset:\"",
"+",
"str",
"(",
"itemset",
")",
")",
"for",
"symbol",
"in",
"productionset",
".",
"getSymbols",
"(",
")",
"+",
"[",
"EndSymbol",
"(",
")",
"]",
":",
"numberoptions",
"=",
"0",
"for",
"lritem",
"in",
"itemset",
".",
"itemlist",
":",
"#if cursor is before a terminal, and there is a transition to another itemset with the following terminal, append shift rule",
"if",
"isinstance",
"(",
"symbol",
",",
"TerminalSymbol",
")",
"and",
"lritem",
".",
"next_symbol",
"(",
")",
"==",
"symbol",
"and",
"itemset",
".",
"has_transition",
"(",
"symbol",
")",
":",
"destinationstate",
"=",
"statesset",
".",
"index",
"(",
"itemset",
".",
"get_transition",
"(",
"symbol",
")",
")",
"result",
".",
"append",
"(",
"itemindex",
",",
"symbol",
",",
"\"Shift\"",
",",
"destinationstate",
")",
"numberoptions",
"+=",
"1",
"if",
"isinstance",
"(",
"symbol",
",",
"NonTerminalSymbol",
")",
"and",
"lritem",
".",
"next_symbol",
"(",
")",
"==",
"symbol",
"and",
"itemset",
".",
"has_transition",
"(",
"symbol",
")",
":",
"destinationstate",
"=",
"statesset",
".",
"index",
"(",
"itemset",
".",
"get_transition",
"(",
"symbol",
")",
")",
"result",
".",
"append_goto",
"(",
"itemindex",
",",
"symbol",
",",
"destinationstate",
")",
"#if cursor is at the end of the rule, then append reduce rule and go transition",
"if",
"lritem",
".",
"previous_symbol",
"(",
")",
"==",
"symbol",
"and",
"lritem",
".",
"is_last_position",
"(",
")",
"and",
"symbol",
"!=",
"Extended_S",
":",
"for",
"x",
"in",
"productionset",
".",
"next_lookup",
"(",
"symbol",
")",
":",
"if",
"isinstance",
"(",
"x",
",",
"Grammar",
")",
":",
"result",
".",
"append",
"(",
"itemindex",
",",
"TerminalSymbol",
"(",
"x",
")",
",",
"\"Reduce\"",
",",
"None",
",",
"lritem",
".",
"rule",
")",
"elif",
"isinstance",
"(",
"x",
",",
"Symbol",
")",
":",
"result",
".",
"append",
"(",
"itemindex",
",",
"x",
",",
"\"Reduce\"",
",",
"None",
",",
"lritem",
".",
"rule",
")",
"else",
":",
"raise",
"TypeError",
"(",
"x",
")",
"numberoptions",
"+=",
"1",
"#if cursor is at the end of main rule, and current symbol is end, then append accept rule",
"if",
"symbol",
"==",
"EndSymbol",
"(",
")",
"and",
"lritem",
".",
"previous_symbol",
"(",
")",
"==",
"productionset",
".",
"initialsymbol",
"and",
"lritem",
".",
"next_symbol",
"(",
")",
"==",
"EndSymbol",
"(",
")",
":",
"result",
".",
"append",
"(",
"itemindex",
",",
"symbol",
",",
"\"Accept\"",
",",
"None",
")",
"numberoptions",
"+=",
"1",
"if",
"not",
"numberoptions",
":",
"LOG",
".",
"info",
"(",
"\"No rule found to generate a new parsertable entry \"",
")",
"LOG",
".",
"debug",
"(",
"\"symbol: \"",
"+",
"str",
"(",
"symbol",
")",
")",
"LOG",
".",
"debug",
"(",
"\"itemset: \"",
"+",
"str",
"(",
"itemset",
")",
")",
"elif",
"numberoptions",
">",
"1",
":",
"#FIXME can it count duplicated entries?",
"raise",
"Exception",
"(",
"\"LR Conflict %s\"",
"%",
"symbol",
")",
"return",
"result"
] | SLR method to build parser table | [
"SLR",
"method",
"to",
"build",
"parser",
"table"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/parser/LR0.py#L97-L134 | train |
nesaro/pydsl | pydsl/parser/LR0.py | ParserTable.append | def append(self, state, symbol, action, destinationstate, production = None):
"""Appends a new rule"""
if action not in (None, "Accept", "Shift", "Reduce"):
raise TypeError
rule = {"action":action, "dest":destinationstate}
if action == "Reduce":
if rule is None:
raise TypeError("Expected production parameter")
rule["rule"] = production
while isinstance(symbol, TerminalSymbol) and isinstance(symbol.gd, Iterable) and len(symbol.gd) == 1 and isinstance(list(symbol.gd)[0], Grammar):
symbol = TerminalSymbol(list(symbol.gd)[0]) #Reduces symbol if its gd is a Sequence/Choice of 1 element
if not isinstance(symbol, Symbol):
raise TypeError("Expected symbol, got %s" % symbol)
self[state][symbol] = rule | python | def append(self, state, symbol, action, destinationstate, production = None):
"""Appends a new rule"""
if action not in (None, "Accept", "Shift", "Reduce"):
raise TypeError
rule = {"action":action, "dest":destinationstate}
if action == "Reduce":
if rule is None:
raise TypeError("Expected production parameter")
rule["rule"] = production
while isinstance(symbol, TerminalSymbol) and isinstance(symbol.gd, Iterable) and len(symbol.gd) == 1 and isinstance(list(symbol.gd)[0], Grammar):
symbol = TerminalSymbol(list(symbol.gd)[0]) #Reduces symbol if its gd is a Sequence/Choice of 1 element
if not isinstance(symbol, Symbol):
raise TypeError("Expected symbol, got %s" % symbol)
self[state][symbol] = rule | [
"def",
"append",
"(",
"self",
",",
"state",
",",
"symbol",
",",
"action",
",",
"destinationstate",
",",
"production",
"=",
"None",
")",
":",
"if",
"action",
"not",
"in",
"(",
"None",
",",
"\"Accept\"",
",",
"\"Shift\"",
",",
"\"Reduce\"",
")",
":",
"raise",
"TypeError",
"rule",
"=",
"{",
"\"action\"",
":",
"action",
",",
"\"dest\"",
":",
"destinationstate",
"}",
"if",
"action",
"==",
"\"Reduce\"",
":",
"if",
"rule",
"is",
"None",
":",
"raise",
"TypeError",
"(",
"\"Expected production parameter\"",
")",
"rule",
"[",
"\"rule\"",
"]",
"=",
"production",
"while",
"isinstance",
"(",
"symbol",
",",
"TerminalSymbol",
")",
"and",
"isinstance",
"(",
"symbol",
".",
"gd",
",",
"Iterable",
")",
"and",
"len",
"(",
"symbol",
".",
"gd",
")",
"==",
"1",
"and",
"isinstance",
"(",
"list",
"(",
"symbol",
".",
"gd",
")",
"[",
"0",
"]",
",",
"Grammar",
")",
":",
"symbol",
"=",
"TerminalSymbol",
"(",
"list",
"(",
"symbol",
".",
"gd",
")",
"[",
"0",
"]",
")",
"#Reduces symbol if its gd is a Sequence/Choice of 1 element",
"if",
"not",
"isinstance",
"(",
"symbol",
",",
"Symbol",
")",
":",
"raise",
"TypeError",
"(",
"\"Expected symbol, got %s\"",
"%",
"symbol",
")",
"self",
"[",
"state",
"]",
"[",
"symbol",
"]",
"=",
"rule"
] | Appends a new rule | [
"Appends",
"a",
"new",
"rule"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/parser/LR0.py#L141-L154 | train |
nesaro/pydsl | pydsl/parser/LR0.py | ParserTable.insert | def insert(self, state, token):
"""change internal state, return action"""
if token == EndSymbol():
return self[state][EndSymbol()]
from pydsl.check import check
symbol_list = [x for x in self[state] if isinstance(x, TerminalSymbol) and check(x.gd, [token])]
if not symbol_list:
return {"action":"Fail"}
if len(symbol_list) > 1:
raise Exception("Multiple symbols matches input")
symbol = symbol_list[0]
return self[state][symbol] | python | def insert(self, state, token):
"""change internal state, return action"""
if token == EndSymbol():
return self[state][EndSymbol()]
from pydsl.check import check
symbol_list = [x for x in self[state] if isinstance(x, TerminalSymbol) and check(x.gd, [token])]
if not symbol_list:
return {"action":"Fail"}
if len(symbol_list) > 1:
raise Exception("Multiple symbols matches input")
symbol = symbol_list[0]
return self[state][symbol] | [
"def",
"insert",
"(",
"self",
",",
"state",
",",
"token",
")",
":",
"if",
"token",
"==",
"EndSymbol",
"(",
")",
":",
"return",
"self",
"[",
"state",
"]",
"[",
"EndSymbol",
"(",
")",
"]",
"from",
"pydsl",
".",
"check",
"import",
"check",
"symbol_list",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
"[",
"state",
"]",
"if",
"isinstance",
"(",
"x",
",",
"TerminalSymbol",
")",
"and",
"check",
"(",
"x",
".",
"gd",
",",
"[",
"token",
"]",
")",
"]",
"if",
"not",
"symbol_list",
":",
"return",
"{",
"\"action\"",
":",
"\"Fail\"",
"}",
"if",
"len",
"(",
"symbol_list",
")",
">",
"1",
":",
"raise",
"Exception",
"(",
"\"Multiple symbols matches input\"",
")",
"symbol",
"=",
"symbol_list",
"[",
"0",
"]",
"return",
"self",
"[",
"state",
"]",
"[",
"symbol",
"]"
] | change internal state, return action | [
"change",
"internal",
"state",
"return",
"action"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/parser/LR0.py#L164-L175 | train |
nesaro/pydsl | pydsl/parser/LR0.py | LR0ItemSet.append_item | def append_item(self, item):
"""Append new item to set"""
if not isinstance(item, LR0Item):
raise TypeError
self.itemlist.append(item) | python | def append_item(self, item):
"""Append new item to set"""
if not isinstance(item, LR0Item):
raise TypeError
self.itemlist.append(item) | [
"def",
"append_item",
"(",
"self",
",",
"item",
")",
":",
"if",
"not",
"isinstance",
"(",
"item",
",",
"LR0Item",
")",
":",
"raise",
"TypeError",
"self",
".",
"itemlist",
".",
"append",
"(",
"item",
")"
] | Append new item to set | [
"Append",
"new",
"item",
"to",
"set"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/parser/LR0.py#L248-L252 | train |
nesaro/pydsl | pydsl/parser/LR0.py | LR0ItemSet.append_transition | def append_transition(self, symbol, targetset):
"""Appends a transition"""
if symbol in self.transitions:
return
self.transitions[symbol] = targetset | python | def append_transition(self, symbol, targetset):
"""Appends a transition"""
if symbol in self.transitions:
return
self.transitions[symbol] = targetset | [
"def",
"append_transition",
"(",
"self",
",",
"symbol",
",",
"targetset",
")",
":",
"if",
"symbol",
"in",
"self",
".",
"transitions",
":",
"return",
"self",
".",
"transitions",
"[",
"symbol",
"]",
"=",
"targetset"
] | Appends a transition | [
"Appends",
"a",
"transition"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/parser/LR0.py#L254-L258 | train |
nesaro/pydsl | pydsl/parser/LR0.py | LR0Parser.__parse | def __parse(self, tokenlist):
"""see parent docstring"""
#empty stack
#iterate over symbollist
tokenlist = [x for x in tokenlist]
if not isinstance(tokenlist, list):
raise TypeError("Expected list, got %s" % tokenlist.__class__.__name__)
LOG.debug("get_trees: checking list: " + str(tokenlist))
stack = [(0, Extended_S)]
while True:
state = stack[-1][0]
if len(tokenlist):#FIXME: tokenlist with one element is reported as false
token = tokenlist[0]
else:
token = EndSymbol()
newdic = self.__parsertable.insert(state, token)
action = newdic["action"]
if action == "Fail":
return False
elif action == "Accept":
return True
if action == "Reduce":
reductionrule = newdic["rule"]
#TODO extract len(right side) of the rule and insert left side
for rsymbol in reversed(reductionrule.rightside):
state, symbol = stack.pop() # TODO: check
state = stack[-1][0]
state = self.__parsertable.goto(state,reductionrule.leftside[0])
stack.append((state, reductionrule.leftside[0]))
elif action == "Shift":
stack.append((newdic['dest'], tokenlist.pop(0)))
else:
raise ValueError("Unknown action")
return False | python | def __parse(self, tokenlist):
"""see parent docstring"""
#empty stack
#iterate over symbollist
tokenlist = [x for x in tokenlist]
if not isinstance(tokenlist, list):
raise TypeError("Expected list, got %s" % tokenlist.__class__.__name__)
LOG.debug("get_trees: checking list: " + str(tokenlist))
stack = [(0, Extended_S)]
while True:
state = stack[-1][0]
if len(tokenlist):#FIXME: tokenlist with one element is reported as false
token = tokenlist[0]
else:
token = EndSymbol()
newdic = self.__parsertable.insert(state, token)
action = newdic["action"]
if action == "Fail":
return False
elif action == "Accept":
return True
if action == "Reduce":
reductionrule = newdic["rule"]
#TODO extract len(right side) of the rule and insert left side
for rsymbol in reversed(reductionrule.rightside):
state, symbol = stack.pop() # TODO: check
state = stack[-1][0]
state = self.__parsertable.goto(state,reductionrule.leftside[0])
stack.append((state, reductionrule.leftside[0]))
elif action == "Shift":
stack.append((newdic['dest'], tokenlist.pop(0)))
else:
raise ValueError("Unknown action")
return False | [
"def",
"__parse",
"(",
"self",
",",
"tokenlist",
")",
":",
"#empty stack",
"#iterate over symbollist",
"tokenlist",
"=",
"[",
"x",
"for",
"x",
"in",
"tokenlist",
"]",
"if",
"not",
"isinstance",
"(",
"tokenlist",
",",
"list",
")",
":",
"raise",
"TypeError",
"(",
"\"Expected list, got %s\"",
"%",
"tokenlist",
".",
"__class__",
".",
"__name__",
")",
"LOG",
".",
"debug",
"(",
"\"get_trees: checking list: \"",
"+",
"str",
"(",
"tokenlist",
")",
")",
"stack",
"=",
"[",
"(",
"0",
",",
"Extended_S",
")",
"]",
"while",
"True",
":",
"state",
"=",
"stack",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
"if",
"len",
"(",
"tokenlist",
")",
":",
"#FIXME: tokenlist with one element is reported as false",
"token",
"=",
"tokenlist",
"[",
"0",
"]",
"else",
":",
"token",
"=",
"EndSymbol",
"(",
")",
"newdic",
"=",
"self",
".",
"__parsertable",
".",
"insert",
"(",
"state",
",",
"token",
")",
"action",
"=",
"newdic",
"[",
"\"action\"",
"]",
"if",
"action",
"==",
"\"Fail\"",
":",
"return",
"False",
"elif",
"action",
"==",
"\"Accept\"",
":",
"return",
"True",
"if",
"action",
"==",
"\"Reduce\"",
":",
"reductionrule",
"=",
"newdic",
"[",
"\"rule\"",
"]",
"#TODO extract len(right side) of the rule and insert left side",
"for",
"rsymbol",
"in",
"reversed",
"(",
"reductionrule",
".",
"rightside",
")",
":",
"state",
",",
"symbol",
"=",
"stack",
".",
"pop",
"(",
")",
"# TODO: check",
"state",
"=",
"stack",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
"state",
"=",
"self",
".",
"__parsertable",
".",
"goto",
"(",
"state",
",",
"reductionrule",
".",
"leftside",
"[",
"0",
"]",
")",
"stack",
".",
"append",
"(",
"(",
"state",
",",
"reductionrule",
".",
"leftside",
"[",
"0",
"]",
")",
")",
"elif",
"action",
"==",
"\"Shift\"",
":",
"stack",
".",
"append",
"(",
"(",
"newdic",
"[",
"'dest'",
"]",
",",
"tokenlist",
".",
"pop",
"(",
"0",
")",
")",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Unknown action\"",
")",
"return",
"False"
] | see parent docstring | [
"see",
"parent",
"docstring"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/parser/LR0.py#L279-L312 | train |
nesaro/pydsl | pydsl/lex.py | graph_from_alphabet | def graph_from_alphabet(alphabet, base):
"""Creates a graph that connects the base with the target through alphabets
If every target is connected to any inputs, create the independent paths"""
if not isinstance(alphabet, Choice):
raise TypeError(alphabet.__class__.__name__)
if not isinstance(base, Choice):
raise TypeError(base.__class__.__name__)
import networkx
result = networkx.DiGraph()
current_alphabet = alphabet
pending_stack = set(current_alphabet)
while pending_stack:
current_alphabet = pending_stack.pop()
if current_alphabet == base:
continue
if current_alphabet in base:
result.add_edge(current_alphabet, base)
elif isinstance(current_alphabet, Choice):
for element in current_alphabet:
if element in base:
result.add_edge(current_alphabet, base)
else:
result.add_edge(current_alphabet, element)
pending_stack.add(element)
elif current_alphabet.alphabet:
result.add_edge(current_alphabet, current_alphabet.alphabet)
pending_stack.add(current_alphabet.alphabet)
return result | python | def graph_from_alphabet(alphabet, base):
"""Creates a graph that connects the base with the target through alphabets
If every target is connected to any inputs, create the independent paths"""
if not isinstance(alphabet, Choice):
raise TypeError(alphabet.__class__.__name__)
if not isinstance(base, Choice):
raise TypeError(base.__class__.__name__)
import networkx
result = networkx.DiGraph()
current_alphabet = alphabet
pending_stack = set(current_alphabet)
while pending_stack:
current_alphabet = pending_stack.pop()
if current_alphabet == base:
continue
if current_alphabet in base:
result.add_edge(current_alphabet, base)
elif isinstance(current_alphabet, Choice):
for element in current_alphabet:
if element in base:
result.add_edge(current_alphabet, base)
else:
result.add_edge(current_alphabet, element)
pending_stack.add(element)
elif current_alphabet.alphabet:
result.add_edge(current_alphabet, current_alphabet.alphabet)
pending_stack.add(current_alphabet.alphabet)
return result | [
"def",
"graph_from_alphabet",
"(",
"alphabet",
",",
"base",
")",
":",
"if",
"not",
"isinstance",
"(",
"alphabet",
",",
"Choice",
")",
":",
"raise",
"TypeError",
"(",
"alphabet",
".",
"__class__",
".",
"__name__",
")",
"if",
"not",
"isinstance",
"(",
"base",
",",
"Choice",
")",
":",
"raise",
"TypeError",
"(",
"base",
".",
"__class__",
".",
"__name__",
")",
"import",
"networkx",
"result",
"=",
"networkx",
".",
"DiGraph",
"(",
")",
"current_alphabet",
"=",
"alphabet",
"pending_stack",
"=",
"set",
"(",
"current_alphabet",
")",
"while",
"pending_stack",
":",
"current_alphabet",
"=",
"pending_stack",
".",
"pop",
"(",
")",
"if",
"current_alphabet",
"==",
"base",
":",
"continue",
"if",
"current_alphabet",
"in",
"base",
":",
"result",
".",
"add_edge",
"(",
"current_alphabet",
",",
"base",
")",
"elif",
"isinstance",
"(",
"current_alphabet",
",",
"Choice",
")",
":",
"for",
"element",
"in",
"current_alphabet",
":",
"if",
"element",
"in",
"base",
":",
"result",
".",
"add_edge",
"(",
"current_alphabet",
",",
"base",
")",
"else",
":",
"result",
".",
"add_edge",
"(",
"current_alphabet",
",",
"element",
")",
"pending_stack",
".",
"add",
"(",
"element",
")",
"elif",
"current_alphabet",
".",
"alphabet",
":",
"result",
".",
"add_edge",
"(",
"current_alphabet",
",",
"current_alphabet",
".",
"alphabet",
")",
"pending_stack",
".",
"add",
"(",
"current_alphabet",
".",
"alphabet",
")",
"return",
"result"
] | Creates a graph that connects the base with the target through alphabets
If every target is connected to any inputs, create the independent paths | [
"Creates",
"a",
"graph",
"that",
"connects",
"the",
"base",
"with",
"the",
"target",
"through",
"alphabets",
"If",
"every",
"target",
"is",
"connected",
"to",
"any",
"inputs",
"create",
"the",
"independent",
"paths"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/lex.py#L56-L84 | train |
nesaro/pydsl | pydsl/lex.py | is_subset | def is_subset(a, b):
"""Excluding same size"""
return b.left <= a.left and b.right > a.right or b.left < a.left and b.right >= a.right | python | def is_subset(a, b):
"""Excluding same size"""
return b.left <= a.left and b.right > a.right or b.left < a.left and b.right >= a.right | [
"def",
"is_subset",
"(",
"a",
",",
"b",
")",
":",
"return",
"b",
".",
"left",
"<=",
"a",
".",
"left",
"and",
"b",
".",
"right",
">",
"a",
".",
"right",
"or",
"b",
".",
"left",
"<",
"a",
".",
"left",
"and",
"b",
".",
"right",
">=",
"a",
".",
"right"
] | Excluding same size | [
"Excluding",
"same",
"size"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/lex.py#L141-L143 | train |
nesaro/pydsl | pydsl/lex.py | digraph_walker_backwards | def digraph_walker_backwards(graph, element, call_back):
"""Visits every element guaranteeing that the previous elements have been visited before"""
call_back(graph, element)
for predecessor in graph.predecessors(element):
call_back(graph, predecessor)
for predecessor in graph.predecessors(element):
digraph_walker_backwards(graph, predecessor, call_back) | python | def digraph_walker_backwards(graph, element, call_back):
"""Visits every element guaranteeing that the previous elements have been visited before"""
call_back(graph, element)
for predecessor in graph.predecessors(element):
call_back(graph, predecessor)
for predecessor in graph.predecessors(element):
digraph_walker_backwards(graph, predecessor, call_back) | [
"def",
"digraph_walker_backwards",
"(",
"graph",
",",
"element",
",",
"call_back",
")",
":",
"call_back",
"(",
"graph",
",",
"element",
")",
"for",
"predecessor",
"in",
"graph",
".",
"predecessors",
"(",
"element",
")",
":",
"call_back",
"(",
"graph",
",",
"predecessor",
")",
"for",
"predecessor",
"in",
"graph",
".",
"predecessors",
"(",
"element",
")",
":",
"digraph_walker_backwards",
"(",
"graph",
",",
"predecessor",
",",
"call_back",
")"
] | Visits every element guaranteeing that the previous elements have been visited before | [
"Visits",
"every",
"element",
"guaranteeing",
"that",
"the",
"previous",
"elements",
"have",
"been",
"visited",
"before"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/lex.py#L185-L191 | train |
nesaro/pydsl | pydsl/grammar/BNF.py | BNFGrammar.first_lookup | def first_lookup(self, symbol, size=1):
"""
Returns a Grammar Definition with the first n terminal symbols
produced by the input symbol
"""
if isinstance(symbol, (TerminalSymbol, NullSymbol)):
return [symbol.gd]
result = []
for production in self.productions:
if production.leftside[0] != symbol:
continue
for right_symbol in production.rightside:
if right_symbol == symbol: #Avoids infinite recursion
break
current_symbol_first = self.first_lookup(right_symbol, size)
import collections
from pydsl.grammar.definition import String
if isinstance(current_symbol_first, collections.Iterable) and not isinstance(current_symbol_first, String):
result += current_symbol_first
else:
result.append(current_symbol_first)
if isinstance(current_symbol_first, String) or \
not isinstance(current_symbol_first, collections.Iterable) or \
(NullSymbol not in current_symbol_first):
break # This element doesn't have Null in its first set so there is no need to continue
if not result:
raise KeyError("Symbol doesn't exist in this grammar")
return Choice(result) | python | def first_lookup(self, symbol, size=1):
"""
Returns a Grammar Definition with the first n terminal symbols
produced by the input symbol
"""
if isinstance(symbol, (TerminalSymbol, NullSymbol)):
return [symbol.gd]
result = []
for production in self.productions:
if production.leftside[0] != symbol:
continue
for right_symbol in production.rightside:
if right_symbol == symbol: #Avoids infinite recursion
break
current_symbol_first = self.first_lookup(right_symbol, size)
import collections
from pydsl.grammar.definition import String
if isinstance(current_symbol_first, collections.Iterable) and not isinstance(current_symbol_first, String):
result += current_symbol_first
else:
result.append(current_symbol_first)
if isinstance(current_symbol_first, String) or \
not isinstance(current_symbol_first, collections.Iterable) or \
(NullSymbol not in current_symbol_first):
break # This element doesn't have Null in its first set so there is no need to continue
if not result:
raise KeyError("Symbol doesn't exist in this grammar")
return Choice(result) | [
"def",
"first_lookup",
"(",
"self",
",",
"symbol",
",",
"size",
"=",
"1",
")",
":",
"if",
"isinstance",
"(",
"symbol",
",",
"(",
"TerminalSymbol",
",",
"NullSymbol",
")",
")",
":",
"return",
"[",
"symbol",
".",
"gd",
"]",
"result",
"=",
"[",
"]",
"for",
"production",
"in",
"self",
".",
"productions",
":",
"if",
"production",
".",
"leftside",
"[",
"0",
"]",
"!=",
"symbol",
":",
"continue",
"for",
"right_symbol",
"in",
"production",
".",
"rightside",
":",
"if",
"right_symbol",
"==",
"symbol",
":",
"#Avoids infinite recursion",
"break",
"current_symbol_first",
"=",
"self",
".",
"first_lookup",
"(",
"right_symbol",
",",
"size",
")",
"import",
"collections",
"from",
"pydsl",
".",
"grammar",
".",
"definition",
"import",
"String",
"if",
"isinstance",
"(",
"current_symbol_first",
",",
"collections",
".",
"Iterable",
")",
"and",
"not",
"isinstance",
"(",
"current_symbol_first",
",",
"String",
")",
":",
"result",
"+=",
"current_symbol_first",
"else",
":",
"result",
".",
"append",
"(",
"current_symbol_first",
")",
"if",
"isinstance",
"(",
"current_symbol_first",
",",
"String",
")",
"or",
"not",
"isinstance",
"(",
"current_symbol_first",
",",
"collections",
".",
"Iterable",
")",
"or",
"(",
"NullSymbol",
"not",
"in",
"current_symbol_first",
")",
":",
"break",
"# This element doesn't have Null in its first set so there is no need to continue",
"if",
"not",
"result",
":",
"raise",
"KeyError",
"(",
"\"Symbol doesn't exist in this grammar\"",
")",
"return",
"Choice",
"(",
"result",
")"
] | Returns a Grammar Definition with the first n terminal symbols
produced by the input symbol | [
"Returns",
"a",
"Grammar",
"Definition",
"with",
"the",
"first",
"n",
"terminal",
"symbols",
"produced",
"by",
"the",
"input",
"symbol"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/grammar/BNF.py#L96-L123 | train |
nesaro/pydsl | pydsl/grammar/BNF.py | BNFGrammar.next_lookup | def next_lookup(self, symbol):
"""Returns the next TerminalSymbols produced by the input symbol within this grammar definition"""
result = []
if symbol == self.initialsymbol:
result.append(EndSymbol())
for production in self.productions:
if symbol in production.rightside:
nextindex = production.rightside.index(symbol) + 1
while nextindex < len(production.rightside):
nextsymbol = production.rightside[nextindex]
firstlist = self.first_lookup(nextsymbol)
cleanfirstlist = Choice([x for x in firstlist if x != NullSymbol()])
result.append(cleanfirstlist)
if NullSymbol() not in firstlist:
break
else:
result += self.next_lookup(production.leftside[0]) #reached the end of the rightside
return result | python | def next_lookup(self, symbol):
"""Returns the next TerminalSymbols produced by the input symbol within this grammar definition"""
result = []
if symbol == self.initialsymbol:
result.append(EndSymbol())
for production in self.productions:
if symbol in production.rightside:
nextindex = production.rightside.index(symbol) + 1
while nextindex < len(production.rightside):
nextsymbol = production.rightside[nextindex]
firstlist = self.first_lookup(nextsymbol)
cleanfirstlist = Choice([x for x in firstlist if x != NullSymbol()])
result.append(cleanfirstlist)
if NullSymbol() not in firstlist:
break
else:
result += self.next_lookup(production.leftside[0]) #reached the end of the rightside
return result | [
"def",
"next_lookup",
"(",
"self",
",",
"symbol",
")",
":",
"result",
"=",
"[",
"]",
"if",
"symbol",
"==",
"self",
".",
"initialsymbol",
":",
"result",
".",
"append",
"(",
"EndSymbol",
"(",
")",
")",
"for",
"production",
"in",
"self",
".",
"productions",
":",
"if",
"symbol",
"in",
"production",
".",
"rightside",
":",
"nextindex",
"=",
"production",
".",
"rightside",
".",
"index",
"(",
"symbol",
")",
"+",
"1",
"while",
"nextindex",
"<",
"len",
"(",
"production",
".",
"rightside",
")",
":",
"nextsymbol",
"=",
"production",
".",
"rightside",
"[",
"nextindex",
"]",
"firstlist",
"=",
"self",
".",
"first_lookup",
"(",
"nextsymbol",
")",
"cleanfirstlist",
"=",
"Choice",
"(",
"[",
"x",
"for",
"x",
"in",
"firstlist",
"if",
"x",
"!=",
"NullSymbol",
"(",
")",
"]",
")",
"result",
".",
"append",
"(",
"cleanfirstlist",
")",
"if",
"NullSymbol",
"(",
")",
"not",
"in",
"firstlist",
":",
"break",
"else",
":",
"result",
"+=",
"self",
".",
"next_lookup",
"(",
"production",
".",
"leftside",
"[",
"0",
"]",
")",
"#reached the end of the rightside",
"return",
"result"
] | Returns the next TerminalSymbols produced by the input symbol within this grammar definition | [
"Returns",
"the",
"next",
"TerminalSymbols",
"produced",
"by",
"the",
"input",
"symbol",
"within",
"this",
"grammar",
"definition"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/grammar/BNF.py#L125-L142 | train |
nesaro/pydsl | pydsl/grammar/BNF.py | BNFGrammar.main_production | def main_production(self):
"""Returns main rule"""
for rule in self.productions:
if rule.leftside[0] == self._initialsymbol:
return rule
raise IndexError | python | def main_production(self):
"""Returns main rule"""
for rule in self.productions:
if rule.leftside[0] == self._initialsymbol:
return rule
raise IndexError | [
"def",
"main_production",
"(",
"self",
")",
":",
"for",
"rule",
"in",
"self",
".",
"productions",
":",
"if",
"rule",
".",
"leftside",
"[",
"0",
"]",
"==",
"self",
".",
"_initialsymbol",
":",
"return",
"rule",
"raise",
"IndexError"
] | Returns main rule | [
"Returns",
"main",
"rule"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/grammar/BNF.py#L155-L160 | train |
nesaro/pydsl | pydsl/grammar/BNF.py | BNFGrammar.getSymbols | def getSymbols(self):
"""Returns every symbol"""
symbollist = []
for rule in self.productions:
for symbol in rule.leftside + rule.rightside:
if symbol not in symbollist:
symbollist.append(symbol)
symbollist += self.terminal_symbols
return symbollist | python | def getSymbols(self):
"""Returns every symbol"""
symbollist = []
for rule in self.productions:
for symbol in rule.leftside + rule.rightside:
if symbol not in symbollist:
symbollist.append(symbol)
symbollist += self.terminal_symbols
return symbollist | [
"def",
"getSymbols",
"(",
"self",
")",
":",
"symbollist",
"=",
"[",
"]",
"for",
"rule",
"in",
"self",
".",
"productions",
":",
"for",
"symbol",
"in",
"rule",
".",
"leftside",
"+",
"rule",
".",
"rightside",
":",
"if",
"symbol",
"not",
"in",
"symbollist",
":",
"symbollist",
".",
"append",
"(",
"symbol",
")",
"symbollist",
"+=",
"self",
".",
"terminal_symbols",
"return",
"symbollist"
] | Returns every symbol | [
"Returns",
"every",
"symbol"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/grammar/BNF.py#L168-L176 | train |
nesaro/pydsl | pydsl/extract.py | extract_alphabet | def extract_alphabet(alphabet, inputdata, fixed_start = False):
"""
Receives a sequence and an alphabet,
returns a list of PositionTokens with all of the parts of the sequence that
are a subset of the alphabet
"""
if not inputdata:
return []
base_alphabet = alphabet.alphabet
lexer = lexer_factory(alphabet, base_alphabet)
totallen = len(inputdata)
maxl = totallen
minl = 1
if fixed_start:
max_start = 1
else:
max_start = totallen
result = []
for i in range(max_start):
for j in range(i+minl, min(i+maxl, totallen) + 1):
try:
lexed = lexer(inputdata[i:j])
if lexed and len(lexed) == 1:
result.append((i,j, inputdata[i:j], lexed[0].gd))
elif lexed:
raise Exception
except:
continue
result = filter_subsets(result)
return [PositionToken(content, gd, left, right) for (left, right, content, gd) in result] | python | def extract_alphabet(alphabet, inputdata, fixed_start = False):
"""
Receives a sequence and an alphabet,
returns a list of PositionTokens with all of the parts of the sequence that
are a subset of the alphabet
"""
if not inputdata:
return []
base_alphabet = alphabet.alphabet
lexer = lexer_factory(alphabet, base_alphabet)
totallen = len(inputdata)
maxl = totallen
minl = 1
if fixed_start:
max_start = 1
else:
max_start = totallen
result = []
for i in range(max_start):
for j in range(i+minl, min(i+maxl, totallen) + 1):
try:
lexed = lexer(inputdata[i:j])
if lexed and len(lexed) == 1:
result.append((i,j, inputdata[i:j], lexed[0].gd))
elif lexed:
raise Exception
except:
continue
result = filter_subsets(result)
return [PositionToken(content, gd, left, right) for (left, right, content, gd) in result] | [
"def",
"extract_alphabet",
"(",
"alphabet",
",",
"inputdata",
",",
"fixed_start",
"=",
"False",
")",
":",
"if",
"not",
"inputdata",
":",
"return",
"[",
"]",
"base_alphabet",
"=",
"alphabet",
".",
"alphabet",
"lexer",
"=",
"lexer_factory",
"(",
"alphabet",
",",
"base_alphabet",
")",
"totallen",
"=",
"len",
"(",
"inputdata",
")",
"maxl",
"=",
"totallen",
"minl",
"=",
"1",
"if",
"fixed_start",
":",
"max_start",
"=",
"1",
"else",
":",
"max_start",
"=",
"totallen",
"result",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"max_start",
")",
":",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"minl",
",",
"min",
"(",
"i",
"+",
"maxl",
",",
"totallen",
")",
"+",
"1",
")",
":",
"try",
":",
"lexed",
"=",
"lexer",
"(",
"inputdata",
"[",
"i",
":",
"j",
"]",
")",
"if",
"lexed",
"and",
"len",
"(",
"lexed",
")",
"==",
"1",
":",
"result",
".",
"append",
"(",
"(",
"i",
",",
"j",
",",
"inputdata",
"[",
"i",
":",
"j",
"]",
",",
"lexed",
"[",
"0",
"]",
".",
"gd",
")",
")",
"elif",
"lexed",
":",
"raise",
"Exception",
"except",
":",
"continue",
"result",
"=",
"filter_subsets",
"(",
"result",
")",
"return",
"[",
"PositionToken",
"(",
"content",
",",
"gd",
",",
"left",
",",
"right",
")",
"for",
"(",
"left",
",",
"right",
",",
"content",
",",
"gd",
")",
"in",
"result",
"]"
] | Receives a sequence and an alphabet,
returns a list of PositionTokens with all of the parts of the sequence that
are a subset of the alphabet | [
"Receives",
"a",
"sequence",
"and",
"an",
"alphabet",
"returns",
"a",
"list",
"of",
"PositionTokens",
"with",
"all",
"of",
"the",
"parts",
"of",
"the",
"sequence",
"that",
"are",
"a",
"subset",
"of",
"the",
"alphabet"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/extract.py#L44-L74 | train |
nesaro/pydsl | pydsl/extract.py | extract | def extract(grammar, inputdata, fixed_start = False, return_first=False):
"""
Receives a sequence and a grammar,
returns a list of PositionTokens with all of the parts of the sequence that
are recognized by the grammar
"""
if not inputdata:
return []
checker = checker_factory(grammar)
totallen = len(inputdata)
from pydsl.grammar.PEG import Choice
try:
maxl = grammar.maxsize or totallen
except NotImplementedError:
maxl = totallen
try:
#minl = grammar.minsize #FIXME: It won't work with incompatible alphabets
minl = 1
except NotImplementedError:
minl = 1
if fixed_start:
max_start = 1
else:
max_start = totallen
result = []
for i in range(max_start):
for j in range(i+minl, min(i+maxl, totallen) + 1):
slice = inputdata[i:j]
check = checker.check(slice)
if check:
this_pt = PositionToken(slice, grammar, i, j)
if return_first:
return this_pt
result.append(this_pt)
return result | python | def extract(grammar, inputdata, fixed_start = False, return_first=False):
"""
Receives a sequence and a grammar,
returns a list of PositionTokens with all of the parts of the sequence that
are recognized by the grammar
"""
if not inputdata:
return []
checker = checker_factory(grammar)
totallen = len(inputdata)
from pydsl.grammar.PEG import Choice
try:
maxl = grammar.maxsize or totallen
except NotImplementedError:
maxl = totallen
try:
#minl = grammar.minsize #FIXME: It won't work with incompatible alphabets
minl = 1
except NotImplementedError:
minl = 1
if fixed_start:
max_start = 1
else:
max_start = totallen
result = []
for i in range(max_start):
for j in range(i+minl, min(i+maxl, totallen) + 1):
slice = inputdata[i:j]
check = checker.check(slice)
if check:
this_pt = PositionToken(slice, grammar, i, j)
if return_first:
return this_pt
result.append(this_pt)
return result | [
"def",
"extract",
"(",
"grammar",
",",
"inputdata",
",",
"fixed_start",
"=",
"False",
",",
"return_first",
"=",
"False",
")",
":",
"if",
"not",
"inputdata",
":",
"return",
"[",
"]",
"checker",
"=",
"checker_factory",
"(",
"grammar",
")",
"totallen",
"=",
"len",
"(",
"inputdata",
")",
"from",
"pydsl",
".",
"grammar",
".",
"PEG",
"import",
"Choice",
"try",
":",
"maxl",
"=",
"grammar",
".",
"maxsize",
"or",
"totallen",
"except",
"NotImplementedError",
":",
"maxl",
"=",
"totallen",
"try",
":",
"#minl = grammar.minsize #FIXME: It won't work with incompatible alphabets",
"minl",
"=",
"1",
"except",
"NotImplementedError",
":",
"minl",
"=",
"1",
"if",
"fixed_start",
":",
"max_start",
"=",
"1",
"else",
":",
"max_start",
"=",
"totallen",
"result",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"max_start",
")",
":",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"minl",
",",
"min",
"(",
"i",
"+",
"maxl",
",",
"totallen",
")",
"+",
"1",
")",
":",
"slice",
"=",
"inputdata",
"[",
"i",
":",
"j",
"]",
"check",
"=",
"checker",
".",
"check",
"(",
"slice",
")",
"if",
"check",
":",
"this_pt",
"=",
"PositionToken",
"(",
"slice",
",",
"grammar",
",",
"i",
",",
"j",
")",
"if",
"return_first",
":",
"return",
"this_pt",
"result",
".",
"append",
"(",
"this_pt",
")",
"return",
"result"
] | Receives a sequence and a grammar,
returns a list of PositionTokens with all of the parts of the sequence that
are recognized by the grammar | [
"Receives",
"a",
"sequence",
"and",
"a",
"grammar",
"returns",
"a",
"list",
"of",
"PositionTokens",
"with",
"all",
"of",
"the",
"parts",
"of",
"the",
"sequence",
"that",
"are",
"recognized",
"by",
"the",
"grammar"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/extract.py#L76-L111 | train |
nesaro/pydsl | pydsl/token.py | append_position_to_token_list | def append_position_to_token_list(token_list):
"""Converts a list of Token into a list of Token, asuming size == 1"""
return [PositionToken(value.content, value.gd, index, index+1) for (index, value) in enumerate(token_list)] | python | def append_position_to_token_list(token_list):
"""Converts a list of Token into a list of Token, asuming size == 1"""
return [PositionToken(value.content, value.gd, index, index+1) for (index, value) in enumerate(token_list)] | [
"def",
"append_position_to_token_list",
"(",
"token_list",
")",
":",
"return",
"[",
"PositionToken",
"(",
"value",
".",
"content",
",",
"value",
".",
"gd",
",",
"index",
",",
"index",
"+",
"1",
")",
"for",
"(",
"index",
",",
"value",
")",
"in",
"enumerate",
"(",
"token_list",
")",
"]"
] | Converts a list of Token into a list of Token, asuming size == 1 | [
"Converts",
"a",
"list",
"of",
"Token",
"into",
"a",
"list",
"of",
"Token",
"asuming",
"size",
"==",
"1"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/token.py#L62-L64 | train |
nesaro/pydsl | pydsl/file/python.py | load_python_file | def load_python_file(moduleobject):
""" Try to create an indexable instance from a module"""
if isinstance(moduleobject, str):
moduleobject = load_module(moduleobject)
if not hasattr(moduleobject, "iclass"):
raise KeyError("Element" + str(moduleobject))
iclass = getattr(moduleobject, "iclass")
mylist = getattr(moduleobject, "__all__", None) or list(filter(lambda x:x[:1] != "_", (dir(moduleobject))))
mylist.remove('iclass')
resultdic = {}
for x in mylist:
resultdic[x] = getattr(moduleobject, x)
if iclass == "SymbolGrammar":
from pydsl.grammar.BNF import BNFGrammar
return BNFGrammar(**resultdic)
elif iclass == "PLY":
from pydsl.grammar.definition import PLYGrammar
return PLYGrammar(moduleobject)
elif iclass in ["PythonGrammar"]:
from pydsl.grammar.definition import PythonGrammar
return PythonGrammar(resultdic)
elif iclass == "PythonTranslator":
return resultdic
elif iclass == "parsley":
from pydsl.grammar.parsley import ParsleyGrammar
return ParsleyGrammar(**resultdic)
elif iclass == "pyparsing":
return resultdic['root_symbol']
else:
raise ValueError(str(moduleobject)) | python | def load_python_file(moduleobject):
""" Try to create an indexable instance from a module"""
if isinstance(moduleobject, str):
moduleobject = load_module(moduleobject)
if not hasattr(moduleobject, "iclass"):
raise KeyError("Element" + str(moduleobject))
iclass = getattr(moduleobject, "iclass")
mylist = getattr(moduleobject, "__all__", None) or list(filter(lambda x:x[:1] != "_", (dir(moduleobject))))
mylist.remove('iclass')
resultdic = {}
for x in mylist:
resultdic[x] = getattr(moduleobject, x)
if iclass == "SymbolGrammar":
from pydsl.grammar.BNF import BNFGrammar
return BNFGrammar(**resultdic)
elif iclass == "PLY":
from pydsl.grammar.definition import PLYGrammar
return PLYGrammar(moduleobject)
elif iclass in ["PythonGrammar"]:
from pydsl.grammar.definition import PythonGrammar
return PythonGrammar(resultdic)
elif iclass == "PythonTranslator":
return resultdic
elif iclass == "parsley":
from pydsl.grammar.parsley import ParsleyGrammar
return ParsleyGrammar(**resultdic)
elif iclass == "pyparsing":
return resultdic['root_symbol']
else:
raise ValueError(str(moduleobject)) | [
"def",
"load_python_file",
"(",
"moduleobject",
")",
":",
"if",
"isinstance",
"(",
"moduleobject",
",",
"str",
")",
":",
"moduleobject",
"=",
"load_module",
"(",
"moduleobject",
")",
"if",
"not",
"hasattr",
"(",
"moduleobject",
",",
"\"iclass\"",
")",
":",
"raise",
"KeyError",
"(",
"\"Element\"",
"+",
"str",
"(",
"moduleobject",
")",
")",
"iclass",
"=",
"getattr",
"(",
"moduleobject",
",",
"\"iclass\"",
")",
"mylist",
"=",
"getattr",
"(",
"moduleobject",
",",
"\"__all__\"",
",",
"None",
")",
"or",
"list",
"(",
"filter",
"(",
"lambda",
"x",
":",
"x",
"[",
":",
"1",
"]",
"!=",
"\"_\"",
",",
"(",
"dir",
"(",
"moduleobject",
")",
")",
")",
")",
"mylist",
".",
"remove",
"(",
"'iclass'",
")",
"resultdic",
"=",
"{",
"}",
"for",
"x",
"in",
"mylist",
":",
"resultdic",
"[",
"x",
"]",
"=",
"getattr",
"(",
"moduleobject",
",",
"x",
")",
"if",
"iclass",
"==",
"\"SymbolGrammar\"",
":",
"from",
"pydsl",
".",
"grammar",
".",
"BNF",
"import",
"BNFGrammar",
"return",
"BNFGrammar",
"(",
"*",
"*",
"resultdic",
")",
"elif",
"iclass",
"==",
"\"PLY\"",
":",
"from",
"pydsl",
".",
"grammar",
".",
"definition",
"import",
"PLYGrammar",
"return",
"PLYGrammar",
"(",
"moduleobject",
")",
"elif",
"iclass",
"in",
"[",
"\"PythonGrammar\"",
"]",
":",
"from",
"pydsl",
".",
"grammar",
".",
"definition",
"import",
"PythonGrammar",
"return",
"PythonGrammar",
"(",
"resultdic",
")",
"elif",
"iclass",
"==",
"\"PythonTranslator\"",
":",
"return",
"resultdic",
"elif",
"iclass",
"==",
"\"parsley\"",
":",
"from",
"pydsl",
".",
"grammar",
".",
"parsley",
"import",
"ParsleyGrammar",
"return",
"ParsleyGrammar",
"(",
"*",
"*",
"resultdic",
")",
"elif",
"iclass",
"==",
"\"pyparsing\"",
":",
"return",
"resultdic",
"[",
"'root_symbol'",
"]",
"else",
":",
"raise",
"ValueError",
"(",
"str",
"(",
"moduleobject",
")",
")"
] | Try to create an indexable instance from a module | [
"Try",
"to",
"create",
"an",
"indexable",
"instance",
"from",
"a",
"module"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/file/python.py#L34-L63 | train |
nesaro/pydsl | pydsl/file/BNF.py | load_bnf_file | def load_bnf_file(filepath, repository = None):
"""Converts a bnf file into a BNFGrammar instance"""
linelist = []
with open(filepath,'r') as mlfile:
for line in mlfile:
linelist.append(line)
return strlist_to_production_set(linelist, repository) | python | def load_bnf_file(filepath, repository = None):
"""Converts a bnf file into a BNFGrammar instance"""
linelist = []
with open(filepath,'r') as mlfile:
for line in mlfile:
linelist.append(line)
return strlist_to_production_set(linelist, repository) | [
"def",
"load_bnf_file",
"(",
"filepath",
",",
"repository",
"=",
"None",
")",
":",
"linelist",
"=",
"[",
"]",
"with",
"open",
"(",
"filepath",
",",
"'r'",
")",
"as",
"mlfile",
":",
"for",
"line",
"in",
"mlfile",
":",
"linelist",
".",
"append",
"(",
"line",
")",
"return",
"strlist_to_production_set",
"(",
"linelist",
",",
"repository",
")"
] | Converts a bnf file into a BNFGrammar instance | [
"Converts",
"a",
"bnf",
"file",
"into",
"a",
"BNFGrammar",
"instance"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/file/BNF.py#L141-L147 | train |
nesaro/pydsl | pydsl/file/regexp.py | load_re_from_file | def load_re_from_file(filepath):
"""Converts a re file to Regular Grammar instance"""
regexp = None
with open(filepath,'r') as mlfile:
flagstr = ""
for line in mlfile:
cleanline = re.sub("//.*$", "", line)
if re.search("^\s*$", cleanline):
continue
if re.search ("^#.*$", cleanline):
flagstr = cleanline[1:]
continue
if regexp is not None:
raise Exception("Regular expression file format error")
else:
regexp = cleanline.rstrip('\n')
flags = 0
if "i" in flagstr:
flags |= re.I
from pydsl.grammar.definition import RegularExpression
return RegularExpression(regexp, flags) | python | def load_re_from_file(filepath):
"""Converts a re file to Regular Grammar instance"""
regexp = None
with open(filepath,'r') as mlfile:
flagstr = ""
for line in mlfile:
cleanline = re.sub("//.*$", "", line)
if re.search("^\s*$", cleanline):
continue
if re.search ("^#.*$", cleanline):
flagstr = cleanline[1:]
continue
if regexp is not None:
raise Exception("Regular expression file format error")
else:
regexp = cleanline.rstrip('\n')
flags = 0
if "i" in flagstr:
flags |= re.I
from pydsl.grammar.definition import RegularExpression
return RegularExpression(regexp, flags) | [
"def",
"load_re_from_file",
"(",
"filepath",
")",
":",
"regexp",
"=",
"None",
"with",
"open",
"(",
"filepath",
",",
"'r'",
")",
"as",
"mlfile",
":",
"flagstr",
"=",
"\"\"",
"for",
"line",
"in",
"mlfile",
":",
"cleanline",
"=",
"re",
".",
"sub",
"(",
"\"//.*$\"",
",",
"\"\"",
",",
"line",
")",
"if",
"re",
".",
"search",
"(",
"\"^\\s*$\"",
",",
"cleanline",
")",
":",
"continue",
"if",
"re",
".",
"search",
"(",
"\"^#.*$\"",
",",
"cleanline",
")",
":",
"flagstr",
"=",
"cleanline",
"[",
"1",
":",
"]",
"continue",
"if",
"regexp",
"is",
"not",
"None",
":",
"raise",
"Exception",
"(",
"\"Regular expression file format error\"",
")",
"else",
":",
"regexp",
"=",
"cleanline",
".",
"rstrip",
"(",
"'\\n'",
")",
"flags",
"=",
"0",
"if",
"\"i\"",
"in",
"flagstr",
":",
"flags",
"|=",
"re",
".",
"I",
"from",
"pydsl",
".",
"grammar",
".",
"definition",
"import",
"RegularExpression",
"return",
"RegularExpression",
"(",
"regexp",
",",
"flags",
")"
] | Converts a re file to Regular Grammar instance | [
"Converts",
"a",
"re",
"file",
"to",
"Regular",
"Grammar",
"instance"
] | 00b4fffd72036b80335e1a44a888fac57917ab41 | https://github.com/nesaro/pydsl/blob/00b4fffd72036b80335e1a44a888fac57917ab41/pydsl/file/regexp.py#L28-L48 | train |
aio-libs/aiohttp-jinja2 | aiohttp_jinja2/helpers.py | url_for | def url_for(context, __route_name, **parts):
"""Filter for generating urls.
Usage: {{ url('the-view-name') }} might become "/path/to/view" or
{{ url('item-details', id=123, query={'active': 'true'}) }}
might become "/items/1?active=true".
"""
app = context['app']
query = None
if 'query_' in parts:
query = parts.pop('query_')
for key in parts:
val = parts[key]
if isinstance(val, str):
# if type is inherited from str expilict cast to str makes sense
# if type is exactly str the operation is very fast
val = str(val)
elif type(val) is int:
# int inherited classes like bool are forbidden
val = str(val)
else:
raise TypeError("argument value should be str or int, "
"got {} -> [{}] {!r}".format(key, type(val), val))
parts[key] = val
url = app.router[__route_name].url_for(**parts)
if query:
url = url.with_query(query)
return url | python | def url_for(context, __route_name, **parts):
"""Filter for generating urls.
Usage: {{ url('the-view-name') }} might become "/path/to/view" or
{{ url('item-details', id=123, query={'active': 'true'}) }}
might become "/items/1?active=true".
"""
app = context['app']
query = None
if 'query_' in parts:
query = parts.pop('query_')
for key in parts:
val = parts[key]
if isinstance(val, str):
# if type is inherited from str expilict cast to str makes sense
# if type is exactly str the operation is very fast
val = str(val)
elif type(val) is int:
# int inherited classes like bool are forbidden
val = str(val)
else:
raise TypeError("argument value should be str or int, "
"got {} -> [{}] {!r}".format(key, type(val), val))
parts[key] = val
url = app.router[__route_name].url_for(**parts)
if query:
url = url.with_query(query)
return url | [
"def",
"url_for",
"(",
"context",
",",
"__route_name",
",",
"*",
"*",
"parts",
")",
":",
"app",
"=",
"context",
"[",
"'app'",
"]",
"query",
"=",
"None",
"if",
"'query_'",
"in",
"parts",
":",
"query",
"=",
"parts",
".",
"pop",
"(",
"'query_'",
")",
"for",
"key",
"in",
"parts",
":",
"val",
"=",
"parts",
"[",
"key",
"]",
"if",
"isinstance",
"(",
"val",
",",
"str",
")",
":",
"# if type is inherited from str expilict cast to str makes sense",
"# if type is exactly str the operation is very fast",
"val",
"=",
"str",
"(",
"val",
")",
"elif",
"type",
"(",
"val",
")",
"is",
"int",
":",
"# int inherited classes like bool are forbidden",
"val",
"=",
"str",
"(",
"val",
")",
"else",
":",
"raise",
"TypeError",
"(",
"\"argument value should be str or int, \"",
"\"got {} -> [{}] {!r}\"",
".",
"format",
"(",
"key",
",",
"type",
"(",
"val",
")",
",",
"val",
")",
")",
"parts",
"[",
"key",
"]",
"=",
"val",
"url",
"=",
"app",
".",
"router",
"[",
"__route_name",
"]",
".",
"url_for",
"(",
"*",
"*",
"parts",
")",
"if",
"query",
":",
"url",
"=",
"url",
".",
"with_query",
"(",
"query",
")",
"return",
"url"
] | Filter for generating urls.
Usage: {{ url('the-view-name') }} might become "/path/to/view" or
{{ url('item-details', id=123, query={'active': 'true'}) }}
might become "/items/1?active=true". | [
"Filter",
"for",
"generating",
"urls",
"."
] | 474a852c8b29dc69106bf4aba28a9c99cf63dac9 | https://github.com/aio-libs/aiohttp-jinja2/blob/474a852c8b29dc69106bf4aba28a9c99cf63dac9/aiohttp_jinja2/helpers.py#L9-L39 | train |
aio-libs/aiohttp-jinja2 | aiohttp_jinja2/helpers.py | static_url | def static_url(context, static_file_path):
"""Filter for generating urls for static files.
NOTE: you'll need
to set app['static_root_url'] to be used as the root for the urls returned.
Usage: {{ static('styles.css') }} might become
"/static/styles.css" or "http://mycdn.example.com/styles.css"
"""
app = context['app']
try:
static_url = app['static_root_url']
except KeyError:
raise RuntimeError(
"app does not define a static root url "
"'static_root_url', you need to set the url root "
"with app['static_root_url'] = '<static root>'.") from None
return '{}/{}'.format(static_url.rstrip('/'), static_file_path.lstrip('/')) | python | def static_url(context, static_file_path):
"""Filter for generating urls for static files.
NOTE: you'll need
to set app['static_root_url'] to be used as the root for the urls returned.
Usage: {{ static('styles.css') }} might become
"/static/styles.css" or "http://mycdn.example.com/styles.css"
"""
app = context['app']
try:
static_url = app['static_root_url']
except KeyError:
raise RuntimeError(
"app does not define a static root url "
"'static_root_url', you need to set the url root "
"with app['static_root_url'] = '<static root>'.") from None
return '{}/{}'.format(static_url.rstrip('/'), static_file_path.lstrip('/')) | [
"def",
"static_url",
"(",
"context",
",",
"static_file_path",
")",
":",
"app",
"=",
"context",
"[",
"'app'",
"]",
"try",
":",
"static_url",
"=",
"app",
"[",
"'static_root_url'",
"]",
"except",
"KeyError",
":",
"raise",
"RuntimeError",
"(",
"\"app does not define a static root url \"",
"\"'static_root_url', you need to set the url root \"",
"\"with app['static_root_url'] = '<static root>'.\"",
")",
"from",
"None",
"return",
"'{}/{}'",
".",
"format",
"(",
"static_url",
".",
"rstrip",
"(",
"'/'",
")",
",",
"static_file_path",
".",
"lstrip",
"(",
"'/'",
")",
")"
] | Filter for generating urls for static files.
NOTE: you'll need
to set app['static_root_url'] to be used as the root for the urls returned.
Usage: {{ static('styles.css') }} might become
"/static/styles.css" or "http://mycdn.example.com/styles.css" | [
"Filter",
"for",
"generating",
"urls",
"for",
"static",
"files",
"."
] | 474a852c8b29dc69106bf4aba28a9c99cf63dac9 | https://github.com/aio-libs/aiohttp-jinja2/blob/474a852c8b29dc69106bf4aba28a9c99cf63dac9/aiohttp_jinja2/helpers.py#L43-L60 | train |
cmbruns/pyopenvr | src/openvr/gl_renderer.py | OpenVrGlRenderer.init_gl | def init_gl(self):
"allocate OpenGL resources"
self.vr_system = openvr.init(openvr.VRApplication_Scene)
w, h = self.vr_system.getRecommendedRenderTargetSize()
self.left_fb = OpenVrFramebuffer(w, h, multisample=self.multisample)
self.right_fb = OpenVrFramebuffer(w, h, multisample=self.multisample)
self.compositor = openvr.VRCompositor()
if self.compositor is None:
raise Exception("Unable to create compositor")
self.left_fb.init_gl()
self.right_fb.init_gl()
# Compute projection matrix
zNear = 0.2
zFar = 500.0
self.projection_left = numpy.asarray(matrixForOpenVrMatrix(self.vr_system.getProjectionMatrix(
openvr.Eye_Left,
zNear, zFar)))
self.projection_right = numpy.asarray(matrixForOpenVrMatrix(self.vr_system.getProjectionMatrix(
openvr.Eye_Right,
zNear, zFar)))
self.view_left = matrixForOpenVrMatrix(
self.vr_system.getEyeToHeadTransform(openvr.Eye_Left)).I # head_X_eye in Kane notation
self.view_right = matrixForOpenVrMatrix(
self.vr_system.getEyeToHeadTransform(openvr.Eye_Right)).I # head_X_eye in Kane notation
for actor in self:
actor.init_gl() | python | def init_gl(self):
"allocate OpenGL resources"
self.vr_system = openvr.init(openvr.VRApplication_Scene)
w, h = self.vr_system.getRecommendedRenderTargetSize()
self.left_fb = OpenVrFramebuffer(w, h, multisample=self.multisample)
self.right_fb = OpenVrFramebuffer(w, h, multisample=self.multisample)
self.compositor = openvr.VRCompositor()
if self.compositor is None:
raise Exception("Unable to create compositor")
self.left_fb.init_gl()
self.right_fb.init_gl()
# Compute projection matrix
zNear = 0.2
zFar = 500.0
self.projection_left = numpy.asarray(matrixForOpenVrMatrix(self.vr_system.getProjectionMatrix(
openvr.Eye_Left,
zNear, zFar)))
self.projection_right = numpy.asarray(matrixForOpenVrMatrix(self.vr_system.getProjectionMatrix(
openvr.Eye_Right,
zNear, zFar)))
self.view_left = matrixForOpenVrMatrix(
self.vr_system.getEyeToHeadTransform(openvr.Eye_Left)).I # head_X_eye in Kane notation
self.view_right = matrixForOpenVrMatrix(
self.vr_system.getEyeToHeadTransform(openvr.Eye_Right)).I # head_X_eye in Kane notation
for actor in self:
actor.init_gl() | [
"def",
"init_gl",
"(",
"self",
")",
":",
"self",
".",
"vr_system",
"=",
"openvr",
".",
"init",
"(",
"openvr",
".",
"VRApplication_Scene",
")",
"w",
",",
"h",
"=",
"self",
".",
"vr_system",
".",
"getRecommendedRenderTargetSize",
"(",
")",
"self",
".",
"left_fb",
"=",
"OpenVrFramebuffer",
"(",
"w",
",",
"h",
",",
"multisample",
"=",
"self",
".",
"multisample",
")",
"self",
".",
"right_fb",
"=",
"OpenVrFramebuffer",
"(",
"w",
",",
"h",
",",
"multisample",
"=",
"self",
".",
"multisample",
")",
"self",
".",
"compositor",
"=",
"openvr",
".",
"VRCompositor",
"(",
")",
"if",
"self",
".",
"compositor",
"is",
"None",
":",
"raise",
"Exception",
"(",
"\"Unable to create compositor\"",
")",
"self",
".",
"left_fb",
".",
"init_gl",
"(",
")",
"self",
".",
"right_fb",
".",
"init_gl",
"(",
")",
"# Compute projection matrix",
"zNear",
"=",
"0.2",
"zFar",
"=",
"500.0",
"self",
".",
"projection_left",
"=",
"numpy",
".",
"asarray",
"(",
"matrixForOpenVrMatrix",
"(",
"self",
".",
"vr_system",
".",
"getProjectionMatrix",
"(",
"openvr",
".",
"Eye_Left",
",",
"zNear",
",",
"zFar",
")",
")",
")",
"self",
".",
"projection_right",
"=",
"numpy",
".",
"asarray",
"(",
"matrixForOpenVrMatrix",
"(",
"self",
".",
"vr_system",
".",
"getProjectionMatrix",
"(",
"openvr",
".",
"Eye_Right",
",",
"zNear",
",",
"zFar",
")",
")",
")",
"self",
".",
"view_left",
"=",
"matrixForOpenVrMatrix",
"(",
"self",
".",
"vr_system",
".",
"getEyeToHeadTransform",
"(",
"openvr",
".",
"Eye_Left",
")",
")",
".",
"I",
"# head_X_eye in Kane notation",
"self",
".",
"view_right",
"=",
"matrixForOpenVrMatrix",
"(",
"self",
".",
"vr_system",
".",
"getEyeToHeadTransform",
"(",
"openvr",
".",
"Eye_Right",
")",
")",
".",
"I",
"# head_X_eye in Kane notation",
"for",
"actor",
"in",
"self",
":",
"actor",
".",
"init_gl",
"(",
")"
] | allocate OpenGL resources | [
"allocate",
"OpenGL",
"resources"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/gl_renderer.py#L144-L169 | train |
cmbruns/pyopenvr | src/samples/glut/pink_world.py | PinkWorld.display | def display(self):
"Renders the scene once every refresh"
self.compositor.waitGetPoses(self.poses, openvr.k_unMaxTrackedDeviceCount, None, 0)
hmd_pose0 = self.poses[openvr.k_unTrackedDeviceIndex_Hmd]
if not hmd_pose0.bPoseIsValid:
return
# hmd_pose = hmd_pose0.mDeviceToAbsoluteTracking
# 1) On-screen render:
if True:
glClearColor(0.8, 0.4, 0.4, 0) # Pink background
glClear(GL_COLOR_BUFFER_BIT)
# glutSwapBuffers()
glFlush() # Single buffer
# 2) VR render
# TODO: render different things to each eye
glBindFramebuffer(GL_FRAMEBUFFER, self.fb)
glClearColor(0.8, 0.4, 0.4, 0) # Pink background
glClear(GL_COLOR_BUFFER_BIT)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
#
# TODO: use different textures for each eye
self.compositor.submit(openvr.Eye_Left, self.texture)
self.compositor.submit(openvr.Eye_Right, self.texture)
glBindFramebuffer(GL_FRAMEBUFFER, 0) | python | def display(self):
"Renders the scene once every refresh"
self.compositor.waitGetPoses(self.poses, openvr.k_unMaxTrackedDeviceCount, None, 0)
hmd_pose0 = self.poses[openvr.k_unTrackedDeviceIndex_Hmd]
if not hmd_pose0.bPoseIsValid:
return
# hmd_pose = hmd_pose0.mDeviceToAbsoluteTracking
# 1) On-screen render:
if True:
glClearColor(0.8, 0.4, 0.4, 0) # Pink background
glClear(GL_COLOR_BUFFER_BIT)
# glutSwapBuffers()
glFlush() # Single buffer
# 2) VR render
# TODO: render different things to each eye
glBindFramebuffer(GL_FRAMEBUFFER, self.fb)
glClearColor(0.8, 0.4, 0.4, 0) # Pink background
glClear(GL_COLOR_BUFFER_BIT)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
#
# TODO: use different textures for each eye
self.compositor.submit(openvr.Eye_Left, self.texture)
self.compositor.submit(openvr.Eye_Right, self.texture)
glBindFramebuffer(GL_FRAMEBUFFER, 0) | [
"def",
"display",
"(",
"self",
")",
":",
"self",
".",
"compositor",
".",
"waitGetPoses",
"(",
"self",
".",
"poses",
",",
"openvr",
".",
"k_unMaxTrackedDeviceCount",
",",
"None",
",",
"0",
")",
"hmd_pose0",
"=",
"self",
".",
"poses",
"[",
"openvr",
".",
"k_unTrackedDeviceIndex_Hmd",
"]",
"if",
"not",
"hmd_pose0",
".",
"bPoseIsValid",
":",
"return",
"# hmd_pose = hmd_pose0.mDeviceToAbsoluteTracking\r",
"# 1) On-screen render:\r",
"if",
"True",
":",
"glClearColor",
"(",
"0.8",
",",
"0.4",
",",
"0.4",
",",
"0",
")",
"# Pink background\r",
"glClear",
"(",
"GL_COLOR_BUFFER_BIT",
")",
"# glutSwapBuffers()\r",
"glFlush",
"(",
")",
"# Single buffer\r",
"# 2) VR render\r",
"# TODO: render different things to each eye\r",
"glBindFramebuffer",
"(",
"GL_FRAMEBUFFER",
",",
"self",
".",
"fb",
")",
"glClearColor",
"(",
"0.8",
",",
"0.4",
",",
"0.4",
",",
"0",
")",
"# Pink background\r",
"glClear",
"(",
"GL_COLOR_BUFFER_BIT",
")",
"glBindFramebuffer",
"(",
"GL_FRAMEBUFFER",
",",
"0",
")",
"#\r",
"# TODO: use different textures for each eye\r",
"self",
".",
"compositor",
".",
"submit",
"(",
"openvr",
".",
"Eye_Left",
",",
"self",
".",
"texture",
")",
"self",
".",
"compositor",
".",
"submit",
"(",
"openvr",
".",
"Eye_Right",
",",
"self",
".",
"texture",
")",
"glBindFramebuffer",
"(",
"GL_FRAMEBUFFER",
",",
"0",
")"
] | Renders the scene once every refresh | [
"Renders",
"the",
"scene",
"once",
"every",
"refresh"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/samples/glut/pink_world.py#L93-L116 | train |
cmbruns/pyopenvr | src/samples/glut/pink_world.py | PinkWorld.key_press | def key_press(self, key, x, y):
"Close the application when the player presses ESCAPE"
if ord(key) == 27:
# print "Escape!"
if bool(glutLeaveMainLoop):
glutLeaveMainLoop()
else:
raise Exception("Application quit") | python | def key_press(self, key, x, y):
"Close the application when the player presses ESCAPE"
if ord(key) == 27:
# print "Escape!"
if bool(glutLeaveMainLoop):
glutLeaveMainLoop()
else:
raise Exception("Application quit") | [
"def",
"key_press",
"(",
"self",
",",
"key",
",",
"x",
",",
"y",
")",
":",
"if",
"ord",
"(",
"key",
")",
"==",
"27",
":",
"# print \"Escape!\"\r",
"if",
"bool",
"(",
"glutLeaveMainLoop",
")",
":",
"glutLeaveMainLoop",
"(",
")",
"else",
":",
"raise",
"Exception",
"(",
"\"Application quit\"",
")"
] | Close the application when the player presses ESCAPE | [
"Close",
"the",
"application",
"when",
"the",
"player",
"presses",
"ESCAPE"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/samples/glut/pink_world.py#L118-L125 | train |
cmbruns/pyopenvr | src/openvr/glframework/cyglfw3_app.py | CyGLFW3App.key_callback | def key_callback(self, window, key, scancode, action, mods):
"""press ESCAPE to quite the application"""
if key == glfw.KEY_ESCAPE and action == glfw.PRESS:
glfw.SetWindowShouldClose(self.window, True) | python | def key_callback(self, window, key, scancode, action, mods):
"""press ESCAPE to quite the application"""
if key == glfw.KEY_ESCAPE and action == glfw.PRESS:
glfw.SetWindowShouldClose(self.window, True) | [
"def",
"key_callback",
"(",
"self",
",",
"window",
",",
"key",
",",
"scancode",
",",
"action",
",",
"mods",
")",
":",
"if",
"key",
"==",
"glfw",
".",
"KEY_ESCAPE",
"and",
"action",
"==",
"glfw",
".",
"PRESS",
":",
"glfw",
".",
"SetWindowShouldClose",
"(",
"self",
".",
"window",
",",
"True",
")"
] | press ESCAPE to quite the application | [
"press",
"ESCAPE",
"to",
"quite",
"the",
"application"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/glframework/cyglfw3_app.py#L66-L69 | train |
cmbruns/pyopenvr | src/openvr/glframework/sdl_app.py | SdlApp.run_loop | def run_loop(self):
"keep rendering until the user says quit"
self.running = True
event = SDL_Event()
try:
while self.running:
while SDL_PollEvent(ctypes.byref(event)) != 0:
f = self._sdl_event_handlers.get(event.type)
if f is not None:
f ( event )
self.render_scene()
except SdlAppQuit as e:
pass | python | def run_loop(self):
"keep rendering until the user says quit"
self.running = True
event = SDL_Event()
try:
while self.running:
while SDL_PollEvent(ctypes.byref(event)) != 0:
f = self._sdl_event_handlers.get(event.type)
if f is not None:
f ( event )
self.render_scene()
except SdlAppQuit as e:
pass | [
"def",
"run_loop",
"(",
"self",
")",
":",
"self",
".",
"running",
"=",
"True",
"event",
"=",
"SDL_Event",
"(",
")",
"try",
":",
"while",
"self",
".",
"running",
":",
"while",
"SDL_PollEvent",
"(",
"ctypes",
".",
"byref",
"(",
"event",
")",
")",
"!=",
"0",
":",
"f",
"=",
"self",
".",
"_sdl_event_handlers",
".",
"get",
"(",
"event",
".",
"type",
")",
"if",
"f",
"is",
"not",
"None",
":",
"f",
"(",
"event",
")",
"self",
".",
"render_scene",
"(",
")",
"except",
"SdlAppQuit",
"as",
"e",
":",
"pass"
] | keep rendering until the user says quit | [
"keep",
"rendering",
"until",
"the",
"user",
"says",
"quit"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/glframework/sdl_app.py#L112-L124 | train |
cmbruns/pyopenvr | src/samples/sdl/NOTWORKING_hellovr_opengl_sdl.py | Matrix4.scale | def scale(self, x, y=None, z=None):
"Uniform scale, if only sx argument is specified"
if y is None:
y = x
if z is None:
z = x
m = self
for col in range(4):
# Only the top three rows
m[0,col] *= x
m[1,col] *= y
m[2,col] *= z
return self | python | def scale(self, x, y=None, z=None):
"Uniform scale, if only sx argument is specified"
if y is None:
y = x
if z is None:
z = x
m = self
for col in range(4):
# Only the top three rows
m[0,col] *= x
m[1,col] *= y
m[2,col] *= z
return self | [
"def",
"scale",
"(",
"self",
",",
"x",
",",
"y",
"=",
"None",
",",
"z",
"=",
"None",
")",
":",
"if",
"y",
"is",
"None",
":",
"y",
"=",
"x",
"if",
"z",
"is",
"None",
":",
"z",
"=",
"x",
"m",
"=",
"self",
"for",
"col",
"in",
"range",
"(",
"4",
")",
":",
"# Only the top three rows\r",
"m",
"[",
"0",
",",
"col",
"]",
"*=",
"x",
"m",
"[",
"1",
",",
"col",
"]",
"*=",
"y",
"m",
"[",
"2",
",",
"col",
"]",
"*=",
"z",
"return",
"self"
] | Uniform scale, if only sx argument is specified | [
"Uniform",
"scale",
"if",
"only",
"sx",
"argument",
"is",
"specified"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/samples/sdl/NOTWORKING_hellovr_opengl_sdl.py#L160-L172 | train |
cmbruns/pyopenvr | src/openvr/tracked_devices_actor.py | TrackedDevicesActor._check_devices | def _check_devices(self):
"Enumerate OpenVR tracked devices and check whether any need to be initialized"
for i in range(1, len(self.poses)):
pose = self.poses[i]
if not pose.bDeviceIsConnected:
continue
if not pose.bPoseIsValid:
continue
if self.show_controllers_only:
device_class = openvr.VRSystem().getTrackedDeviceClass(i)
if not device_class == openvr.TrackedDeviceClass_Controller:
continue
model_name = openvr.VRSystem().getStringTrackedDeviceProperty(i, openvr.Prop_RenderModelName_String)
# Create a new mesh object, if necessary
if model_name not in self.meshes:
self.meshes[model_name] = TrackedDeviceMesh(model_name) | python | def _check_devices(self):
"Enumerate OpenVR tracked devices and check whether any need to be initialized"
for i in range(1, len(self.poses)):
pose = self.poses[i]
if not pose.bDeviceIsConnected:
continue
if not pose.bPoseIsValid:
continue
if self.show_controllers_only:
device_class = openvr.VRSystem().getTrackedDeviceClass(i)
if not device_class == openvr.TrackedDeviceClass_Controller:
continue
model_name = openvr.VRSystem().getStringTrackedDeviceProperty(i, openvr.Prop_RenderModelName_String)
# Create a new mesh object, if necessary
if model_name not in self.meshes:
self.meshes[model_name] = TrackedDeviceMesh(model_name) | [
"def",
"_check_devices",
"(",
"self",
")",
":",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"self",
".",
"poses",
")",
")",
":",
"pose",
"=",
"self",
".",
"poses",
"[",
"i",
"]",
"if",
"not",
"pose",
".",
"bDeviceIsConnected",
":",
"continue",
"if",
"not",
"pose",
".",
"bPoseIsValid",
":",
"continue",
"if",
"self",
".",
"show_controllers_only",
":",
"device_class",
"=",
"openvr",
".",
"VRSystem",
"(",
")",
".",
"getTrackedDeviceClass",
"(",
"i",
")",
"if",
"not",
"device_class",
"==",
"openvr",
".",
"TrackedDeviceClass_Controller",
":",
"continue",
"model_name",
"=",
"openvr",
".",
"VRSystem",
"(",
")",
".",
"getStringTrackedDeviceProperty",
"(",
"i",
",",
"openvr",
".",
"Prop_RenderModelName_String",
")",
"# Create a new mesh object, if necessary",
"if",
"model_name",
"not",
"in",
"self",
".",
"meshes",
":",
"self",
".",
"meshes",
"[",
"model_name",
"]",
"=",
"TrackedDeviceMesh",
"(",
"model_name",
")"
] | Enumerate OpenVR tracked devices and check whether any need to be initialized | [
"Enumerate",
"OpenVR",
"tracked",
"devices",
"and",
"check",
"whether",
"any",
"need",
"to",
"be",
"initialized"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/tracked_devices_actor.py#L144-L159 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | getGenericInterface | def getGenericInterface(interfaceVersion):
"""
Returns the interface of the specified version. This method must be called after VR_Init. The
pointer returned is valid until VR_Shutdown is called.
"""
error = EVRInitError()
result = _openvr.VR_GetGenericInterface(interfaceVersion, byref(error))
_checkInitError(error.value)
return result | python | def getGenericInterface(interfaceVersion):
"""
Returns the interface of the specified version. This method must be called after VR_Init. The
pointer returned is valid until VR_Shutdown is called.
"""
error = EVRInitError()
result = _openvr.VR_GetGenericInterface(interfaceVersion, byref(error))
_checkInitError(error.value)
return result | [
"def",
"getGenericInterface",
"(",
"interfaceVersion",
")",
":",
"error",
"=",
"EVRInitError",
"(",
")",
"result",
"=",
"_openvr",
".",
"VR_GetGenericInterface",
"(",
"interfaceVersion",
",",
"byref",
"(",
"error",
")",
")",
"_checkInitError",
"(",
"error",
".",
"value",
")",
"return",
"result"
] | Returns the interface of the specified version. This method must be called after VR_Init. The
pointer returned is valid until VR_Shutdown is called. | [
"Returns",
"the",
"interface",
"of",
"the",
"specified",
"version",
".",
"This",
"method",
"must",
"be",
"called",
"after",
"VR_Init",
".",
"The",
"pointer",
"returned",
"is",
"valid",
"until",
"VR_Shutdown",
"is",
"called",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L6414-L6422 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getRecommendedRenderTargetSize | def getRecommendedRenderTargetSize(self):
"""Suggested size for the intermediate render target that the distortion pulls from."""
fn = self.function_table.getRecommendedRenderTargetSize
pnWidth = c_uint32()
pnHeight = c_uint32()
fn(byref(pnWidth), byref(pnHeight))
return pnWidth.value, pnHeight.value | python | def getRecommendedRenderTargetSize(self):
"""Suggested size for the intermediate render target that the distortion pulls from."""
fn = self.function_table.getRecommendedRenderTargetSize
pnWidth = c_uint32()
pnHeight = c_uint32()
fn(byref(pnWidth), byref(pnHeight))
return pnWidth.value, pnHeight.value | [
"def",
"getRecommendedRenderTargetSize",
"(",
"self",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getRecommendedRenderTargetSize",
"pnWidth",
"=",
"c_uint32",
"(",
")",
"pnHeight",
"=",
"c_uint32",
"(",
")",
"fn",
"(",
"byref",
"(",
"pnWidth",
")",
",",
"byref",
"(",
"pnHeight",
")",
")",
"return",
"pnWidth",
".",
"value",
",",
"pnHeight",
".",
"value"
] | Suggested size for the intermediate render target that the distortion pulls from. | [
"Suggested",
"size",
"for",
"the",
"intermediate",
"render",
"target",
"that",
"the",
"distortion",
"pulls",
"from",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2628-L2635 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getProjectionMatrix | def getProjectionMatrix(self, eEye, fNearZ, fFarZ):
"""The projection matrix for the specified eye"""
fn = self.function_table.getProjectionMatrix
result = fn(eEye, fNearZ, fFarZ)
return result | python | def getProjectionMatrix(self, eEye, fNearZ, fFarZ):
"""The projection matrix for the specified eye"""
fn = self.function_table.getProjectionMatrix
result = fn(eEye, fNearZ, fFarZ)
return result | [
"def",
"getProjectionMatrix",
"(",
"self",
",",
"eEye",
",",
"fNearZ",
",",
"fFarZ",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getProjectionMatrix",
"result",
"=",
"fn",
"(",
"eEye",
",",
"fNearZ",
",",
"fFarZ",
")",
"return",
"result"
] | The projection matrix for the specified eye | [
"The",
"projection",
"matrix",
"for",
"the",
"specified",
"eye"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2637-L2642 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getProjectionRaw | def getProjectionRaw(self, eEye):
"""
The components necessary to build your own projection matrix in case your
application is doing something fancy like infinite Z
"""
fn = self.function_table.getProjectionRaw
pfLeft = c_float()
pfRight = c_float()
pfTop = c_float()
pfBottom = c_float()
fn(eEye, byref(pfLeft), byref(pfRight), byref(pfTop), byref(pfBottom))
return pfLeft.value, pfRight.value, pfTop.value, pfBottom.value | python | def getProjectionRaw(self, eEye):
"""
The components necessary to build your own projection matrix in case your
application is doing something fancy like infinite Z
"""
fn = self.function_table.getProjectionRaw
pfLeft = c_float()
pfRight = c_float()
pfTop = c_float()
pfBottom = c_float()
fn(eEye, byref(pfLeft), byref(pfRight), byref(pfTop), byref(pfBottom))
return pfLeft.value, pfRight.value, pfTop.value, pfBottom.value | [
"def",
"getProjectionRaw",
"(",
"self",
",",
"eEye",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getProjectionRaw",
"pfLeft",
"=",
"c_float",
"(",
")",
"pfRight",
"=",
"c_float",
"(",
")",
"pfTop",
"=",
"c_float",
"(",
")",
"pfBottom",
"=",
"c_float",
"(",
")",
"fn",
"(",
"eEye",
",",
"byref",
"(",
"pfLeft",
")",
",",
"byref",
"(",
"pfRight",
")",
",",
"byref",
"(",
"pfTop",
")",
",",
"byref",
"(",
"pfBottom",
")",
")",
"return",
"pfLeft",
".",
"value",
",",
"pfRight",
".",
"value",
",",
"pfTop",
".",
"value",
",",
"pfBottom",
".",
"value"
] | The components necessary to build your own projection matrix in case your
application is doing something fancy like infinite Z | [
"The",
"components",
"necessary",
"to",
"build",
"your",
"own",
"projection",
"matrix",
"in",
"case",
"your",
"application",
"is",
"doing",
"something",
"fancy",
"like",
"infinite",
"Z"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2644-L2656 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.computeDistortion | def computeDistortion(self, eEye, fU, fV):
"""
Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable.
"""
fn = self.function_table.computeDistortion
pDistortionCoordinates = DistortionCoordinates_t()
result = fn(eEye, fU, fV, byref(pDistortionCoordinates))
return result, pDistortionCoordinates | python | def computeDistortion(self, eEye, fU, fV):
"""
Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable.
"""
fn = self.function_table.computeDistortion
pDistortionCoordinates = DistortionCoordinates_t()
result = fn(eEye, fU, fV, byref(pDistortionCoordinates))
return result, pDistortionCoordinates | [
"def",
"computeDistortion",
"(",
"self",
",",
"eEye",
",",
"fU",
",",
"fV",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"computeDistortion",
"pDistortionCoordinates",
"=",
"DistortionCoordinates_t",
"(",
")",
"result",
"=",
"fn",
"(",
"eEye",
",",
"fU",
",",
"fV",
",",
"byref",
"(",
"pDistortionCoordinates",
")",
")",
"return",
"result",
",",
"pDistortionCoordinates"
] | Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. | [
"Gets",
"the",
"result",
"of",
"the",
"distortion",
"function",
"for",
"the",
"specified",
"eye",
"and",
"input",
"UVs",
".",
"UVs",
"go",
"from",
"0",
"0",
"in",
"the",
"upper",
"left",
"of",
"that",
"eye",
"s",
"viewport",
"and",
"1",
"1",
"in",
"the",
"lower",
"right",
"of",
"that",
"eye",
"s",
"viewport",
".",
"Returns",
"true",
"for",
"success",
".",
"Otherwise",
"returns",
"false",
"and",
"distortion",
"coordinates",
"are",
"not",
"suitable",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2658-L2668 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getTimeSinceLastVsync | def getTimeSinceLastVsync(self):
"""
Returns the number of elapsed seconds since the last recorded vsync event. This
will come from a vsync timer event in the timer if possible or from the application-reported
time if that is not available. If no vsync times are available the function will
return zero for vsync time and frame counter and return false from the method.
"""
fn = self.function_table.getTimeSinceLastVsync
pfSecondsSinceLastVsync = c_float()
pulFrameCounter = c_uint64()
result = fn(byref(pfSecondsSinceLastVsync), byref(pulFrameCounter))
return result, pfSecondsSinceLastVsync.value, pulFrameCounter.value | python | def getTimeSinceLastVsync(self):
"""
Returns the number of elapsed seconds since the last recorded vsync event. This
will come from a vsync timer event in the timer if possible or from the application-reported
time if that is not available. If no vsync times are available the function will
return zero for vsync time and frame counter and return false from the method.
"""
fn = self.function_table.getTimeSinceLastVsync
pfSecondsSinceLastVsync = c_float()
pulFrameCounter = c_uint64()
result = fn(byref(pfSecondsSinceLastVsync), byref(pulFrameCounter))
return result, pfSecondsSinceLastVsync.value, pulFrameCounter.value | [
"def",
"getTimeSinceLastVsync",
"(",
"self",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getTimeSinceLastVsync",
"pfSecondsSinceLastVsync",
"=",
"c_float",
"(",
")",
"pulFrameCounter",
"=",
"c_uint64",
"(",
")",
"result",
"=",
"fn",
"(",
"byref",
"(",
"pfSecondsSinceLastVsync",
")",
",",
"byref",
"(",
"pulFrameCounter",
")",
")",
"return",
"result",
",",
"pfSecondsSinceLastVsync",
".",
"value",
",",
"pulFrameCounter",
".",
"value"
] | Returns the number of elapsed seconds since the last recorded vsync event. This
will come from a vsync timer event in the timer if possible or from the application-reported
time if that is not available. If no vsync times are available the function will
return zero for vsync time and frame counter and return false from the method. | [
"Returns",
"the",
"number",
"of",
"elapsed",
"seconds",
"since",
"the",
"last",
"recorded",
"vsync",
"event",
".",
"This",
"will",
"come",
"from",
"a",
"vsync",
"timer",
"event",
"in",
"the",
"timer",
"if",
"possible",
"or",
"from",
"the",
"application",
"-",
"reported",
"time",
"if",
"that",
"is",
"not",
"available",
".",
"If",
"no",
"vsync",
"times",
"are",
"available",
"the",
"function",
"will",
"return",
"zero",
"for",
"vsync",
"time",
"and",
"frame",
"counter",
"and",
"return",
"false",
"from",
"the",
"method",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2681-L2693 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getTrackedDeviceActivityLevel | def getTrackedDeviceActivityLevel(self, unDeviceId):
"""Returns the level of activity on the device."""
fn = self.function_table.getTrackedDeviceActivityLevel
result = fn(unDeviceId)
return result | python | def getTrackedDeviceActivityLevel(self, unDeviceId):
"""Returns the level of activity on the device."""
fn = self.function_table.getTrackedDeviceActivityLevel
result = fn(unDeviceId)
return result | [
"def",
"getTrackedDeviceActivityLevel",
"(",
"self",
",",
"unDeviceId",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getTrackedDeviceActivityLevel",
"result",
"=",
"fn",
"(",
"unDeviceId",
")",
"return",
"result"
] | Returns the level of activity on the device. | [
"Returns",
"the",
"level",
"of",
"activity",
"on",
"the",
"device",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2835-L2840 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.applyTransform | def applyTransform(self):
"""
Convenience utility to apply the specified transform to the specified pose.
This properly transforms all pose components, including velocity and angular velocity
"""
fn = self.function_table.applyTransform
pOutputPose = TrackedDevicePose_t()
pTrackedDevicePose = TrackedDevicePose_t()
pTransform = HmdMatrix34_t()
fn(byref(pOutputPose), byref(pTrackedDevicePose), byref(pTransform))
return pOutputPose, pTrackedDevicePose, pTransform | python | def applyTransform(self):
"""
Convenience utility to apply the specified transform to the specified pose.
This properly transforms all pose components, including velocity and angular velocity
"""
fn = self.function_table.applyTransform
pOutputPose = TrackedDevicePose_t()
pTrackedDevicePose = TrackedDevicePose_t()
pTransform = HmdMatrix34_t()
fn(byref(pOutputPose), byref(pTrackedDevicePose), byref(pTransform))
return pOutputPose, pTrackedDevicePose, pTransform | [
"def",
"applyTransform",
"(",
"self",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"applyTransform",
"pOutputPose",
"=",
"TrackedDevicePose_t",
"(",
")",
"pTrackedDevicePose",
"=",
"TrackedDevicePose_t",
"(",
")",
"pTransform",
"=",
"HmdMatrix34_t",
"(",
")",
"fn",
"(",
"byref",
"(",
"pOutputPose",
")",
",",
"byref",
"(",
"pTrackedDevicePose",
")",
",",
"byref",
"(",
"pTransform",
")",
")",
"return",
"pOutputPose",
",",
"pTrackedDevicePose",
",",
"pTransform"
] | Convenience utility to apply the specified transform to the specified pose.
This properly transforms all pose components, including velocity and angular velocity | [
"Convenience",
"utility",
"to",
"apply",
"the",
"specified",
"transform",
"to",
"the",
"specified",
"pose",
".",
"This",
"properly",
"transforms",
"all",
"pose",
"components",
"including",
"velocity",
"and",
"angular",
"velocity"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2842-L2853 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getTrackedDeviceIndexForControllerRole | def getTrackedDeviceIndexForControllerRole(self, unDeviceType):
"""Returns the device index associated with a specific role, for example the left hand or the right hand. This function is deprecated in favor of the new IVRInput system."""
fn = self.function_table.getTrackedDeviceIndexForControllerRole
result = fn(unDeviceType)
return result | python | def getTrackedDeviceIndexForControllerRole(self, unDeviceType):
"""Returns the device index associated with a specific role, for example the left hand or the right hand. This function is deprecated in favor of the new IVRInput system."""
fn = self.function_table.getTrackedDeviceIndexForControllerRole
result = fn(unDeviceType)
return result | [
"def",
"getTrackedDeviceIndexForControllerRole",
"(",
"self",
",",
"unDeviceType",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getTrackedDeviceIndexForControllerRole",
"result",
"=",
"fn",
"(",
"unDeviceType",
")",
"return",
"result"
] | Returns the device index associated with a specific role, for example the left hand or the right hand. This function is deprecated in favor of the new IVRInput system. | [
"Returns",
"the",
"device",
"index",
"associated",
"with",
"a",
"specific",
"role",
"for",
"example",
"the",
"left",
"hand",
"or",
"the",
"right",
"hand",
".",
"This",
"function",
"is",
"deprecated",
"in",
"favor",
"of",
"the",
"new",
"IVRInput",
"system",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2855-L2860 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getControllerRoleForTrackedDeviceIndex | def getControllerRoleForTrackedDeviceIndex(self, unDeviceIndex):
"""Returns the controller type associated with a device index. This function is deprecated in favor of the new IVRInput system."""
fn = self.function_table.getControllerRoleForTrackedDeviceIndex
result = fn(unDeviceIndex)
return result | python | def getControllerRoleForTrackedDeviceIndex(self, unDeviceIndex):
"""Returns the controller type associated with a device index. This function is deprecated in favor of the new IVRInput system."""
fn = self.function_table.getControllerRoleForTrackedDeviceIndex
result = fn(unDeviceIndex)
return result | [
"def",
"getControllerRoleForTrackedDeviceIndex",
"(",
"self",
",",
"unDeviceIndex",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getControllerRoleForTrackedDeviceIndex",
"result",
"=",
"fn",
"(",
"unDeviceIndex",
")",
"return",
"result"
] | Returns the controller type associated with a device index. This function is deprecated in favor of the new IVRInput system. | [
"Returns",
"the",
"controller",
"type",
"associated",
"with",
"a",
"device",
"index",
".",
"This",
"function",
"is",
"deprecated",
"in",
"favor",
"of",
"the",
"new",
"IVRInput",
"system",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2862-L2867 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.isTrackedDeviceConnected | def isTrackedDeviceConnected(self, unDeviceIndex):
"""Returns true if there is a device connected in this slot."""
fn = self.function_table.isTrackedDeviceConnected
result = fn(unDeviceIndex)
return result | python | def isTrackedDeviceConnected(self, unDeviceIndex):
"""Returns true if there is a device connected in this slot."""
fn = self.function_table.isTrackedDeviceConnected
result = fn(unDeviceIndex)
return result | [
"def",
"isTrackedDeviceConnected",
"(",
"self",
",",
"unDeviceIndex",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"isTrackedDeviceConnected",
"result",
"=",
"fn",
"(",
"unDeviceIndex",
")",
"return",
"result"
] | Returns true if there is a device connected in this slot. | [
"Returns",
"true",
"if",
"there",
"is",
"a",
"device",
"connected",
"in",
"this",
"slot",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2883-L2888 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getBoolTrackedDeviceProperty | def getBoolTrackedDeviceProperty(self, unDeviceIndex, prop):
"""Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false."""
fn = self.function_table.getBoolTrackedDeviceProperty
pError = ETrackedPropertyError()
result = fn(unDeviceIndex, prop, byref(pError))
return result, pError | python | def getBoolTrackedDeviceProperty(self, unDeviceIndex, prop):
"""Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false."""
fn = self.function_table.getBoolTrackedDeviceProperty
pError = ETrackedPropertyError()
result = fn(unDeviceIndex, prop, byref(pError))
return result, pError | [
"def",
"getBoolTrackedDeviceProperty",
"(",
"self",
",",
"unDeviceIndex",
",",
"prop",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getBoolTrackedDeviceProperty",
"pError",
"=",
"ETrackedPropertyError",
"(",
")",
"result",
"=",
"fn",
"(",
"unDeviceIndex",
",",
"prop",
",",
"byref",
"(",
"pError",
")",
")",
"return",
"result",
",",
"pError"
] | Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. | [
"Returns",
"a",
"bool",
"property",
".",
"If",
"the",
"device",
"index",
"is",
"not",
"valid",
"or",
"the",
"property",
"is",
"not",
"a",
"bool",
"type",
"this",
"function",
"will",
"return",
"false",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2890-L2896 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getArrayTrackedDeviceProperty | def getArrayTrackedDeviceProperty(self, unDeviceIndex, prop, propType, pBuffer, unBufferSize):
"""
Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties.
"""
fn = self.function_table.getArrayTrackedDeviceProperty
pError = ETrackedPropertyError()
result = fn(unDeviceIndex, prop, propType, pBuffer, unBufferSize, byref(pError))
return result, pError | python | def getArrayTrackedDeviceProperty(self, unDeviceIndex, prop, propType, pBuffer, unBufferSize):
"""
Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties.
"""
fn = self.function_table.getArrayTrackedDeviceProperty
pError = ETrackedPropertyError()
result = fn(unDeviceIndex, prop, propType, pBuffer, unBufferSize, byref(pError))
return result, pError | [
"def",
"getArrayTrackedDeviceProperty",
"(",
"self",
",",
"unDeviceIndex",
",",
"prop",
",",
"propType",
",",
"pBuffer",
",",
"unBufferSize",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getArrayTrackedDeviceProperty",
"pError",
"=",
"ETrackedPropertyError",
"(",
")",
"result",
"=",
"fn",
"(",
"unDeviceIndex",
",",
"prop",
",",
"propType",
",",
"pBuffer",
",",
"unBufferSize",
",",
"byref",
"(",
"pError",
")",
")",
"return",
"result",
",",
"pError"
] | Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties. | [
"Returns",
"an",
"array",
"of",
"one",
"type",
"of",
"property",
".",
"If",
"the",
"device",
"index",
"is",
"not",
"valid",
"or",
"the",
"property",
"is",
"not",
"a",
"single",
"value",
"or",
"an",
"array",
"of",
"the",
"specified",
"type",
"this",
"function",
"will",
"return",
"0",
".",
"Otherwise",
"it",
"returns",
"the",
"number",
"of",
"bytes",
"necessary",
"to",
"hold",
"the",
"array",
"of",
"properties",
".",
"If",
"unBufferSize",
"is",
"greater",
"than",
"the",
"returned",
"size",
"and",
"pBuffer",
"is",
"non",
"-",
"NULL",
"pBuffer",
"is",
"filled",
"with",
"the",
"contents",
"of",
"array",
"of",
"properties",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2930-L2940 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getStringTrackedDeviceProperty | def getStringTrackedDeviceProperty(self, unDeviceIndex, prop):
"""
Returns a string property. If the device index is not valid or the property is not a string type this function will
return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters.
"""
fn = self.function_table.getStringTrackedDeviceProperty
pError = ETrackedPropertyError()
# TODO: automate this string argument manipulation ****
unRequiredBufferLen = fn( unDeviceIndex, prop, None, 0, byref(pError) )
if unRequiredBufferLen == 0:
return b""
pchBuffer = ctypes.create_string_buffer(unRequiredBufferLen)
fn( unDeviceIndex, prop, pchBuffer, unRequiredBufferLen, byref(pError) )
if pError.value != TrackedProp_Success:
raise OpenVRError(str(pError))
sResult = bytes(pchBuffer.value)
return sResult | python | def getStringTrackedDeviceProperty(self, unDeviceIndex, prop):
"""
Returns a string property. If the device index is not valid or the property is not a string type this function will
return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters.
"""
fn = self.function_table.getStringTrackedDeviceProperty
pError = ETrackedPropertyError()
# TODO: automate this string argument manipulation ****
unRequiredBufferLen = fn( unDeviceIndex, prop, None, 0, byref(pError) )
if unRequiredBufferLen == 0:
return b""
pchBuffer = ctypes.create_string_buffer(unRequiredBufferLen)
fn( unDeviceIndex, prop, pchBuffer, unRequiredBufferLen, byref(pError) )
if pError.value != TrackedProp_Success:
raise OpenVRError(str(pError))
sResult = bytes(pchBuffer.value)
return sResult | [
"def",
"getStringTrackedDeviceProperty",
"(",
"self",
",",
"unDeviceIndex",
",",
"prop",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getStringTrackedDeviceProperty",
"pError",
"=",
"ETrackedPropertyError",
"(",
")",
"# TODO: automate this string argument manipulation ****",
"unRequiredBufferLen",
"=",
"fn",
"(",
"unDeviceIndex",
",",
"prop",
",",
"None",
",",
"0",
",",
"byref",
"(",
"pError",
")",
")",
"if",
"unRequiredBufferLen",
"==",
"0",
":",
"return",
"b\"\"",
"pchBuffer",
"=",
"ctypes",
".",
"create_string_buffer",
"(",
"unRequiredBufferLen",
")",
"fn",
"(",
"unDeviceIndex",
",",
"prop",
",",
"pchBuffer",
",",
"unRequiredBufferLen",
",",
"byref",
"(",
"pError",
")",
")",
"if",
"pError",
".",
"value",
"!=",
"TrackedProp_Success",
":",
"raise",
"OpenVRError",
"(",
"str",
"(",
"pError",
")",
")",
"sResult",
"=",
"bytes",
"(",
"pchBuffer",
".",
"value",
")",
"return",
"sResult"
] | Returns a string property. If the device index is not valid or the property is not a string type this function will
return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. | [
"Returns",
"a",
"string",
"property",
".",
"If",
"the",
"device",
"index",
"is",
"not",
"valid",
"or",
"the",
"property",
"is",
"not",
"a",
"string",
"type",
"this",
"function",
"will",
"return",
"0",
".",
"Otherwise",
"it",
"returns",
"the",
"length",
"of",
"the",
"number",
"of",
"bytes",
"necessary",
"to",
"hold",
"this",
"string",
"including",
"the",
"trailing",
"null",
".",
"Strings",
"will",
"always",
"fit",
"in",
"buffers",
"of",
"k_unMaxPropertyStringSize",
"characters",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2942-L2960 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getPropErrorNameFromEnum | def getPropErrorNameFromEnum(self, error):
"""
returns a string that corresponds with the specified property error. The string will be the name
of the error enum value for all valid error codes
"""
fn = self.function_table.getPropErrorNameFromEnum
result = fn(error)
return result | python | def getPropErrorNameFromEnum(self, error):
"""
returns a string that corresponds with the specified property error. The string will be the name
of the error enum value for all valid error codes
"""
fn = self.function_table.getPropErrorNameFromEnum
result = fn(error)
return result | [
"def",
"getPropErrorNameFromEnum",
"(",
"self",
",",
"error",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getPropErrorNameFromEnum",
"result",
"=",
"fn",
"(",
"error",
")",
"return",
"result"
] | returns a string that corresponds with the specified property error. The string will be the name
of the error enum value for all valid error codes | [
"returns",
"a",
"string",
"that",
"corresponds",
"with",
"the",
"specified",
"property",
"error",
".",
"The",
"string",
"will",
"be",
"the",
"name",
"of",
"the",
"error",
"enum",
"value",
"for",
"all",
"valid",
"error",
"codes"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2962-L2970 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.pollNextEvent | def pollNextEvent(self, pEvent):
"""
Returns true and fills the event with the next event on the queue if there is one. If there are no events
this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct
"""
fn = self.function_table.pollNextEvent
result = fn(byref(pEvent), sizeof(VREvent_t))
return result != 0 | python | def pollNextEvent(self, pEvent):
"""
Returns true and fills the event with the next event on the queue if there is one. If there are no events
this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct
"""
fn = self.function_table.pollNextEvent
result = fn(byref(pEvent), sizeof(VREvent_t))
return result != 0 | [
"def",
"pollNextEvent",
"(",
"self",
",",
"pEvent",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"pollNextEvent",
"result",
"=",
"fn",
"(",
"byref",
"(",
"pEvent",
")",
",",
"sizeof",
"(",
"VREvent_t",
")",
")",
"return",
"result",
"!=",
"0"
] | Returns true and fills the event with the next event on the queue if there is one. If there are no events
this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct | [
"Returns",
"true",
"and",
"fills",
"the",
"event",
"with",
"the",
"next",
"event",
"on",
"the",
"queue",
"if",
"there",
"is",
"one",
".",
"If",
"there",
"are",
"no",
"events",
"this",
"method",
"returns",
"false",
".",
"uncbVREvent",
"should",
"be",
"the",
"size",
"in",
"bytes",
"of",
"the",
"VREvent_t",
"struct"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2972-L2980 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.pollNextEventWithPose | def pollNextEventWithPose(self, eOrigin, uncbVREvent):
"""
Returns true and fills the event with the next event on the queue if there is one. If there are no events
this method returns false. Fills in the pose of the associated tracked device in the provided pose struct.
This pose will always be older than the call to this function and should not be used to render the device.
uncbVREvent should be the size in bytes of the VREvent_t struct
"""
fn = self.function_table.pollNextEventWithPose
pEvent = VREvent_t()
pTrackedDevicePose = TrackedDevicePose_t()
result = fn(eOrigin, byref(pEvent), uncbVREvent, byref(pTrackedDevicePose))
return result, pEvent, pTrackedDevicePose | python | def pollNextEventWithPose(self, eOrigin, uncbVREvent):
"""
Returns true and fills the event with the next event on the queue if there is one. If there are no events
this method returns false. Fills in the pose of the associated tracked device in the provided pose struct.
This pose will always be older than the call to this function and should not be used to render the device.
uncbVREvent should be the size in bytes of the VREvent_t struct
"""
fn = self.function_table.pollNextEventWithPose
pEvent = VREvent_t()
pTrackedDevicePose = TrackedDevicePose_t()
result = fn(eOrigin, byref(pEvent), uncbVREvent, byref(pTrackedDevicePose))
return result, pEvent, pTrackedDevicePose | [
"def",
"pollNextEventWithPose",
"(",
"self",
",",
"eOrigin",
",",
"uncbVREvent",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"pollNextEventWithPose",
"pEvent",
"=",
"VREvent_t",
"(",
")",
"pTrackedDevicePose",
"=",
"TrackedDevicePose_t",
"(",
")",
"result",
"=",
"fn",
"(",
"eOrigin",
",",
"byref",
"(",
"pEvent",
")",
",",
"uncbVREvent",
",",
"byref",
"(",
"pTrackedDevicePose",
")",
")",
"return",
"result",
",",
"pEvent",
",",
"pTrackedDevicePose"
] | Returns true and fills the event with the next event on the queue if there is one. If there are no events
this method returns false. Fills in the pose of the associated tracked device in the provided pose struct.
This pose will always be older than the call to this function and should not be used to render the device.
uncbVREvent should be the size in bytes of the VREvent_t struct | [
"Returns",
"true",
"and",
"fills",
"the",
"event",
"with",
"the",
"next",
"event",
"on",
"the",
"queue",
"if",
"there",
"is",
"one",
".",
"If",
"there",
"are",
"no",
"events",
"this",
"method",
"returns",
"false",
".",
"Fills",
"in",
"the",
"pose",
"of",
"the",
"associated",
"tracked",
"device",
"in",
"the",
"provided",
"pose",
"struct",
".",
"This",
"pose",
"will",
"always",
"be",
"older",
"than",
"the",
"call",
"to",
"this",
"function",
"and",
"should",
"not",
"be",
"used",
"to",
"render",
"the",
"device",
".",
"uncbVREvent",
"should",
"be",
"the",
"size",
"in",
"bytes",
"of",
"the",
"VREvent_t",
"struct"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2982-L2994 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getEventTypeNameFromEnum | def getEventTypeNameFromEnum(self, eType):
"""returns the name of an EVREvent enum value"""
fn = self.function_table.getEventTypeNameFromEnum
result = fn(eType)
return result | python | def getEventTypeNameFromEnum(self, eType):
"""returns the name of an EVREvent enum value"""
fn = self.function_table.getEventTypeNameFromEnum
result = fn(eType)
return result | [
"def",
"getEventTypeNameFromEnum",
"(",
"self",
",",
"eType",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getEventTypeNameFromEnum",
"result",
"=",
"fn",
"(",
"eType",
")",
"return",
"result"
] | returns the name of an EVREvent enum value | [
"returns",
"the",
"name",
"of",
"an",
"EVREvent",
"enum",
"value"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L2996-L3001 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getControllerState | def getControllerState(self, unControllerDeviceIndex, unControllerStateSize=sizeof(VRControllerState_t)):
"""
Fills the supplied struct with the current state of the controller. Returns false if the controller index
is invalid. This function is deprecated in favor of the new IVRInput system.
"""
fn = self.function_table.getControllerState
pControllerState = VRControllerState_t()
result = fn(unControllerDeviceIndex, byref(pControllerState), unControllerStateSize)
return result, pControllerState | python | def getControllerState(self, unControllerDeviceIndex, unControllerStateSize=sizeof(VRControllerState_t)):
"""
Fills the supplied struct with the current state of the controller. Returns false if the controller index
is invalid. This function is deprecated in favor of the new IVRInput system.
"""
fn = self.function_table.getControllerState
pControllerState = VRControllerState_t()
result = fn(unControllerDeviceIndex, byref(pControllerState), unControllerStateSize)
return result, pControllerState | [
"def",
"getControllerState",
"(",
"self",
",",
"unControllerDeviceIndex",
",",
"unControllerStateSize",
"=",
"sizeof",
"(",
"VRControllerState_t",
")",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getControllerState",
"pControllerState",
"=",
"VRControllerState_t",
"(",
")",
"result",
"=",
"fn",
"(",
"unControllerDeviceIndex",
",",
"byref",
"(",
"pControllerState",
")",
",",
"unControllerStateSize",
")",
"return",
"result",
",",
"pControllerState"
] | Fills the supplied struct with the current state of the controller. Returns false if the controller index
is invalid. This function is deprecated in favor of the new IVRInput system. | [
"Fills",
"the",
"supplied",
"struct",
"with",
"the",
"current",
"state",
"of",
"the",
"controller",
".",
"Returns",
"false",
"if",
"the",
"controller",
"index",
"is",
"invalid",
".",
"This",
"function",
"is",
"deprecated",
"in",
"favor",
"of",
"the",
"new",
"IVRInput",
"system",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3018-L3027 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getControllerStateWithPose | def getControllerStateWithPose(self, eOrigin, unControllerDeviceIndex, unControllerStateSize=sizeof(VRControllerState_t)):
"""
fills the supplied struct with the current state of the controller and the provided pose with the pose of
the controller when the controller state was updated most recently. Use this form if you need a precise controller
pose as input to your application when the user presses or releases a button. This function is deprecated in favor of the new IVRInput system.
"""
fn = self.function_table.getControllerStateWithPose
pControllerState = VRControllerState_t()
pTrackedDevicePose = TrackedDevicePose_t()
result = fn(eOrigin, unControllerDeviceIndex, byref(pControllerState), unControllerStateSize, byref(pTrackedDevicePose))
return result, pControllerState, pTrackedDevicePose | python | def getControllerStateWithPose(self, eOrigin, unControllerDeviceIndex, unControllerStateSize=sizeof(VRControllerState_t)):
"""
fills the supplied struct with the current state of the controller and the provided pose with the pose of
the controller when the controller state was updated most recently. Use this form if you need a precise controller
pose as input to your application when the user presses or releases a button. This function is deprecated in favor of the new IVRInput system.
"""
fn = self.function_table.getControllerStateWithPose
pControllerState = VRControllerState_t()
pTrackedDevicePose = TrackedDevicePose_t()
result = fn(eOrigin, unControllerDeviceIndex, byref(pControllerState), unControllerStateSize, byref(pTrackedDevicePose))
return result, pControllerState, pTrackedDevicePose | [
"def",
"getControllerStateWithPose",
"(",
"self",
",",
"eOrigin",
",",
"unControllerDeviceIndex",
",",
"unControllerStateSize",
"=",
"sizeof",
"(",
"VRControllerState_t",
")",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getControllerStateWithPose",
"pControllerState",
"=",
"VRControllerState_t",
"(",
")",
"pTrackedDevicePose",
"=",
"TrackedDevicePose_t",
"(",
")",
"result",
"=",
"fn",
"(",
"eOrigin",
",",
"unControllerDeviceIndex",
",",
"byref",
"(",
"pControllerState",
")",
",",
"unControllerStateSize",
",",
"byref",
"(",
"pTrackedDevicePose",
")",
")",
"return",
"result",
",",
"pControllerState",
",",
"pTrackedDevicePose"
] | fills the supplied struct with the current state of the controller and the provided pose with the pose of
the controller when the controller state was updated most recently. Use this form if you need a precise controller
pose as input to your application when the user presses or releases a button. This function is deprecated in favor of the new IVRInput system. | [
"fills",
"the",
"supplied",
"struct",
"with",
"the",
"current",
"state",
"of",
"the",
"controller",
"and",
"the",
"provided",
"pose",
"with",
"the",
"pose",
"of",
"the",
"controller",
"when",
"the",
"controller",
"state",
"was",
"updated",
"most",
"recently",
".",
"Use",
"this",
"form",
"if",
"you",
"need",
"a",
"precise",
"controller",
"pose",
"as",
"input",
"to",
"your",
"application",
"when",
"the",
"user",
"presses",
"or",
"releases",
"a",
"button",
".",
"This",
"function",
"is",
"deprecated",
"in",
"favor",
"of",
"the",
"new",
"IVRInput",
"system",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3029-L3040 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.triggerHapticPulse | def triggerHapticPulse(self, unControllerDeviceIndex, unAxisId, usDurationMicroSec):
"""
Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
and axis combination for 5ms. This function is deprecated in favor of the new IVRInput system.
"""
fn = self.function_table.triggerHapticPulse
fn(unControllerDeviceIndex, unAxisId, usDurationMicroSec) | python | def triggerHapticPulse(self, unControllerDeviceIndex, unAxisId, usDurationMicroSec):
"""
Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
and axis combination for 5ms. This function is deprecated in favor of the new IVRInput system.
"""
fn = self.function_table.triggerHapticPulse
fn(unControllerDeviceIndex, unAxisId, usDurationMicroSec) | [
"def",
"triggerHapticPulse",
"(",
"self",
",",
"unControllerDeviceIndex",
",",
"unAxisId",
",",
"usDurationMicroSec",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"triggerHapticPulse",
"fn",
"(",
"unControllerDeviceIndex",
",",
"unAxisId",
",",
"usDurationMicroSec",
")"
] | Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
and axis combination for 5ms. This function is deprecated in favor of the new IVRInput system. | [
"Trigger",
"a",
"single",
"haptic",
"pulse",
"on",
"a",
"controller",
".",
"After",
"this",
"call",
"the",
"application",
"may",
"not",
"trigger",
"another",
"haptic",
"pulse",
"on",
"this",
"controller",
"and",
"axis",
"combination",
"for",
"5ms",
".",
"This",
"function",
"is",
"deprecated",
"in",
"favor",
"of",
"the",
"new",
"IVRInput",
"system",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3042-L3049 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getButtonIdNameFromEnum | def getButtonIdNameFromEnum(self, eButtonId):
"""returns the name of an EVRButtonId enum value. This function is deprecated in favor of the new IVRInput system."""
fn = self.function_table.getButtonIdNameFromEnum
result = fn(eButtonId)
return result | python | def getButtonIdNameFromEnum(self, eButtonId):
"""returns the name of an EVRButtonId enum value. This function is deprecated in favor of the new IVRInput system."""
fn = self.function_table.getButtonIdNameFromEnum
result = fn(eButtonId)
return result | [
"def",
"getButtonIdNameFromEnum",
"(",
"self",
",",
"eButtonId",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getButtonIdNameFromEnum",
"result",
"=",
"fn",
"(",
"eButtonId",
")",
"return",
"result"
] | returns the name of an EVRButtonId enum value. This function is deprecated in favor of the new IVRInput system. | [
"returns",
"the",
"name",
"of",
"an",
"EVRButtonId",
"enum",
"value",
".",
"This",
"function",
"is",
"deprecated",
"in",
"favor",
"of",
"the",
"new",
"IVRInput",
"system",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3051-L3056 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.getControllerAxisTypeNameFromEnum | def getControllerAxisTypeNameFromEnum(self, eAxisType):
"""returns the name of an EVRControllerAxisType enum value. This function is deprecated in favor of the new IVRInput system."""
fn = self.function_table.getControllerAxisTypeNameFromEnum
result = fn(eAxisType)
return result | python | def getControllerAxisTypeNameFromEnum(self, eAxisType):
"""returns the name of an EVRControllerAxisType enum value. This function is deprecated in favor of the new IVRInput system."""
fn = self.function_table.getControllerAxisTypeNameFromEnum
result = fn(eAxisType)
return result | [
"def",
"getControllerAxisTypeNameFromEnum",
"(",
"self",
",",
"eAxisType",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getControllerAxisTypeNameFromEnum",
"result",
"=",
"fn",
"(",
"eAxisType",
")",
"return",
"result"
] | returns the name of an EVRControllerAxisType enum value. This function is deprecated in favor of the new IVRInput system. | [
"returns",
"the",
"name",
"of",
"an",
"EVRControllerAxisType",
"enum",
"value",
".",
"This",
"function",
"is",
"deprecated",
"in",
"favor",
"of",
"the",
"new",
"IVRInput",
"system",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3058-L3063 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRSystem.driverDebugRequest | def driverDebugRequest(self, unDeviceIndex, pchRequest, pchResponseBuffer, unResponseBufferSize):
"""
Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
The size of the response including its terminating null is returned.
"""
fn = self.function_table.driverDebugRequest
result = fn(unDeviceIndex, pchRequest, pchResponseBuffer, unResponseBufferSize)
return result | python | def driverDebugRequest(self, unDeviceIndex, pchRequest, pchResponseBuffer, unResponseBufferSize):
"""
Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
The size of the response including its terminating null is returned.
"""
fn = self.function_table.driverDebugRequest
result = fn(unDeviceIndex, pchRequest, pchResponseBuffer, unResponseBufferSize)
return result | [
"def",
"driverDebugRequest",
"(",
"self",
",",
"unDeviceIndex",
",",
"pchRequest",
",",
"pchResponseBuffer",
",",
"unResponseBufferSize",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"driverDebugRequest",
"result",
"=",
"fn",
"(",
"unDeviceIndex",
",",
"pchRequest",
",",
"pchResponseBuffer",
",",
"unResponseBufferSize",
")",
"return",
"result"
] | Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
The size of the response including its terminating null is returned. | [
"Sends",
"a",
"request",
"to",
"the",
"driver",
"for",
"the",
"specified",
"device",
"and",
"returns",
"the",
"response",
".",
"The",
"maximum",
"response",
"size",
"is",
"32k",
"but",
"this",
"method",
"can",
"be",
"called",
"with",
"a",
"smaller",
"buffer",
".",
"If",
"the",
"response",
"exceeds",
"the",
"size",
"of",
"the",
"buffer",
"it",
"is",
"truncated",
".",
"The",
"size",
"of",
"the",
"response",
"including",
"its",
"terminating",
"null",
"is",
"returned",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3105-L3114 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRExtendedDisplay.getWindowBounds | def getWindowBounds(self):
"""Size and position that the window needs to be on the VR display."""
fn = self.function_table.getWindowBounds
pnX = c_int32()
pnY = c_int32()
pnWidth = c_uint32()
pnHeight = c_uint32()
fn(byref(pnX), byref(pnY), byref(pnWidth), byref(pnHeight))
return pnX.value, pnY.value, pnWidth.value, pnHeight.value | python | def getWindowBounds(self):
"""Size and position that the window needs to be on the VR display."""
fn = self.function_table.getWindowBounds
pnX = c_int32()
pnY = c_int32()
pnWidth = c_uint32()
pnHeight = c_uint32()
fn(byref(pnX), byref(pnY), byref(pnWidth), byref(pnHeight))
return pnX.value, pnY.value, pnWidth.value, pnHeight.value | [
"def",
"getWindowBounds",
"(",
"self",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getWindowBounds",
"pnX",
"=",
"c_int32",
"(",
")",
"pnY",
"=",
"c_int32",
"(",
")",
"pnWidth",
"=",
"c_uint32",
"(",
")",
"pnHeight",
"=",
"c_uint32",
"(",
")",
"fn",
"(",
"byref",
"(",
"pnX",
")",
",",
"byref",
"(",
"pnY",
")",
",",
"byref",
"(",
"pnWidth",
")",
",",
"byref",
"(",
"pnHeight",
")",
")",
"return",
"pnX",
".",
"value",
",",
"pnY",
".",
"value",
",",
"pnWidth",
".",
"value",
",",
"pnHeight",
".",
"value"
] | Size and position that the window needs to be on the VR display. | [
"Size",
"and",
"position",
"that",
"the",
"window",
"needs",
"to",
"be",
"on",
"the",
"VR",
"display",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3176-L3185 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRExtendedDisplay.getEyeOutputViewport | def getEyeOutputViewport(self, eEye):
"""Gets the viewport in the frame buffer to draw the output of the distortion into"""
fn = self.function_table.getEyeOutputViewport
pnX = c_uint32()
pnY = c_uint32()
pnWidth = c_uint32()
pnHeight = c_uint32()
fn(eEye, byref(pnX), byref(pnY), byref(pnWidth), byref(pnHeight))
return pnX.value, pnY.value, pnWidth.value, pnHeight.value | python | def getEyeOutputViewport(self, eEye):
"""Gets the viewport in the frame buffer to draw the output of the distortion into"""
fn = self.function_table.getEyeOutputViewport
pnX = c_uint32()
pnY = c_uint32()
pnWidth = c_uint32()
pnHeight = c_uint32()
fn(eEye, byref(pnX), byref(pnY), byref(pnWidth), byref(pnHeight))
return pnX.value, pnY.value, pnWidth.value, pnHeight.value | [
"def",
"getEyeOutputViewport",
"(",
"self",
",",
"eEye",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getEyeOutputViewport",
"pnX",
"=",
"c_uint32",
"(",
")",
"pnY",
"=",
"c_uint32",
"(",
")",
"pnWidth",
"=",
"c_uint32",
"(",
")",
"pnHeight",
"=",
"c_uint32",
"(",
")",
"fn",
"(",
"eEye",
",",
"byref",
"(",
"pnX",
")",
",",
"byref",
"(",
"pnY",
")",
",",
"byref",
"(",
"pnWidth",
")",
",",
"byref",
"(",
"pnHeight",
")",
")",
"return",
"pnX",
".",
"value",
",",
"pnY",
".",
"value",
",",
"pnWidth",
".",
"value",
",",
"pnHeight",
".",
"value"
] | Gets the viewport in the frame buffer to draw the output of the distortion into | [
"Gets",
"the",
"viewport",
"in",
"the",
"frame",
"buffer",
"to",
"draw",
"the",
"output",
"of",
"the",
"distortion",
"into"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3187-L3196 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRTrackedCamera.getCameraErrorNameFromEnum | def getCameraErrorNameFromEnum(self, eCameraError):
"""Returns a string for an error"""
fn = self.function_table.getCameraErrorNameFromEnum
result = fn(eCameraError)
return result | python | def getCameraErrorNameFromEnum(self, eCameraError):
"""Returns a string for an error"""
fn = self.function_table.getCameraErrorNameFromEnum
result = fn(eCameraError)
return result | [
"def",
"getCameraErrorNameFromEnum",
"(",
"self",
",",
"eCameraError",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getCameraErrorNameFromEnum",
"result",
"=",
"fn",
"(",
"eCameraError",
")",
"return",
"result"
] | Returns a string for an error | [
"Returns",
"a",
"string",
"for",
"an",
"error"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3243-L3248 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRTrackedCamera.hasCamera | def hasCamera(self, nDeviceIndex):
"""For convenience, same as tracked property request Prop_HasCamera_Bool"""
fn = self.function_table.hasCamera
pHasCamera = openvr_bool()
result = fn(nDeviceIndex, byref(pHasCamera))
return result, pHasCamera | python | def hasCamera(self, nDeviceIndex):
"""For convenience, same as tracked property request Prop_HasCamera_Bool"""
fn = self.function_table.hasCamera
pHasCamera = openvr_bool()
result = fn(nDeviceIndex, byref(pHasCamera))
return result, pHasCamera | [
"def",
"hasCamera",
"(",
"self",
",",
"nDeviceIndex",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"hasCamera",
"pHasCamera",
"=",
"openvr_bool",
"(",
")",
"result",
"=",
"fn",
"(",
"nDeviceIndex",
",",
"byref",
"(",
"pHasCamera",
")",
")",
"return",
"result",
",",
"pHasCamera"
] | For convenience, same as tracked property request Prop_HasCamera_Bool | [
"For",
"convenience",
"same",
"as",
"tracked",
"property",
"request",
"Prop_HasCamera_Bool"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3250-L3256 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRTrackedCamera.acquireVideoStreamingService | def acquireVideoStreamingService(self, nDeviceIndex):
"""
Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
The camera may go inactive due to lack of active consumers or headset idleness.
"""
fn = self.function_table.acquireVideoStreamingService
pHandle = TrackedCameraHandle_t()
result = fn(nDeviceIndex, byref(pHandle))
return result, pHandle | python | def acquireVideoStreamingService(self, nDeviceIndex):
"""
Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
The camera may go inactive due to lack of active consumers or headset idleness.
"""
fn = self.function_table.acquireVideoStreamingService
pHandle = TrackedCameraHandle_t()
result = fn(nDeviceIndex, byref(pHandle))
return result, pHandle | [
"def",
"acquireVideoStreamingService",
"(",
"self",
",",
"nDeviceIndex",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"acquireVideoStreamingService",
"pHandle",
"=",
"TrackedCameraHandle_t",
"(",
")",
"result",
"=",
"fn",
"(",
"nDeviceIndex",
",",
"byref",
"(",
"pHandle",
")",
")",
"return",
"result",
",",
"pHandle"
] | Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
The camera may go inactive due to lack of active consumers or headset idleness. | [
"Acquiring",
"streaming",
"service",
"permits",
"video",
"streaming",
"for",
"the",
"caller",
".",
"Releasing",
"hints",
"the",
"system",
"that",
"video",
"services",
"do",
"not",
"need",
"to",
"be",
"maintained",
"for",
"this",
"client",
".",
"If",
"the",
"camera",
"has",
"not",
"already",
"been",
"activated",
"a",
"one",
"time",
"spin",
"up",
"may",
"incur",
"some",
"auto",
"exposure",
"as",
"well",
"as",
"initial",
"streaming",
"frame",
"delays",
".",
"The",
"camera",
"should",
"be",
"considered",
"a",
"global",
"resource",
"accessible",
"for",
"shared",
"consumption",
"but",
"not",
"exclusive",
"to",
"any",
"caller",
".",
"The",
"camera",
"may",
"go",
"inactive",
"due",
"to",
"lack",
"of",
"active",
"consumers",
"or",
"headset",
"idleness",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3281-L3292 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRTrackedCamera.getVideoStreamFrameBuffer | def getVideoStreamFrameBuffer(self, hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, nFrameHeaderSize):
"""
Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
the caller to determine if the frame as advanced per the frame header sequence.
If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
Ideally a caller should be polling at ~16ms intervals
"""
fn = self.function_table.getVideoStreamFrameBuffer
pFrameHeader = CameraVideoStreamFrameHeader_t()
result = fn(hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, byref(pFrameHeader), nFrameHeaderSize)
return result, pFrameHeader | python | def getVideoStreamFrameBuffer(self, hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, nFrameHeaderSize):
"""
Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
the caller to determine if the frame as advanced per the frame header sequence.
If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
Ideally a caller should be polling at ~16ms intervals
"""
fn = self.function_table.getVideoStreamFrameBuffer
pFrameHeader = CameraVideoStreamFrameHeader_t()
result = fn(hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, byref(pFrameHeader), nFrameHeaderSize)
return result, pFrameHeader | [
"def",
"getVideoStreamFrameBuffer",
"(",
"self",
",",
"hTrackedCamera",
",",
"eFrameType",
",",
"pFrameBuffer",
",",
"nFrameBufferSize",
",",
"nFrameHeaderSize",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getVideoStreamFrameBuffer",
"pFrameHeader",
"=",
"CameraVideoStreamFrameHeader_t",
"(",
")",
"result",
"=",
"fn",
"(",
"hTrackedCamera",
",",
"eFrameType",
",",
"pFrameBuffer",
",",
"nFrameBufferSize",
",",
"byref",
"(",
"pFrameHeader",
")",
",",
"nFrameHeaderSize",
")",
"return",
"result",
",",
"pFrameHeader"
] | Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
the caller to determine if the frame as advanced per the frame header sequence.
If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
Ideally a caller should be polling at ~16ms intervals | [
"Copies",
"the",
"image",
"frame",
"into",
"a",
"caller",
"s",
"provided",
"buffer",
".",
"The",
"image",
"data",
"is",
"currently",
"provided",
"as",
"RGBA",
"data",
"4",
"bytes",
"per",
"pixel",
".",
"A",
"caller",
"can",
"provide",
"null",
"for",
"the",
"framebuffer",
"or",
"frameheader",
"if",
"not",
"desired",
".",
"Requesting",
"the",
"frame",
"header",
"first",
"followed",
"by",
"the",
"frame",
"buffer",
"allows",
"the",
"caller",
"to",
"determine",
"if",
"the",
"frame",
"as",
"advanced",
"per",
"the",
"frame",
"header",
"sequence",
".",
"If",
"there",
"is",
"no",
"frame",
"available",
"yet",
"due",
"to",
"initial",
"camera",
"spinup",
"or",
"re",
"-",
"activation",
"the",
"error",
"will",
"be",
"VRTrackedCameraError_NoFrameAvailable",
".",
"Ideally",
"a",
"caller",
"should",
"be",
"polling",
"at",
"~16ms",
"intervals"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3299-L3311 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRTrackedCamera.getVideoStreamTextureGL | def getVideoStreamTextureGL(self, hTrackedCamera, eFrameType, nFrameHeaderSize):
"""Access a shared GL texture for the specified tracked camera stream"""
fn = self.function_table.getVideoStreamTextureGL
pglTextureId = glUInt_t()
pFrameHeader = CameraVideoStreamFrameHeader_t()
result = fn(hTrackedCamera, eFrameType, byref(pglTextureId), byref(pFrameHeader), nFrameHeaderSize)
return result, pglTextureId, pFrameHeader | python | def getVideoStreamTextureGL(self, hTrackedCamera, eFrameType, nFrameHeaderSize):
"""Access a shared GL texture for the specified tracked camera stream"""
fn = self.function_table.getVideoStreamTextureGL
pglTextureId = glUInt_t()
pFrameHeader = CameraVideoStreamFrameHeader_t()
result = fn(hTrackedCamera, eFrameType, byref(pglTextureId), byref(pFrameHeader), nFrameHeaderSize)
return result, pglTextureId, pFrameHeader | [
"def",
"getVideoStreamTextureGL",
"(",
"self",
",",
"hTrackedCamera",
",",
"eFrameType",
",",
"nFrameHeaderSize",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getVideoStreamTextureGL",
"pglTextureId",
"=",
"glUInt_t",
"(",
")",
"pFrameHeader",
"=",
"CameraVideoStreamFrameHeader_t",
"(",
")",
"result",
"=",
"fn",
"(",
"hTrackedCamera",
",",
"eFrameType",
",",
"byref",
"(",
"pglTextureId",
")",
",",
"byref",
"(",
"pFrameHeader",
")",
",",
"nFrameHeaderSize",
")",
"return",
"result",
",",
"pglTextureId",
",",
"pFrameHeader"
] | Access a shared GL texture for the specified tracked camera stream | [
"Access",
"a",
"shared",
"GL",
"texture",
"for",
"the",
"specified",
"tracked",
"camera",
"stream"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3339-L3346 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.addApplicationManifest | def addApplicationManifest(self, pchApplicationManifestFullPath, bTemporary):
"""
Adds an application manifest to the list to load when building the list of installed applications.
Temporary manifests are not automatically loaded
"""
fn = self.function_table.addApplicationManifest
result = fn(pchApplicationManifestFullPath, bTemporary)
return result | python | def addApplicationManifest(self, pchApplicationManifestFullPath, bTemporary):
"""
Adds an application manifest to the list to load when building the list of installed applications.
Temporary manifests are not automatically loaded
"""
fn = self.function_table.addApplicationManifest
result = fn(pchApplicationManifestFullPath, bTemporary)
return result | [
"def",
"addApplicationManifest",
"(",
"self",
",",
"pchApplicationManifestFullPath",
",",
"bTemporary",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"addApplicationManifest",
"result",
"=",
"fn",
"(",
"pchApplicationManifestFullPath",
",",
"bTemporary",
")",
"return",
"result"
] | Adds an application manifest to the list to load when building the list of installed applications.
Temporary manifests are not automatically loaded | [
"Adds",
"an",
"application",
"manifest",
"to",
"the",
"list",
"to",
"load",
"when",
"building",
"the",
"list",
"of",
"installed",
"applications",
".",
"Temporary",
"manifests",
"are",
"not",
"automatically",
"loaded"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3404-L3412 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.removeApplicationManifest | def removeApplicationManifest(self, pchApplicationManifestFullPath):
"""Removes an application manifest from the list to load when building the list of installed applications."""
fn = self.function_table.removeApplicationManifest
result = fn(pchApplicationManifestFullPath)
return result | python | def removeApplicationManifest(self, pchApplicationManifestFullPath):
"""Removes an application manifest from the list to load when building the list of installed applications."""
fn = self.function_table.removeApplicationManifest
result = fn(pchApplicationManifestFullPath)
return result | [
"def",
"removeApplicationManifest",
"(",
"self",
",",
"pchApplicationManifestFullPath",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"removeApplicationManifest",
"result",
"=",
"fn",
"(",
"pchApplicationManifestFullPath",
")",
"return",
"result"
] | Removes an application manifest from the list to load when building the list of installed applications. | [
"Removes",
"an",
"application",
"manifest",
"from",
"the",
"list",
"to",
"load",
"when",
"building",
"the",
"list",
"of",
"installed",
"applications",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3414-L3419 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.isApplicationInstalled | def isApplicationInstalled(self, pchAppKey):
"""Returns true if an application is installed"""
fn = self.function_table.isApplicationInstalled
result = fn(pchAppKey)
return result | python | def isApplicationInstalled(self, pchAppKey):
"""Returns true if an application is installed"""
fn = self.function_table.isApplicationInstalled
result = fn(pchAppKey)
return result | [
"def",
"isApplicationInstalled",
"(",
"self",
",",
"pchAppKey",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"isApplicationInstalled",
"result",
"=",
"fn",
"(",
"pchAppKey",
")",
"return",
"result"
] | Returns true if an application is installed | [
"Returns",
"true",
"if",
"an",
"application",
"is",
"installed"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3421-L3426 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationKeyByProcessId | def getApplicationKeyByProcessId(self, unProcessId, pchAppKeyBuffer, unAppKeyBufferLen):
"""
Returns the key of the application for the specified Process Id. The buffer should be at least
k_unMaxApplicationKeyLength in order to fit the key.
"""
fn = self.function_table.getApplicationKeyByProcessId
result = fn(unProcessId, pchAppKeyBuffer, unAppKeyBufferLen)
return result | python | def getApplicationKeyByProcessId(self, unProcessId, pchAppKeyBuffer, unAppKeyBufferLen):
"""
Returns the key of the application for the specified Process Id. The buffer should be at least
k_unMaxApplicationKeyLength in order to fit the key.
"""
fn = self.function_table.getApplicationKeyByProcessId
result = fn(unProcessId, pchAppKeyBuffer, unAppKeyBufferLen)
return result | [
"def",
"getApplicationKeyByProcessId",
"(",
"self",
",",
"unProcessId",
",",
"pchAppKeyBuffer",
",",
"unAppKeyBufferLen",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationKeyByProcessId",
"result",
"=",
"fn",
"(",
"unProcessId",
",",
"pchAppKeyBuffer",
",",
"unAppKeyBufferLen",
")",
"return",
"result"
] | Returns the key of the application for the specified Process Id. The buffer should be at least
k_unMaxApplicationKeyLength in order to fit the key. | [
"Returns",
"the",
"key",
"of",
"the",
"application",
"for",
"the",
"specified",
"Process",
"Id",
".",
"The",
"buffer",
"should",
"be",
"at",
"least",
"k_unMaxApplicationKeyLength",
"in",
"order",
"to",
"fit",
"the",
"key",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3446-L3454 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.launchApplication | def launchApplication(self, pchAppKey):
"""
Launches the application. The existing scene application will exit and then the new application will start.
This call is not valid for dashboard overlay applications.
"""
fn = self.function_table.launchApplication
result = fn(pchAppKey)
return result | python | def launchApplication(self, pchAppKey):
"""
Launches the application. The existing scene application will exit and then the new application will start.
This call is not valid for dashboard overlay applications.
"""
fn = self.function_table.launchApplication
result = fn(pchAppKey)
return result | [
"def",
"launchApplication",
"(",
"self",
",",
"pchAppKey",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"launchApplication",
"result",
"=",
"fn",
"(",
"pchAppKey",
")",
"return",
"result"
] | Launches the application. The existing scene application will exit and then the new application will start.
This call is not valid for dashboard overlay applications. | [
"Launches",
"the",
"application",
".",
"The",
"existing",
"scene",
"application",
"will",
"exit",
"and",
"then",
"the",
"new",
"application",
"will",
"start",
".",
"This",
"call",
"is",
"not",
"valid",
"for",
"dashboard",
"overlay",
"applications",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3456-L3464 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.launchApplicationFromMimeType | def launchApplicationFromMimeType(self, pchMimeType, pchArgs):
"""launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched"""
fn = self.function_table.launchApplicationFromMimeType
result = fn(pchMimeType, pchArgs)
return result | python | def launchApplicationFromMimeType(self, pchMimeType, pchArgs):
"""launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched"""
fn = self.function_table.launchApplicationFromMimeType
result = fn(pchMimeType, pchArgs)
return result | [
"def",
"launchApplicationFromMimeType",
"(",
"self",
",",
"pchMimeType",
",",
"pchArgs",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"launchApplicationFromMimeType",
"result",
"=",
"fn",
"(",
"pchMimeType",
",",
"pchArgs",
")",
"return",
"result"
] | launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched | [
"launches",
"the",
"application",
"currently",
"associated",
"with",
"this",
"mime",
"type",
"and",
"passes",
"it",
"the",
"option",
"args",
"typically",
"the",
"filename",
"or",
"object",
"name",
"of",
"the",
"item",
"being",
"launched"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3477-L3482 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.launchDashboardOverlay | def launchDashboardOverlay(self, pchAppKey):
"""
Launches the dashboard overlay application if it is not already running. This call is only valid for
dashboard overlay applications.
"""
fn = self.function_table.launchDashboardOverlay
result = fn(pchAppKey)
return result | python | def launchDashboardOverlay(self, pchAppKey):
"""
Launches the dashboard overlay application if it is not already running. This call is only valid for
dashboard overlay applications.
"""
fn = self.function_table.launchDashboardOverlay
result = fn(pchAppKey)
return result | [
"def",
"launchDashboardOverlay",
"(",
"self",
",",
"pchAppKey",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"launchDashboardOverlay",
"result",
"=",
"fn",
"(",
"pchAppKey",
")",
"return",
"result"
] | Launches the dashboard overlay application if it is not already running. This call is only valid for
dashboard overlay applications. | [
"Launches",
"the",
"dashboard",
"overlay",
"application",
"if",
"it",
"is",
"not",
"already",
"running",
".",
"This",
"call",
"is",
"only",
"valid",
"for",
"dashboard",
"overlay",
"applications",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3484-L3492 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.cancelApplicationLaunch | def cancelApplicationLaunch(self, pchAppKey):
"""Cancel a pending launch for an application"""
fn = self.function_table.cancelApplicationLaunch
result = fn(pchAppKey)
return result | python | def cancelApplicationLaunch(self, pchAppKey):
"""Cancel a pending launch for an application"""
fn = self.function_table.cancelApplicationLaunch
result = fn(pchAppKey)
return result | [
"def",
"cancelApplicationLaunch",
"(",
"self",
",",
"pchAppKey",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"cancelApplicationLaunch",
"result",
"=",
"fn",
"(",
"pchAppKey",
")",
"return",
"result"
] | Cancel a pending launch for an application | [
"Cancel",
"a",
"pending",
"launch",
"for",
"an",
"application"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3494-L3499 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationProcessId | def getApplicationProcessId(self, pchAppKey):
"""Returns the process ID for an application. Return 0 if the application was not found or is not running."""
fn = self.function_table.getApplicationProcessId
result = fn(pchAppKey)
return result | python | def getApplicationProcessId(self, pchAppKey):
"""Returns the process ID for an application. Return 0 if the application was not found or is not running."""
fn = self.function_table.getApplicationProcessId
result = fn(pchAppKey)
return result | [
"def",
"getApplicationProcessId",
"(",
"self",
",",
"pchAppKey",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationProcessId",
"result",
"=",
"fn",
"(",
"pchAppKey",
")",
"return",
"result"
] | Returns the process ID for an application. Return 0 if the application was not found or is not running. | [
"Returns",
"the",
"process",
"ID",
"for",
"an",
"application",
".",
"Return",
"0",
"if",
"the",
"application",
"was",
"not",
"found",
"or",
"is",
"not",
"running",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3513-L3518 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationsErrorNameFromEnum | def getApplicationsErrorNameFromEnum(self, error):
"""Returns a string for an applications error"""
fn = self.function_table.getApplicationsErrorNameFromEnum
result = fn(error)
return result | python | def getApplicationsErrorNameFromEnum(self, error):
"""Returns a string for an applications error"""
fn = self.function_table.getApplicationsErrorNameFromEnum
result = fn(error)
return result | [
"def",
"getApplicationsErrorNameFromEnum",
"(",
"self",
",",
"error",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationsErrorNameFromEnum",
"result",
"=",
"fn",
"(",
"error",
")",
"return",
"result"
] | Returns a string for an applications error | [
"Returns",
"a",
"string",
"for",
"an",
"applications",
"error"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3520-L3525 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationPropertyString | def getApplicationPropertyString(self, pchAppKey, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen):
"""Returns a value for an application property. The required buffer size to fit this value will be returned."""
fn = self.function_table.getApplicationPropertyString
peError = EVRApplicationError()
result = fn(pchAppKey, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen, byref(peError))
return result, peError | python | def getApplicationPropertyString(self, pchAppKey, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen):
"""Returns a value for an application property. The required buffer size to fit this value will be returned."""
fn = self.function_table.getApplicationPropertyString
peError = EVRApplicationError()
result = fn(pchAppKey, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen, byref(peError))
return result, peError | [
"def",
"getApplicationPropertyString",
"(",
"self",
",",
"pchAppKey",
",",
"eProperty",
",",
"pchPropertyValueBuffer",
",",
"unPropertyValueBufferLen",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationPropertyString",
"peError",
"=",
"EVRApplicationError",
"(",
")",
"result",
"=",
"fn",
"(",
"pchAppKey",
",",
"eProperty",
",",
"pchPropertyValueBuffer",
",",
"unPropertyValueBufferLen",
",",
"byref",
"(",
"peError",
")",
")",
"return",
"result",
",",
"peError"
] | Returns a value for an application property. The required buffer size to fit this value will be returned. | [
"Returns",
"a",
"value",
"for",
"an",
"application",
"property",
".",
"The",
"required",
"buffer",
"size",
"to",
"fit",
"this",
"value",
"will",
"be",
"returned",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3527-L3533 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationPropertyBool | def getApplicationPropertyBool(self, pchAppKey, eProperty):
"""Returns a bool value for an application property. Returns false in all error cases."""
fn = self.function_table.getApplicationPropertyBool
peError = EVRApplicationError()
result = fn(pchAppKey, eProperty, byref(peError))
return result, peError | python | def getApplicationPropertyBool(self, pchAppKey, eProperty):
"""Returns a bool value for an application property. Returns false in all error cases."""
fn = self.function_table.getApplicationPropertyBool
peError = EVRApplicationError()
result = fn(pchAppKey, eProperty, byref(peError))
return result, peError | [
"def",
"getApplicationPropertyBool",
"(",
"self",
",",
"pchAppKey",
",",
"eProperty",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationPropertyBool",
"peError",
"=",
"EVRApplicationError",
"(",
")",
"result",
"=",
"fn",
"(",
"pchAppKey",
",",
"eProperty",
",",
"byref",
"(",
"peError",
")",
")",
"return",
"result",
",",
"peError"
] | Returns a bool value for an application property. Returns false in all error cases. | [
"Returns",
"a",
"bool",
"value",
"for",
"an",
"application",
"property",
".",
"Returns",
"false",
"in",
"all",
"error",
"cases",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3535-L3541 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.setApplicationAutoLaunch | def setApplicationAutoLaunch(self, pchAppKey, bAutoLaunch):
"""Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool."""
fn = self.function_table.setApplicationAutoLaunch
result = fn(pchAppKey, bAutoLaunch)
return result | python | def setApplicationAutoLaunch(self, pchAppKey, bAutoLaunch):
"""Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool."""
fn = self.function_table.setApplicationAutoLaunch
result = fn(pchAppKey, bAutoLaunch)
return result | [
"def",
"setApplicationAutoLaunch",
"(",
"self",
",",
"pchAppKey",
",",
"bAutoLaunch",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"setApplicationAutoLaunch",
"result",
"=",
"fn",
"(",
"pchAppKey",
",",
"bAutoLaunch",
")",
"return",
"result"
] | Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. | [
"Sets",
"the",
"application",
"auto",
"-",
"launch",
"flag",
".",
"This",
"is",
"only",
"valid",
"for",
"applications",
"which",
"return",
"true",
"for",
"VRApplicationProperty_IsDashboardOverlay_Bool",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3551-L3556 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationAutoLaunch | def getApplicationAutoLaunch(self, pchAppKey):
"""Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool."""
fn = self.function_table.getApplicationAutoLaunch
result = fn(pchAppKey)
return result | python | def getApplicationAutoLaunch(self, pchAppKey):
"""Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool."""
fn = self.function_table.getApplicationAutoLaunch
result = fn(pchAppKey)
return result | [
"def",
"getApplicationAutoLaunch",
"(",
"self",
",",
"pchAppKey",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationAutoLaunch",
"result",
"=",
"fn",
"(",
"pchAppKey",
")",
"return",
"result"
] | Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. | [
"Gets",
"the",
"application",
"auto",
"-",
"launch",
"flag",
".",
"This",
"is",
"only",
"valid",
"for",
"applications",
"which",
"return",
"true",
"for",
"VRApplicationProperty_IsDashboardOverlay_Bool",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3558-L3563 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.setDefaultApplicationForMimeType | def setDefaultApplicationForMimeType(self, pchAppKey, pchMimeType):
"""Adds this mime-type to the list of supported mime types for this application"""
fn = self.function_table.setDefaultApplicationForMimeType
result = fn(pchAppKey, pchMimeType)
return result | python | def setDefaultApplicationForMimeType(self, pchAppKey, pchMimeType):
"""Adds this mime-type to the list of supported mime types for this application"""
fn = self.function_table.setDefaultApplicationForMimeType
result = fn(pchAppKey, pchMimeType)
return result | [
"def",
"setDefaultApplicationForMimeType",
"(",
"self",
",",
"pchAppKey",
",",
"pchMimeType",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"setDefaultApplicationForMimeType",
"result",
"=",
"fn",
"(",
"pchAppKey",
",",
"pchMimeType",
")",
"return",
"result"
] | Adds this mime-type to the list of supported mime types for this application | [
"Adds",
"this",
"mime",
"-",
"type",
"to",
"the",
"list",
"of",
"supported",
"mime",
"types",
"for",
"this",
"application"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3565-L3570 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getDefaultApplicationForMimeType | def getDefaultApplicationForMimeType(self, pchMimeType, pchAppKeyBuffer, unAppKeyBufferLen):
"""return the app key that will open this mime type"""
fn = self.function_table.getDefaultApplicationForMimeType
result = fn(pchMimeType, pchAppKeyBuffer, unAppKeyBufferLen)
return result | python | def getDefaultApplicationForMimeType(self, pchMimeType, pchAppKeyBuffer, unAppKeyBufferLen):
"""return the app key that will open this mime type"""
fn = self.function_table.getDefaultApplicationForMimeType
result = fn(pchMimeType, pchAppKeyBuffer, unAppKeyBufferLen)
return result | [
"def",
"getDefaultApplicationForMimeType",
"(",
"self",
",",
"pchMimeType",
",",
"pchAppKeyBuffer",
",",
"unAppKeyBufferLen",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getDefaultApplicationForMimeType",
"result",
"=",
"fn",
"(",
"pchMimeType",
",",
"pchAppKeyBuffer",
",",
"unAppKeyBufferLen",
")",
"return",
"result"
] | return the app key that will open this mime type | [
"return",
"the",
"app",
"key",
"that",
"will",
"open",
"this",
"mime",
"type"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3572-L3577 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationSupportedMimeTypes | def getApplicationSupportedMimeTypes(self, pchAppKey, pchMimeTypesBuffer, unMimeTypesBuffer):
"""Get the list of supported mime types for this application, comma-delimited"""
fn = self.function_table.getApplicationSupportedMimeTypes
result = fn(pchAppKey, pchMimeTypesBuffer, unMimeTypesBuffer)
return result | python | def getApplicationSupportedMimeTypes(self, pchAppKey, pchMimeTypesBuffer, unMimeTypesBuffer):
"""Get the list of supported mime types for this application, comma-delimited"""
fn = self.function_table.getApplicationSupportedMimeTypes
result = fn(pchAppKey, pchMimeTypesBuffer, unMimeTypesBuffer)
return result | [
"def",
"getApplicationSupportedMimeTypes",
"(",
"self",
",",
"pchAppKey",
",",
"pchMimeTypesBuffer",
",",
"unMimeTypesBuffer",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationSupportedMimeTypes",
"result",
"=",
"fn",
"(",
"pchAppKey",
",",
"pchMimeTypesBuffer",
",",
"unMimeTypesBuffer",
")",
"return",
"result"
] | Get the list of supported mime types for this application, comma-delimited | [
"Get",
"the",
"list",
"of",
"supported",
"mime",
"types",
"for",
"this",
"application",
"comma",
"-",
"delimited"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3579-L3584 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationsThatSupportMimeType | def getApplicationsThatSupportMimeType(self, pchMimeType, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer):
"""Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string"""
fn = self.function_table.getApplicationsThatSupportMimeType
result = fn(pchMimeType, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer)
return result | python | def getApplicationsThatSupportMimeType(self, pchMimeType, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer):
"""Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string"""
fn = self.function_table.getApplicationsThatSupportMimeType
result = fn(pchMimeType, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer)
return result | [
"def",
"getApplicationsThatSupportMimeType",
"(",
"self",
",",
"pchMimeType",
",",
"pchAppKeysThatSupportBuffer",
",",
"unAppKeysThatSupportBuffer",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationsThatSupportMimeType",
"result",
"=",
"fn",
"(",
"pchMimeType",
",",
"pchAppKeysThatSupportBuffer",
",",
"unAppKeysThatSupportBuffer",
")",
"return",
"result"
] | Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string | [
"Get",
"the",
"list",
"of",
"app",
"-",
"keys",
"that",
"support",
"this",
"mime",
"type",
"comma",
"-",
"delimited",
"the",
"return",
"value",
"is",
"number",
"of",
"bytes",
"you",
"need",
"to",
"return",
"the",
"full",
"string"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3586-L3591 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationLaunchArguments | def getApplicationLaunchArguments(self, unHandle, pchArgs, unArgs):
"""Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad"""
fn = self.function_table.getApplicationLaunchArguments
result = fn(unHandle, pchArgs, unArgs)
return result | python | def getApplicationLaunchArguments(self, unHandle, pchArgs, unArgs):
"""Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad"""
fn = self.function_table.getApplicationLaunchArguments
result = fn(unHandle, pchArgs, unArgs)
return result | [
"def",
"getApplicationLaunchArguments",
"(",
"self",
",",
"unHandle",
",",
"pchArgs",
",",
"unArgs",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationLaunchArguments",
"result",
"=",
"fn",
"(",
"unHandle",
",",
"pchArgs",
",",
"unArgs",
")",
"return",
"result"
] | Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad | [
"Get",
"the",
"args",
"list",
"from",
"an",
"app",
"launch",
"that",
"had",
"the",
"process",
"already",
"running",
"you",
"call",
"this",
"when",
"you",
"get",
"a",
"VREvent_ApplicationMimeTypeLoad"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3593-L3598 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getStartingApplication | def getStartingApplication(self, pchAppKeyBuffer, unAppKeyBufferLen):
"""Returns the app key for the application that is starting up"""
fn = self.function_table.getStartingApplication
result = fn(pchAppKeyBuffer, unAppKeyBufferLen)
return result | python | def getStartingApplication(self, pchAppKeyBuffer, unAppKeyBufferLen):
"""Returns the app key for the application that is starting up"""
fn = self.function_table.getStartingApplication
result = fn(pchAppKeyBuffer, unAppKeyBufferLen)
return result | [
"def",
"getStartingApplication",
"(",
"self",
",",
"pchAppKeyBuffer",
",",
"unAppKeyBufferLen",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getStartingApplication",
"result",
"=",
"fn",
"(",
"pchAppKeyBuffer",
",",
"unAppKeyBufferLen",
")",
"return",
"result"
] | Returns the app key for the application that is starting up | [
"Returns",
"the",
"app",
"key",
"for",
"the",
"application",
"that",
"is",
"starting",
"up"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3600-L3605 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.getApplicationsTransitionStateNameFromEnum | def getApplicationsTransitionStateNameFromEnum(self, state):
"""Returns a string for an application transition state"""
fn = self.function_table.getApplicationsTransitionStateNameFromEnum
result = fn(state)
return result | python | def getApplicationsTransitionStateNameFromEnum(self, state):
"""Returns a string for an application transition state"""
fn = self.function_table.getApplicationsTransitionStateNameFromEnum
result = fn(state)
return result | [
"def",
"getApplicationsTransitionStateNameFromEnum",
"(",
"self",
",",
"state",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getApplicationsTransitionStateNameFromEnum",
"result",
"=",
"fn",
"(",
"state",
")",
"return",
"result"
] | Returns a string for an application transition state | [
"Returns",
"a",
"string",
"for",
"an",
"application",
"transition",
"state"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3630-L3635 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRApplications.launchInternalProcess | def launchInternalProcess(self, pchBinaryPath, pchArguments, pchWorkingDirectory):
"""
Starts a subprocess within the calling application. This
suppresses all application transition UI and automatically identifies the new executable
as part of the same application. On success the calling process should exit immediately.
If working directory is NULL or "" the directory portion of the binary path will be
the working directory.
"""
fn = self.function_table.launchInternalProcess
result = fn(pchBinaryPath, pchArguments, pchWorkingDirectory)
return result | python | def launchInternalProcess(self, pchBinaryPath, pchArguments, pchWorkingDirectory):
"""
Starts a subprocess within the calling application. This
suppresses all application transition UI and automatically identifies the new executable
as part of the same application. On success the calling process should exit immediately.
If working directory is NULL or "" the directory portion of the binary path will be
the working directory.
"""
fn = self.function_table.launchInternalProcess
result = fn(pchBinaryPath, pchArguments, pchWorkingDirectory)
return result | [
"def",
"launchInternalProcess",
"(",
"self",
",",
"pchBinaryPath",
",",
"pchArguments",
",",
"pchWorkingDirectory",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"launchInternalProcess",
"result",
"=",
"fn",
"(",
"pchBinaryPath",
",",
"pchArguments",
",",
"pchWorkingDirectory",
")",
"return",
"result"
] | Starts a subprocess within the calling application. This
suppresses all application transition UI and automatically identifies the new executable
as part of the same application. On success the calling process should exit immediately.
If working directory is NULL or "" the directory portion of the binary path will be
the working directory. | [
"Starts",
"a",
"subprocess",
"within",
"the",
"calling",
"application",
".",
"This",
"suppresses",
"all",
"application",
"transition",
"UI",
"and",
"automatically",
"identifies",
"the",
"new",
"executable",
"as",
"part",
"of",
"the",
"same",
"application",
".",
"On",
"success",
"the",
"calling",
"process",
"should",
"exit",
"immediately",
".",
"If",
"working",
"directory",
"is",
"NULL",
"or",
"the",
"directory",
"portion",
"of",
"the",
"binary",
"path",
"will",
"be",
"the",
"working",
"directory",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3644-L3655 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRChaperone.getBoundsColor | def getBoundsColor(self, nNumOutputColors, flCollisionBoundsFadeDistance):
"""Get the current chaperone bounds draw color and brightness"""
fn = self.function_table.getBoundsColor
pOutputColorArray = HmdColor_t()
pOutputCameraColor = HmdColor_t()
fn(byref(pOutputColorArray), nNumOutputColors, flCollisionBoundsFadeDistance, byref(pOutputCameraColor))
return pOutputColorArray, pOutputCameraColor | python | def getBoundsColor(self, nNumOutputColors, flCollisionBoundsFadeDistance):
"""Get the current chaperone bounds draw color and brightness"""
fn = self.function_table.getBoundsColor
pOutputColorArray = HmdColor_t()
pOutputCameraColor = HmdColor_t()
fn(byref(pOutputColorArray), nNumOutputColors, flCollisionBoundsFadeDistance, byref(pOutputCameraColor))
return pOutputColorArray, pOutputCameraColor | [
"def",
"getBoundsColor",
"(",
"self",
",",
"nNumOutputColors",
",",
"flCollisionBoundsFadeDistance",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getBoundsColor",
"pOutputColorArray",
"=",
"HmdColor_t",
"(",
")",
"pOutputCameraColor",
"=",
"HmdColor_t",
"(",
")",
"fn",
"(",
"byref",
"(",
"pOutputColorArray",
")",
",",
"nNumOutputColors",
",",
"flCollisionBoundsFadeDistance",
",",
"byref",
"(",
"pOutputCameraColor",
")",
")",
"return",
"pOutputColorArray",
",",
"pOutputCameraColor"
] | Get the current chaperone bounds draw color and brightness | [
"Get",
"the",
"current",
"chaperone",
"bounds",
"draw",
"color",
"and",
"brightness"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3749-L3756 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRChaperoneSetup.commitWorkingCopy | def commitWorkingCopy(self, configFile):
"""Saves the current working copy to disk"""
fn = self.function_table.commitWorkingCopy
result = fn(configFile)
return result | python | def commitWorkingCopy(self, configFile):
"""Saves the current working copy to disk"""
fn = self.function_table.commitWorkingCopy
result = fn(configFile)
return result | [
"def",
"commitWorkingCopy",
"(",
"self",
",",
"configFile",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"commitWorkingCopy",
"result",
"=",
"fn",
"(",
"configFile",
")",
"return",
"result"
] | Saves the current working copy to disk | [
"Saves",
"the",
"current",
"working",
"copy",
"to",
"disk"
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3817-L3822 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRChaperoneSetup.getWorkingCollisionBoundsInfo | def getWorkingCollisionBoundsInfo(self):
"""
Returns the number of Quads if the buffer points to null. Otherwise it returns Quads
into the buffer up to the max specified from the working copy.
"""
fn = self.function_table.getWorkingCollisionBoundsInfo
pQuadsBuffer = HmdQuad_t()
punQuadsCount = c_uint32()
result = fn(byref(pQuadsBuffer), byref(punQuadsCount))
return result, pQuadsBuffer, punQuadsCount.value | python | def getWorkingCollisionBoundsInfo(self):
"""
Returns the number of Quads if the buffer points to null. Otherwise it returns Quads
into the buffer up to the max specified from the working copy.
"""
fn = self.function_table.getWorkingCollisionBoundsInfo
pQuadsBuffer = HmdQuad_t()
punQuadsCount = c_uint32()
result = fn(byref(pQuadsBuffer), byref(punQuadsCount))
return result, pQuadsBuffer, punQuadsCount.value | [
"def",
"getWorkingCollisionBoundsInfo",
"(",
"self",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getWorkingCollisionBoundsInfo",
"pQuadsBuffer",
"=",
"HmdQuad_t",
"(",
")",
"punQuadsCount",
"=",
"c_uint32",
"(",
")",
"result",
"=",
"fn",
"(",
"byref",
"(",
"pQuadsBuffer",
")",
",",
"byref",
"(",
"punQuadsCount",
")",
")",
"return",
"result",
",",
"pQuadsBuffer",
",",
"punQuadsCount",
".",
"value"
] | Returns the number of Quads if the buffer points to null. Otherwise it returns Quads
into the buffer up to the max specified from the working copy. | [
"Returns",
"the",
"number",
"of",
"Quads",
"if",
"the",
"buffer",
"points",
"to",
"null",
".",
"Otherwise",
"it",
"returns",
"Quads",
"into",
"the",
"buffer",
"up",
"to",
"the",
"max",
"specified",
"from",
"the",
"working",
"copy",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3861-L3871 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRChaperoneSetup.getWorkingSeatedZeroPoseToRawTrackingPose | def getWorkingSeatedZeroPoseToRawTrackingPose(self):
"""Returns the preferred seated position from the working copy."""
fn = self.function_table.getWorkingSeatedZeroPoseToRawTrackingPose
pmatSeatedZeroPoseToRawTrackingPose = HmdMatrix34_t()
result = fn(byref(pmatSeatedZeroPoseToRawTrackingPose))
return result, pmatSeatedZeroPoseToRawTrackingPose | python | def getWorkingSeatedZeroPoseToRawTrackingPose(self):
"""Returns the preferred seated position from the working copy."""
fn = self.function_table.getWorkingSeatedZeroPoseToRawTrackingPose
pmatSeatedZeroPoseToRawTrackingPose = HmdMatrix34_t()
result = fn(byref(pmatSeatedZeroPoseToRawTrackingPose))
return result, pmatSeatedZeroPoseToRawTrackingPose | [
"def",
"getWorkingSeatedZeroPoseToRawTrackingPose",
"(",
"self",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getWorkingSeatedZeroPoseToRawTrackingPose",
"pmatSeatedZeroPoseToRawTrackingPose",
"=",
"HmdMatrix34_t",
"(",
")",
"result",
"=",
"fn",
"(",
"byref",
"(",
"pmatSeatedZeroPoseToRawTrackingPose",
")",
")",
"return",
"result",
",",
"pmatSeatedZeroPoseToRawTrackingPose"
] | Returns the preferred seated position from the working copy. | [
"Returns",
"the",
"preferred",
"seated",
"position",
"from",
"the",
"working",
"copy",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3885-L3891 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRChaperoneSetup.getWorkingStandingZeroPoseToRawTrackingPose | def getWorkingStandingZeroPoseToRawTrackingPose(self):
"""Returns the standing origin from the working copy."""
fn = self.function_table.getWorkingStandingZeroPoseToRawTrackingPose
pmatStandingZeroPoseToRawTrackingPose = HmdMatrix34_t()
result = fn(byref(pmatStandingZeroPoseToRawTrackingPose))
return result, pmatStandingZeroPoseToRawTrackingPose | python | def getWorkingStandingZeroPoseToRawTrackingPose(self):
"""Returns the standing origin from the working copy."""
fn = self.function_table.getWorkingStandingZeroPoseToRawTrackingPose
pmatStandingZeroPoseToRawTrackingPose = HmdMatrix34_t()
result = fn(byref(pmatStandingZeroPoseToRawTrackingPose))
return result, pmatStandingZeroPoseToRawTrackingPose | [
"def",
"getWorkingStandingZeroPoseToRawTrackingPose",
"(",
"self",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"getWorkingStandingZeroPoseToRawTrackingPose",
"pmatStandingZeroPoseToRawTrackingPose",
"=",
"HmdMatrix34_t",
"(",
")",
"result",
"=",
"fn",
"(",
"byref",
"(",
"pmatStandingZeroPoseToRawTrackingPose",
")",
")",
"return",
"result",
",",
"pmatStandingZeroPoseToRawTrackingPose"
] | Returns the standing origin from the working copy. | [
"Returns",
"the",
"standing",
"origin",
"from",
"the",
"working",
"copy",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3893-L3899 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRChaperoneSetup.setWorkingPlayAreaSize | def setWorkingPlayAreaSize(self, sizeX, sizeZ):
"""Sets the Play Area in the working copy."""
fn = self.function_table.setWorkingPlayAreaSize
fn(sizeX, sizeZ) | python | def setWorkingPlayAreaSize(self, sizeX, sizeZ):
"""Sets the Play Area in the working copy."""
fn = self.function_table.setWorkingPlayAreaSize
fn(sizeX, sizeZ) | [
"def",
"setWorkingPlayAreaSize",
"(",
"self",
",",
"sizeX",
",",
"sizeZ",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"setWorkingPlayAreaSize",
"fn",
"(",
"sizeX",
",",
"sizeZ",
")"
] | Sets the Play Area in the working copy. | [
"Sets",
"the",
"Play",
"Area",
"in",
"the",
"working",
"copy",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3901-L3905 | train |
cmbruns/pyopenvr | src/openvr/__init__.py | IVRChaperoneSetup.setWorkingSeatedZeroPoseToRawTrackingPose | def setWorkingSeatedZeroPoseToRawTrackingPose(self):
"""Sets the preferred seated position in the working copy."""
fn = self.function_table.setWorkingSeatedZeroPoseToRawTrackingPose
pMatSeatedZeroPoseToRawTrackingPose = HmdMatrix34_t()
fn(byref(pMatSeatedZeroPoseToRawTrackingPose))
return pMatSeatedZeroPoseToRawTrackingPose | python | def setWorkingSeatedZeroPoseToRawTrackingPose(self):
"""Sets the preferred seated position in the working copy."""
fn = self.function_table.setWorkingSeatedZeroPoseToRawTrackingPose
pMatSeatedZeroPoseToRawTrackingPose = HmdMatrix34_t()
fn(byref(pMatSeatedZeroPoseToRawTrackingPose))
return pMatSeatedZeroPoseToRawTrackingPose | [
"def",
"setWorkingSeatedZeroPoseToRawTrackingPose",
"(",
"self",
")",
":",
"fn",
"=",
"self",
".",
"function_table",
".",
"setWorkingSeatedZeroPoseToRawTrackingPose",
"pMatSeatedZeroPoseToRawTrackingPose",
"=",
"HmdMatrix34_t",
"(",
")",
"fn",
"(",
"byref",
"(",
"pMatSeatedZeroPoseToRawTrackingPose",
")",
")",
"return",
"pMatSeatedZeroPoseToRawTrackingPose"
] | Sets the preferred seated position in the working copy. | [
"Sets",
"the",
"preferred",
"seated",
"position",
"in",
"the",
"working",
"copy",
"."
] | 68395d26bb3df6ab1f0f059c38d441f962938be6 | https://github.com/cmbruns/pyopenvr/blob/68395d26bb3df6ab1f0f059c38d441f962938be6/src/openvr/__init__.py#L3923-L3929 | train |
Subsets and Splits