mdxcanvas 0.0.0__tar.gz

mdxcanvas-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Bean Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mdxcanvas-0.0.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: mdxcanvas
+Version: 0.0.0
+Summary: A Canvas LMS API wrapper for maintaining content in markdown
+License: MIT
+Author: Gordon Bean
+Author-email: gbean@cs.byu.edu
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: CanvasAPI (>=3.2.0,<4.0.0)
+Requires-Dist: Jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: Markdown (>=3.1.1,<4.0.0)
+Requires-Dist: MarkupSafe (>=2.0.1,<3.0.0)
+Requires-Dist: Pygments (>=2.17.2,<3.0.0)
+Requires-Dist: beautifulsoup4 (>=4.13.4,<5.0.0)
+Requires-Dist: cssutils (>=2.11.1,<3.0.0)
+Requires-Dist: markdowndata (>=0.1.0,<0.2.0)
+Requires-Dist: pymdown-extensions (>=10.16.1,<11.0.0)
+Requires-Dist: pytest (>=8.4.0,<9.0.0)
+Requires-Dist: pytz (>=2025.2,<2026.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: strictyaml (>=1.7.3,<2.0.0)

mdxcanvas-0.0.0/mdxcanvas/VERSION

@@ -0,0 +1 @@
+0.6.12

mdxcanvas-0.0.0/mdxcanvas/__init__.py

@@ -0,0 +1,3 @@
+from pathlib import Path
+
+__version__ = (Path(__file__).resolve().parent/"VERSION").read_text().strip()

mdxcanvas-0.0.0/mdxcanvas/deploy/algorithms.py

@@ -0,0 +1,143 @@
+from collections import deque
+
+from ..our_logging import get_logger
+
+logger = get_logger()
+
+
+def tarjan_scc(graph: dict[tuple[str, str], list[tuple[str, str]]]) -> list[list[tuple[str, str]]]:
+    """Find strongly connected components (cycles) using Tarjan's algorithm."""
+    index_counter = [0]
+    stack = []
+    lowlink = {}
+    index = {}
+    on_stack = set()
+    sccs = []
+
+    def strongconnect(node):
+        index[node] = index_counter[0]
+        lowlink[node] = index_counter[0]
+        index_counter[0] += 1
+        stack.append(node)
+        on_stack.add(node)
+
+        for successor in graph.get(node, []):
+            if successor not in index:
+                strongconnect(successor)
+                lowlink[node] = min(lowlink[node], lowlink[successor])
+            elif successor in on_stack:
+                lowlink[node] = min(lowlink[node], index[successor])
+
+        if lowlink[node] == index[node]:
+            scc = []
+            while True:
+                w = stack.pop()
+                on_stack.remove(w)
+                scc.append(w)
+                if w == node:
+                    break
+            sccs.append(scc)
+
+    for node in graph.keys():
+        if node not in index:
+            strongconnect(node)
+
+    return sccs
+
+
+def kahns_topological_sort(graph: dict[tuple[str, str], list[tuple[str, str]]]) -> list[tuple[str, str]]:
+    """Topological sort using Kahn's algorithm (dependencies first)."""
+    in_degree = {node: 0 for node in graph}
+    for deps in graph.values():
+        for dep in deps:
+            if dep in graph:
+                in_degree[dep] += 1
+
+    queue = deque([node for node, degree in in_degree.items() if degree == 0])
+    result = []
+
+    while queue:
+        node = queue.popleft()
+        result.append(node)
+
+        for dep in graph.get(node, []):
+            if dep in in_degree:
+                in_degree[dep] -= 1
+                if in_degree[dep] == 0:
+                    queue.append(dep)
+
+    if len(result) != len(graph):
+        raise ValueError("Internal error: acyclic graph still has cycles")
+
+    return result[::-1]
+
+
+def linearize_dependencies(
+        graph: dict[tuple[str, str], list[tuple[str, str]]],
+        shell_deployers: list[str]
+) -> list[tuple[tuple[str, str], bool]]:
+    """
+    Linearize dependencies with cycle breaking via shell deployments.
+    Example: A→B→C→A returns [((page, C),True), ((page, B), False), ((page, A), False), ((page, C), False)]
+
+    Note: Only certain resource types support shell deployments (assignment, page, quiz).
+    Other types (syllabus, file, etc.) have deterministic IDs and don't need shell deployments.
+    """
+
+    sccs = tarjan_scc(graph)
+
+    cycle_breakers = set()
+    scc_map = {}
+
+    for scc in sccs:
+        if len(scc) > 1:
+            # All nodes in an SCC that are depended upon by other nodes in the SCC
+            # need to be cycle breakers (deployed as shells first)
+            for node in scc:
+                scc_map[node] = scc
+                # Check if any other node in the SCC depends on this node
+                # and that this node supports shell deployment
+                if node[0] in shell_deployers:
+                    for other_node in scc:
+                        if other_node != node and node in graph.get(other_node, []):
+                            cycle_breakers.add(node)
+                            break
+
+    for node, deps in graph.items():
+        # Self-loops only need cycle breaking if the type supports shell deployment
+        if node in deps and node[0] in shell_deployers:
+            cycle_breakers.add(node)
+
+    acyclic_graph = {}
+    for node, deps in graph.items():
+        if node in scc_map:
+            # Remove all edges within the same SCC to break cycles
+            acyclic_graph[node] = [d for d in deps if d not in scc_map[node]]
+        elif node in cycle_breakers:
+            # Self-loop case
+            acyclic_graph[node] = [d for d in deps if d != node]
+        else:
+            acyclic_graph[node] = deps
+
+    topo_order = kahns_topological_sort(acyclic_graph)
+
+    # Shell deployments for cycle breakers must happen FIRST (before everything else)
+    # so that other resources can reference them. Then the full deployment happens
+    # in the natural topological order.
+    result = [(node, True) for node in topo_order if node in cycle_breakers]
+    result.extend((node, False) for node in topo_order)
+
+    return result
+
+
+if __name__ == '__main__':
+    dependency_dict = {
+        'A': ['B'],
+        'B': ['C', 'D'],
+        'C': [],
+        'D': ['C']
+    }
+
+    # expect C, D, B, A
+    order = linearize_dependencies(dependency_dict)
+    print(order)

mdxcanvas-0.0.0/mdxcanvas/deploy/announcement.py

@@ -0,0 +1,25 @@
+from canvasapi.course import Course
+
+from ..resources import AnnouncementInfo
+
+
+def deploy_announcement(course: Course, announcement_info: dict) -> tuple[AnnouncementInfo, None]:
+    announcement_id = announcement_info["canvas_id"]
+
+    if announcement_id:
+        canvas_announcement = course.get_discussion_topic(announcement_id)
+        canvas_announcement.update(**announcement_info)
+
+    else:
+        canvas_announcement = course.create_discussion_topic(**announcement_info)
+
+    announcement_object_info: AnnouncementInfo = {
+        'id': canvas_announcement.id,
+        'title': canvas_announcement.title,
+        'uri': f'/courses/{course.id}/discussion_topics/{canvas_announcement.id}',
+
+        # Following fields have been observed to be missing in some cases
+        'url': canvas_announcement.html_url if hasattr(canvas_announcement, 'html_url') else None
+    }
+
+    return announcement_object_info, None

mdxcanvas-0.0.0/mdxcanvas/deploy/assignment.py

@@ -0,0 +1,38 @@
+from canvasapi.course import Course
+
+from .util import update_group_name_to_id
+from ..resources import AssignmentInfo
+
+
+def deploy_assignment(course: Course, assignment_info: dict) -> tuple[AssignmentInfo, None]:
+    assignment_id = assignment_info["canvas_id"]
+
+    update_group_name_to_id(course, assignment_info)
+
+    # TODO - update group_category (name) to group_category_id
+    #  Is this necessary to support?
+
+    if assignment_id:
+        canvas_assignment = course.get_assignment(assignment_id)
+        canvas_assignment.edit(assignment=assignment_info)
+    else:
+        canvas_assignment = course.create_assignment(assignment=assignment_info)
+
+    assignment_object_info: AssignmentInfo = {
+        'id': canvas_assignment.id,
+        'title': canvas_assignment.name,
+        'uri': f'/courses/{course.id}/assignments/{canvas_assignment.id}',
+
+        # Following fields have been observed to be missing in some cases
+        'url': canvas_assignment.html_url if hasattr(canvas_assignment, 'html_url') else None
+    }
+
+    return assignment_object_info, None
+
+
+def deploy_shell_assignment(course: Course, assignment_info: dict) -> tuple[AssignmentInfo, None]:
+    shell_assignment_info = assignment_info.copy()
+    shell_assignment_info[
+        'description'] = "<p>This is a shell assignment created to break a dependency cycle. The full content will be deployed later.</p>"
+
+    return deploy_assignment(course, shell_assignment_info)