def create(self,
course: int,
title: str,
units: List[int] = None,
position: int = None,
discounting_policy: str = None,
required_section: int = None,
required_percent: int = None,
is_exam: bool = None,
exam_duration_minutes: int = None,
description: str = None,
begin_date_source: str = None,
end_date_source: str = None,
soft_deadline_source: str = None,
hard_deadline_source: str = None,
grading_policy_source: str = None,
**kwargs) -> Section:
vars = locals().copy()
data = {
'section': {
k: v
for k, v in {
**vars,
**kwargs
}.items() if k != 'self' and v is not None
}
}
response = self._stepik._post('sections', data)
if 'sections' not in response:
raise StepikError(response)
return Section(self._stepik, response['sections'][0])
def create(self,
title: str,
steps: List[int] = None,
cover_url: str = None,
is_comments_enabled: bool = None,
language: str = None,
is_public: bool = None,
lti_consumer_key: str = None,
lti_secret_key: str = None,
lti_private_profile: bool = None,
**kwargs) -> Lesson:
vars = locals().copy()
data = {
'lesson': {
k: v
for k, v in {
**vars,
**kwargs
}.items() if k != 'self' and v is not None
}
}
response = self._stepik._post('lessons', data)
if 'lessons' not in response:
raise StepikError(response)
return Lesson(self._stepik, response['lessons'][0])
def create(self,
section: int,
lesson: int,
assignments: List[int] = None,
position: int = None,
begin_date_source: str = None,
end_date_source: str = None,
soft_deadline_source: str = None,
hard_deadline_source: str = None,
grading_policy_source: str = None,
**kwargs) -> Unit:
vars = locals().copy()
data = {
'unit': {
k: v
for k, v in {
**vars,
**kwargs
}.items() if k != 'self' and v is not None
}
}
response = self._stepik._post('units', data)
if 'units' not in response:
raise StepikError(response)
return Unit(self._stepik, response['units'][0])
def create(self,
subject: str,
text: str,
course: str = None,
user: str = None,
is_restricted_by_score: bool = None,
score_percent_min: int = None,
score_percent_max: int = None,
email_template: str = None,
is_scheduled: bool = None,
start_date: str = None,
mail_period_days: int = None,
mail_quantity: int = None,
is_infinite: bool = None,
on_enroll: bool = None,
**kwargs) -> Announcement:
vars = locals().copy()
data = {'announcement':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('announcements', data)
if 'announcements' not in response:
raise StepikError(response)
return Announcement(self._stepik, response['announcements'][0])
def update(self, obj: SocialProfile) -> SocialProfile:
required = ['provider', 'name']
vars = obj._data
data = {'social-profile':
{k: v for k, v in vars.items()
if k != 'self' and v is not None and k in required }}
response = self._stepik._put(f'social-profiles/{ obj.id }', data)
if 'social-profiles' not in response:
raise StepikError(response)
return SocialProfile(self._stepik, response['social-profiles'][0])
def update(self, obj: Instruction) -> Instruction:
required = ['step', 'min_reviews', 'strategy_type', 'rubrics', 'text']
vars = obj._data
data = {'instruction':
{k: v for k, v in vars.items()
if k != 'self' and v is not None and k in required }}
response = self._stepik._put(f'instructions/{ obj.id }', data)
if 'instructions' not in response:
raise StepikError(response)
return Instruction(self._stepik, response['instructions'][0])
def update(self, obj: StepSource) -> StepSource:
required = ['lesson', 'block', 'position', 'is_solutions_unlocked', 'solutions_unlocked_attempts', 'has_submissions_restrictions', 'max_submissions_count', 'cost']
vars = obj._data
data = {'step-source':
{k: v for k, v in vars.items()
if k != 'self' and v is not None and k in required }}
response = self._stepik._put(f'step-sources/{ obj.id }', data)
if 'step-sources' not in response:
raise StepikError(response)
return StepSource(self._stepik, response['step-sources'][0])
def update(self, obj: Announcement) -> Announcement:
required = ['subject', 'text', 'course', 'user', 'is_restricted_by_score', 'score_percent_min', 'score_percent_max', 'email_template', 'is_scheduled', 'start_date', 'mail_period_days', 'mail_quantity', 'is_infinite', 'on_enroll']
vars = obj._data
data = {'announcement':
{k: v for k, v in vars.items()
if k != 'self' and v is not None and k in required }}
response = self._stepik._put(f'announcements/{ obj.id }', data)
if 'announcements' not in response:
raise StepikError(response)
return Announcement(self._stepik, response['announcements'][0])
def update(self, obj: Course) -> Course:
required = ['title', 'summary', 'workload', 'intro', 'course_format', 'target_audience', 'is_certificate_auto_issued', 'certificate_regular_threshold', 'certificate_distinction_threshold', 'instructors', 'certificate', 'requirements', 'description', 'sections', 'is_adaptive', 'is_idea_compatible', 'intro_video', 'authors', 'tags', 'is_enabled', 'language', 'is_public', 'begin_date_source', 'end_date_source', 'soft_deadline_source', 'hard_deadline_source', 'grading_policy_source', 'lti_consumer_key', 'lti_secret_key', 'lti_private_profile']
vars = obj._data
data = {'course':
{k: v for k, v in vars.items()
if k != 'self' and v is not None and k in required }}
response = self._stepik._put(f'courses/{ obj.id }', data)
if 'courses' not in response:
raise StepikError(response)
return Course(self._stepik, response['courses'][0])
def update(self, obj: Comment) -> Comment:
required = ['target', 'parent', 'text', 'is_pinned', 'is_reported', 'attachments', 'thread', 'submission']
vars = obj._data
data = {'comment':
{k: v for k, v in vars.items()
if k != 'self' and v is not None and k in required }}
response = self._stepik._put(f'comments/{ obj.id }', data)
if 'comments' not in response:
raise StepikError(response)
return Comment(self._stepik, response['comments'][0])
def update(self, obj: Review) -> Review:
required = ['session', 'target_session', 'text', 'rubric_scores']
vars = obj._data
data = {'review':
{k: v for k, v in vars.items()
if k != 'self' and v is not None and k in required }}
response = self._stepik._put(f'reviews/{ obj.id }', data)
if 'reviews' not in response:
raise StepikError(response)
return Review(self._stepik, response['reviews'][0])
def create(self,
course: str,
**kwargs) -> FavoriteCourse:
vars = locals().copy()
data = {'favorite-course':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('favorite-courses', data)
if 'favorite-courses' not in response:
raise StepikError(response)
return FavoriteCourse(self._stepik, response['favorite-courses'][0])
def create(self,
result: str,
**kwargs) -> SearchReaction:
vars = locals().copy()
data = {'search-reaction':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('search-reactions', data)
if 'search-reactions' not in response:
raise StepikError(response)
return SearchReaction(self._stepik, response['search-reactions'][0])
def create(self,
followee: str,
**kwargs) -> Follower:
vars = locals().copy()
data = {'follower':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('followers', data)
if 'followers' not in response:
raise StepikError(response)
return Follower(self._stepik, response['followers'][0])
def create(self,
step: str,
**kwargs) -> Attempt:
vars = locals().copy()
data = {'attempt':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('attempts', data)
if 'attempts' not in response:
raise StepikError(response)
return Attempt(self._stepik, response['attempts'][0])
def create(self,
goal_name: str,
value: str = None,
**kwargs) -> GoalMetric:
vars = locals().copy()
data = {'goal-metric':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('goal-metrics', data)
if 'goal-metrics' not in response:
raise StepikError(response)
return GoalMetric(self._stepik, response['goal-metrics'][0])
def create(self,
provider: str,
name: str,
**kwargs) -> SocialProfile:
vars = locals().copy()
data = {'social-profile':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('social-profiles', data)
if 'social-profiles' not in response:
raise StepikError(response)
return SocialProfile(self._stepik, response['social-profiles'][0])
def create(self,
session: str,
file: str,
**kwargs) -> ScoreFile:
vars = locals().copy()
data = {'score-file':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('score-files', data)
if 'score-files' not in response:
raise StepikError(response)
return ScoreFile(self._stepik, response['score-files'][0])
def create(self,
course: str,
amount: float = None,
**kwargs) -> CoursePayment:
vars = locals().copy()
data = {'course-payment':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('course-payments', data)
if 'course-payments' not in response:
raise StepikError(response)
return CoursePayment(self._stepik, response['course-payments'][0])
def create(self,
klass: str,
invitation_key: str,
**kwargs) -> Student:
vars = locals().copy()
data = {'student':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('students', data)
if 'students' not in response:
raise StepikError(response)
return Student(self._stepik, response['students'][0])
def create(self,
provider: str,
uid: str,
user: str = None,
**kwargs) -> SocialAccount:
vars = locals().copy()
data = {'social-account':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('social-accounts', data)
if 'social-accounts' not in response:
raise StepikError(response)
return SocialAccount(self._stepik, response['social-accounts'][0])
def update(self, obj: Rubric) -> Rubric:
required = ['instruction', 'text', 'cost', 'position']
vars = obj._data
data = {
'rubric': {
k: v
for k, v in vars.items()
if k != 'self' and v is not None and k in required
}
}
response = self._stepik._put(f'rubrics/{ obj.id }', data)
if 'rubrics' not in response:
raise StepikError(response)
return Rubric(self._stepik, response['rubrics'][0])
def update(self, obj: Attachment) -> Attachment:
required = ['file', 'course', 'lesson']
vars = obj._data
data = {
'attachment': {
k: v
for k, v in vars.items()
if k != 'self' and v is not None and k in required
}
}
response = self._stepik._put(f'attachments/{ obj.id }', data)
if 'attachments' not in response:
raise StepikError(response)
return Attachment(self._stepik, response['attachments'][0])
def create(self,
session: str,
target_session: str = None,
text: str = None,
rubric_scores: str = None,
**kwargs) -> Review:
vars = locals().copy()
data = {'review':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('reviews', data)
if 'reviews' not in response:
raise StepikError(response)
return Review(self._stepik, response['reviews'][0])
def update(self, obj: Class) -> Class:
required = ['course', 'title', 'description']
vars = obj._data
data = {
'class': {
k: v
for k, v in vars.items()
if k != 'self' and v is not None and k in required
}
}
response = self._stepik._put(f'classes/{ obj.id }', data)
if 'classes' not in response:
raise StepikError(response)
return Class(self._stepik, response['classes'][0])
def update(self, obj: CourseReminder) -> CourseReminder:
required = ['course', 'is_active']
vars = obj._data
data = {
'course-reminder': {
k: v
for k, v in vars.items()
if k != 'self' and v is not None and k in required
}
}
response = self._stepik._put(f'course-reminders/{ obj.id }', data)
if 'course-reminders' not in response:
raise StepikError(response)
return CourseReminder(self._stepik, response['course-reminders'][0])
def update(self, obj: StorageRecord) -> StorageRecord:
required = ['kind', 'data']
vars = obj._data
data = {
'storage-record': {
k: v
for k, v in vars.items()
if k != 'self' and v is not None and k in required
}
}
response = self._stepik._put(f'storage-records/{ obj.id }', data)
if 'storage-records' not in response:
raise StepikError(response)
return StorageRecord(self._stepik, response['storage-records'][0])
def update(self, obj: CourseReview) -> CourseReview:
required = ['course', 'score', 'text']
vars = obj._data
data = {
'course-review': {
k: v
for k, v in vars.items()
if k != 'self' and v is not None and k in required
}
}
response = self._stepik._put(f'course-reviews/{ obj.id }', data)
if 'course-reviews' not in response:
raise StepikError(response)
return CourseReview(self._stepik, response['course-reviews'][0])
def create(self, section: str, **kwargs) -> ExamSession:
vars = locals().copy()
data = {
'exam-session': {
k: v
for k, v in {
**vars,
**kwargs
}.items() if k != 'self' and v is not None
}
}
response = self._stepik._post('exam-sessions', data)
if 'exam-sessions' not in response:
raise StepikError(response)
return ExamSession(self._stepik, response['exam-sessions'][0])
def create(self,
type: str,
course: str = None,
lesson: str = None,
step: str = None,
klass: str = None,
**kwargs) -> LongTask:
vars = locals().copy()
data = {'long-task':
{k: v for k, v in {**vars, **kwargs}.items()
if k != 'self' and v is not None}}
response = self._stepik._post('long-tasks', data)
if 'long-tasks' not in response:
raise StepikError(response)
return LongTask(self._stepik, response['long-tasks'][0])
