looking decent

Dockerfile

@@ -16,4 +16,4 @@ RUN mkdir -p /app/__marimo__ && \
     chmod -R 755 /app
 USER user
 
-CMD ["marimo", "run", "app.py", "--include-code", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["marimo", "run", "app.py", "--token-password","${CICEROJOBAPPS_API_KEY}","--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,470 +1,524 @@
 import marimo
 
-__generated_with = "0.9.2"
+__generated_with = "0.17.0"
 app = marimo.App()
 
 
 @app.cell
-def __():
+def _():
     import marimo as mo
 
-    mo.md("# Welcome to marimo! 🌊🍃")
+    mo.md('# <center>Cicero Jobs</center>')
     return (mo,)
 
 
 @app.cell
-def __(mo):
-    slider = mo.ui.slider(1, 22)
-    return (slider,)
+def _():
+    import glob
+    import os
+    from pydantic_ai import Agent, BinaryContent, DocumentUrl
+    from pydantic import BaseModel, Field
+    return Agent, BaseModel, BinaryContent, DocumentUrl, Field
+
+
+@app.function
+def create_job_application_prompt(resume: str, cover_letter: str, further_instructions: str | None = None) -> str:
+    fi = further_instructions or ''
+    return f"""
+<JobApplicationGenerationRequest>
+    <Persona>
+        You are an expert human resources professional and a resume and cover letter drafting specialist, with a deep focus on the in-house legal market. Your task is to generate a complete set of application materials based on the provided resume and job description.
+    </Persona>
+
+    <InputData>
+        <Resume>
+            {resume}
+        </Resume>
+        <JobOpening>
+            {cover_letter}
+        </JobOpening>
+        <FurtherInstructions>
+            {fi}
+        </FurtherInstructions>
+    </InputData>
+
+    <OutputSpecification>
+        Your final output must be a structured object with four distinct fields: `resume`, `cover_letter`, `letter_to_recruiter`, and `tips`. Follow the detailed instructions for each field below.
+    </OutputSpecification>
+
+    <CoreProcessingInstructions>
+        1.  **Analyze and Synthesize:** Meticulously analyze the provided `<Resume>` and the `<JobOpening>`. Your primary goal is to tailor the candidate's materials to perfectly align with the requirements and keywords of the job description.
+        2.  **Adhere to Writing Guidelines:** In all generated content, strictly apply the principles outlined in the `<WritingGuidelines>` section. This includes using appropriate tense, structuring bullet points effectively (PAR, STAR), incorporating action verbs, and maintaining a professional brand.
+        3.  **Fact-Based Generation:** Do not invent skills or experiences. All generated content must be directly supported by the information in the provided `<Resume>`. If a skill is treated superficially, you may suggest enhancements or ask clarifying questions in the `tips` section.
+        4.  **Keyword Integration:** Identify core competencies, role-specific skills, and industry-relevant keywords from the job posting. Systematically integrate these exact keywords (avoiding synonyms unless instructed) into all generated documents to optimize for Applicant Tracking Systems (ATS) and recruiter review.
+    </CoreProcessingInstructions>
+
+    <GenerationTasks>
+        <Task id="resume">
+            <Description>
+                Generate a complete, richly formatted Markdown resume, fully tailored for the specific job opening.
+            </Description>
+            <Instructions>
+                -   Return the **entire, updated resume**, not just the changed parts. The final output should be a single, complete Markdown document.
+                -   **Summary Section:** Draft a concise (30-90 words) and impactful summary. This is your elevator pitch.
+                    -   If not extremely excessive, match the professional title based on the job opening:
+                        -   DO: "Commercial Counsel" -> "Commercial and Corporate Attorney"
+                        -   DO: "Corporate Counsel" -> "Corporate Attorney"
+                        -   DO NOT: Attorney --> General Counsel
+                        -   DO NOT: intern --> manager
+                    -   Incorporate the candidate's years of experience, but adjust as follows:
+                        -   If the required experience is incompatible with the candidate's seniority, use phrases like "seasoned" or "experienced" instead of a number.
+                        -   For roles requiring 3-4 years, do not overemphasize seniority.
+                        -   For roles requiring 5+ years, explicitly state the number of years of experience.
+                -   **Skills Section:**
+                    -   Identify the most important keywords from the job posting. Prioritize keywords that appear multiple times, are standard for the role, or showcase unique relevant skills.
+                    -   Include industry-standard skills that may not be in the job description but are valuable for the role.
+                    -   Format the skills as a comma-separated list: `Skilla, skillb, skillc`.
+                -   **Experience Section:**
+                    -   Adapt the language in the resume to use the exact keywords from the job posting, replacing any synonyms.
+                    -   Ensure bullet points are unique, highlight quantifiable achievements, and provide context (e.g., team size, project value).
+                    -   Structure bullet points using the C.A.R. technique, front-loading the result where possible.
+                -   **Formatting:** Ensure the length and structure of the updated resume are similar to the original provided document.
+                    -    MANDATORY: Your answer must be perfect Markdown syntax (will be rendered by mistune)
+                    -    MANDATORY: headers such as the candidate name, section titles (e.g., Summary, Experience, Skills), and contact information must be wrapped in <p style=\"text-align:center;\"> ... </p> tags.
+                    -    MANDATORY: Must end wishing the candidate good luck and explaining finding a job is a numbers game. Motivate them!
+
+            </Instructions>
+        </Task>
+
+        <Task id="cover_letter">
+            <Description>
+                Generate a compelling, personalized, and richly formatted Markdown cover letter.
+            </Description>
+            <Instructions>
+                -   The cover letter must be under 400 words and structured in 3-4 paragraphs.
+                -   Address it to the hiring manager. If a name is available in the job posting, use it.
+                -   The content should be approximately 60% based on the job opening and 40% on the resume.
+                -   Explicitly mention experiences from the resume that are directly relevant to the role. Highlight leadership experience (e.g., managing paralegals).
+                -   When mentioning past employers, do not append suffixes like "LLP" or "Inc."
+                -   Perform a quick web search for information about the company to add a sentence or two showing genuine interest and research.
+                -   Ensure all statements are directly supported by the resume.
+            </Instructions>
+        </Task>
+
+        <Task id="letter_to_recruiter">
+            <Description>
+                Generate a concise, professional, and richly formatted Markdown message for LinkedIn or email outreach.
+            </Description>
+            <Instructions>
+                -   The message should be 5-7 sentences long.
+                -   Draft a clear and professional subject line (e.g., "Regarding the Corporate Counsel Position").
+                -   Address the hiring manager by name if available.
+                -   Briefly introduce the candidate, state the position being applied for, and highlight 1-2 key qualifications that make them a perfect fit.
+                -   End with a clear call to action, such as expressing eagerness to discuss the role further.
+                -   Return the message without any additional markup or bullet points.
+            </Instructions>
+        </Task>
+
+        <Task id="tips">
+            <Description>
+                Generate 5-7 actionable tips specific to this application, formatted as a bulleted list in Markdown.
+            </Description>
+            <Instructions>
+                -   Analyze the resume against the job description to identify strengths and potential gaps.
+                -   Provide concrete advice. For example:
+                    -   "During the interview, be prepared to elaborate on your experience with [Specific Skill from Job Posting] by using the project at [Previous Company] as a prime example."
+                    -   "The job emphasizes [Company Value or Mission]. Consider mentioning how your work in [Relevant Experience] aligns with this value."
+                    -   "Your resume mentions [Superficial Skill]. I recommend adding a bullet point with a quantifiable result to strengthen this, such as..."
+                    -   "Research the company's recent acquisition of [Company X] and be prepared to discuss its potential legal integration challenges."
+                -   The tips should be formatted as a simple Markdown bulleted list.
+            </Instructions>
+        </Task>
+    </GenerationTasks>
+
+    <WritingGuidelines>
+        <Section name="Summary">
+            Not always required: If you've included a cover letter, your summary might be redundant. Valuable for quickly grabbing attention and highlighting your most relevant qualifications, as well as filling the gap if you're not submitting a cover letter.
+            Focus on:
+            - Who you are and what you do: Clearly state your professional identity and area of expertise.
+            - Your achievements: Highlight measurable results, awards, problems solved, and times you exceeded expectations.
+        </Section>
+        <Section name="Work Experience">
+            This is the section of your resume in which you detail your career history.
+            - Use bullets for skim value.
+            - Use simple present tense for current roles (e.g., manages) and simple past tense for past roles (e.g., managed).
+            - Provide context for each position: company type, industry, size, and your role's impact on the bottom line.
+            - Focus on your main functions and their relevance to the target job.
+            - Emphasize quantifiable impact: landing clients, saving costs, automating tasks, hitting targets.
+        </Section>
+        <Section name="Bullet Point Structuring">
+            - PAR (Problem-Action-Result): Ideal for showing accomplishments and impact. Example: "Reduced customer support response time by 20% by implementing a new ticketing system."
+            - STAR (Situation-Task-Action-Result): Provides a more detailed narrative for demonstrating specific competencies. Example: "Managed inventory levels in a fast-paced retail setting; achieved a 15% reduction in inventory costs."
+            - Result-First: Leads with the outcome to grab attention. Example: "Increased sales revenue by 18% through targeted marketing campaigns."
+            - Action Verb + Skill + Result: Concise and effective for technical roles. Example: "Developed a user-friendly website using HTML, CSS, and JavaScript, resulting in a 30% increase in website traffic."
+            - Prioritize your most relevant bullet points for each specific job application.
+        </Section>
+        <Section name="Technical Skills">
+            - Showcase specific knowledge in tools, software, and processes.
+            - Hard Skills: Programming languages (Java, Python), software (Adobe Creative Suite), cloud platforms (AWS, Azure).
+            - Soft Technical Skills: Troubleshooting, data analysis, project management, technical writing.
+            - Use the PAR method to demonstrate technical skills in context. Example: "Problem: Website traffic was declining. Action: Implemented optimization techniques using HTML, CSS, JavaScript. Result: Increased traffic by 25%."
+        </Section>
+        <Section name="Soft Skills">
+            - Avoid overused terms like "Problem-solving" or "Driven".
+            - Instead of listing soft skills, demonstrate them through your achievement-oriented bullet points. Example: Instead of "excellent communication skills," write "Presented quarterly performance updates to internal stakeholders."
+        </Section>
+        <Section name="Professional Brand and Summary Details">
+            - Your brand is the unique combination of your skills, experience, and personality.
+            - Your summary is your sales pitch, answering "Who are you and why should I hire you?"
+            - It should be concise (60-120 words), factual, data-driven, and placed at the top of your resume.
+            - Use a combination of present tense ("who you are") and past tense ("what you've achieved"). Example: "Project manager (PMP) with 11 years of experience... Successfully completed three plant projects in 2022 valued at $15MM."
+        </Section>
+        <Section name="Experience Section Details">
+            - List your most relevant responsibilities and bullets first.
+            - Avoid generic statements; provide specific context and quantifiable metrics.
+            - Use the C.A.R (Challenge, Action, Result) technique. Where possible, front-load the bullet with the result.
+            - Use a short introductory paragraph for each role to provide a high-level overview.
+            - Utilize strong action verbs (e.g., Achieved, Coordinated, Implemented, Streamlined, Managed, Maximized).
+        </Section>
+    </WritingGuidelines>
+</JobApplicationGenerationRequest>
+"""
 
 
-@app.cell
-def __(mo, slider):
-    mo.md(
-        f"""
-        marimo is a **reactive** Python notebook.
-
-        This means that unlike traditional notebooks, marimo notebooks **run
-        automatically** when you modify them or
-        interact with UI elements, like this slider: {slider}.
+@app.cell(hide_code=True)
+def _(BaseModel, Field):
+    class ApplicationMaterials(BaseModel):
+        """Structured output for resume and cover letter generation."""
 
-        {"##" + "🍃" * slider.value}
-        """
-    )
-    return
+        resume: str = Field(..., description='Markdown Richly Formatted resume highlighting relevant experience for the job')
+        cover_letter: str = Field(..., description='Markdown Richly Formatted and Compelling, personalized cover letter (3-4 paragraphs)')
+        letter_to_recruiter: str = Field(..., description='Markdown Richly Formatted and Concise professional message for LinkedIn/email outreach (5-7 sentences)')
+        tips: str = Field(..., description='Markdown Richly Formatted and 5-7 actionable tips specific to this application, formatted as bullet points')
+    return (ApplicationMaterials,)
 
 
 @app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: disabling automatic execution": mo.md(
-                rf"""
-            marimo lets you disable automatic execution: just go into the
-            notebook settings and set
-
-            "Runtime > On Cell Change" to "lazy".
-
-            When the runtime is lazy, after running a cell, marimo marks its
-            descendants as stale instead of automatically running them. The
-            lazy runtime puts you in control over when cells are run, while
-            still giving guarantees about the notebook state.
-            """
-            )
-        }
-    )
-    return
+def _(mo):
+    resume_button = mo.ui.file(kind='area', filetypes=['.pdf', '.txt', '.doc', '.docx'], label='Or drop your pdf/doc/docx/txt file résumé here!')
 
+    job_posting_area = mo.ui.text_area(placeholder='📋 Drop your job posting here!', full_width=True, rows=27)
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        Tip: This is a tutorial notebook. You can create your own notebooks
-        by entering `marimo edit` at the command line.
-        """
-    ).callout()
-    return
+    resume_area = mo.ui.text_area(placeholder='📄 Provide the full content of your résumé. Uploading file in pdf/docx/doc/txt is preferred.', full_width=True, rows=20)
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 1. Reactive execution
-
-        A marimo notebook is made up of small blocks of Python code called
-        cells.
-
-        marimo reads your cells and models the dependencies among them: whenever
-        a cell that defines a global variable  is run, marimo
-        **automatically runs** all cells that reference that variable.
-
-        Reactivity keeps your program state and outputs in sync with your code,
-        making for a dynamic programming environment that prevents bugs before they
-        happen.
-        """
-    )
-    return
+    job_url = mo.ui.text(placeholder='https://example.com/job-posting', label='Alternatively, provide the URL of the job posting', full_width=True)
 
+    continue_button = mo.ui.button(value=None, kind='success', tooltip='Click submit to continue.', label='Submit All (or press Ctrl/Cmd Enter)', keyboard_shortcut='Ctrl+Enter', full_width=True)
 
-@app.cell(hide_code=True)
-def __(changed, mo):
-    (
-        mo.md(
-            f"""
-            **✨ Nice!** The value of `changed` is now {changed}.
-
-            When you updated the value of the variable `changed`, marimo
-            **reacted** by running this cell automatically, because this cell
-            references the global variable `changed`.
-
-            Reactivity ensures that your notebook state is always
-            consistent, which is crucial for doing good science; it's also what
-            enables marimo notebooks to double as tools and  apps.
-            """
-        )
-        if changed
-        else mo.md(
-            """
-            **🌊 See it in action.** In the next cell, change the value of the
-            variable  `changed` to `True`, then click the run button.
-            """
-        )
+    continue_render = mo.vstack(
+        [
+            mo.md("# Let's start with your materials!"),
+            mo.vstack(
+                [
+                    mo.md('## '),
+                    mo.hstack(
+                        [mo.vstack([mo.md('### Resume:'), resume_button, resume_area], align='center'), mo.vstack([mo.md('### Job Posting:'), job_posting_area, job_url], align='center')], align='center'
+                    ),
+                    continue_button,
+                ],
+                align='start',
+            ),
+        ],
+        align='center',
     )
-    return
+    return continue_render, job_posting_area, job_url, resume_button
 
 
 @app.cell
-def __():
-    changed = False
-    return (changed,)
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: execution order": (
-                """
-                The order of cells on the page has no bearing on
-                the order in which cells are executed: marimo knows that a cell
-                reading a variable must run after the cell that  defines it. This
-                frees you to organize your code in the way that makes the most
-                sense for you.
-                """
-            )
-        }
-    )
+def _(continue_render):
+    continue_render
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        **Global names must be unique.** To enable reactivity, marimo imposes a
-        constraint on how names appear in cells: no two cells may define the same
-        variable.
-        """
-    )
-    return
+@app.cell
+def _(job_posting_area, job_url, mo):
+    if job_posting_area.value != '':
+        buceta = 'Vamo'
+        job_posting = job_posting_area.value
+    elif job_posting_area.value == '' and job_url.value == '':
+        buceta = None
+        job_posting = None
+    elif job_posting_area.value == '' and job_url.value != '':
+        buceta = 'Vamo'
+        import httpx
+
+        url = f'https://r.jina.ai/{job_url.value}'
+        headers = {f'Authorization': 'Bearer '}
+        response = httpx.get(url, headers=headers)
+        job_posting = response.text
+
+    mo.stop(buceta is None, mo.callout(mo.md('⚠️ **Please provide your materials before continuing!**'), kind='danger'))
+    return (job_posting,)
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: encapsulation": (
-                """
-                By encapsulating logic in functions, classes, or Python modules,
-                you can minimize the number of global variables in your notebook.
-                """
-            )
-        }
-    )
-    return
+@app.cell
+def _(resume_button):
+    # Helper function to determine media type from filename
+    import io
+
+
+    try:
+        if resume_button.contents() is not '':
+            print(f'we got button contents: {resume_button.contents()}')
+            resume_contents = resume_button.contents()
+            try:
+                from markitdown import MarkItDown
+
+                md = MarkItDown(enable_plugins=True)
+                forcing_bytes = io.BytesIO(resume_contents)
+                docx_converted = md.convert(forcing_bytes)
+                resume_complete = str(docx_converted.text_content)
+                print('Converted to markdown')
+            except Exception as e:
+                print(f'an exception occurrred {e}')
+                if isinstance(resume_contents, (bytes, bytearray)):
+                    resume_complete = io.BytesIO(resume_contents)
+                else:
+                    resume_complete = resume_contents
+        else:
+            resume_contents = ''
+    except Exception:
+        resume_contents = ''
+    return io, resume_complete
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: private variables": (
-                """
-                Variables prefixed with an underscore are "private" to a cell, so
-                they can be defined by multiple cells.
-                """
-            )
-        }
-    )
-    return
+@app.cell
+def _(job_posting, resume_complete):
+    final_prompt = create_job_application_prompt(resume_complete, job_posting)
+    return (final_prompt,)
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 2. UI elements
-
-        Cells can output interactive UI elements. Interacting with a UI
-        element **automatically triggers notebook execution**: when
-        you interact with a UI element, its value is sent back to Python, and
-        every cell that references that element is re-run.
-
-        marimo provides a library of UI elements to choose from under
-        `marimo.ui`.
-        """
-    )
+@app.cell
+def _(BinaryContent, DocumentUrl, job_posting_area, job_url):
+    job_posting_complete = ''
+    job_posting_mime = 'text/plain'
+    is_url = False
+
+    job_area_value = job_posting_area.value if hasattr(job_posting_area, 'value') else None
+    job_url_value = job_url.value if hasattr(job_url, 'value') else None
+
+    if job_area_value:
+        job_posting_complete = job_area_value
+        job_posting_mime = 'text/plain'
+        is_url = False
+    elif job_url_value:
+        job_posting_complete = job_url_value.strip()
+        # Basic URL detection
+        if job_posting_complete.lower().startswith(('http://', 'https://')):
+            is_url = True
+            job_posting_mime = None
+        else:
+            # If user provided something in the URL field that's not an HTTP URL, treat it as plain text
+            is_url = False
+            job_posting_mime = 'text/plain'
+    else:
+        job_posting_complete = ''
+        job_posting_mime = 'text/plain'
+        is_url = False
+
+    # Build inputs for the agent
+    if is_url:
+        job_posting_input = DocumentUrl(job_posting_complete)
+    else:
+        job_posting_input = BinaryContent(data=job_posting_complete, media_type=job_posting_mime or 'text/plain')
     return
 
 
 @app.cell
-def __(mo):
-    mo.md("""**🌊 Some UI elements.** Try interacting with the below elements.""")
+def _(resume_complete):
+    print(resume_complete)
     return
 
 
 @app.cell
-def __(mo):
-    icon = mo.ui.dropdown(["🍃", "🌊", "✨"], value="🍃")
-    return (icon,)
+def _(Agent, ApplicationMaterials, final_prompt):
+    import asyncio
+    import uvloop
+    import nest_asyncio
 
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    nest_asyncio.apply()
 
-@app.cell
-def __(icon, mo):
-    repetitions = mo.ui.slider(1, 16, label=f"number of {icon.value}: ")
-    return (repetitions,)
+    career_agent = Agent('gemini-2.5-flash', output_type=ApplicationMaterials)
+    if final_prompt is not None:
+        result = asyncio.run(career_agent.run(final_prompt))
+    return (result,)
 
 
 @app.cell
-def __(icon, repetitions):
-    icon, repetitions
-    return
+def _(result):
+    import json
+
+    _output = getattr(result, 'output', None)
+
+    _parsed = None
+    if isinstance(_output, str):
+        try:
+            _parsed = json.loads(_output)
+        except Exception:
+            _parsed = None
+    elif isinstance(_output, dict):
+        _parsed = _output
+    else:
+        try:
+            _parsed = {}
+            for k in dir(_output):
+                if k.startswith('_') or k.startswith('model_'):
+                    continue
+                try:
+                    v = getattr(_output, k)
+                except Exception:
+                    continue
+                if callable(v):
+                    continue
+                _parsed[k] = v
+        except Exception:
+            _parsed = None
+
+
+    def _get_field(*keys, default=None):
+        if _parsed and isinstance(_parsed, dict):
+            for k in keys:
+                if k in _parsed:
+                    return _parsed[k]
+        for k in keys:
+            if hasattr(_output, k):
+                try:
+                    return getattr(_output, k)
+                except Exception:
+                    continue
+        return default
+
+
+    processed_data = {
+        'resume': _get_field('resume', 'resume_text', default=None),
+        'cover_letter': _get_field('cover_letter', 'coverletter', 'cover_letter_text', default=None),
+        'recruiter_message': _get_field('letter_to_recruiter', 'recruiter_message', 'message_to_recruiter', default=None),
+        'tips': _get_field('tips', 'advice', 'suggestions', default=None),
+    }
+    return (processed_data,)
 
 
 @app.cell
-def __(icon, mo, repetitions):
-    mo.md("# " + icon.value * repetitions.value)
+def _():
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 3. marimo is just Python
-
-        marimo cells parse Python (and only Python), and marimo notebooks are
-        stored as pure Python files — outputs are _not_ included. There's no
-        magical syntax.
-
-        The Python files generated by marimo are:
-
-        - easily versioned with git, yielding minimal diffs
-        - legible for both humans and machines
-        - formattable using your tool of choice,
-        - usable as Python  scripts, with UI  elements taking their default
-        values, and
-        - importable by other modules (more on that in the future).
-        """
-    )
-    return
+@app.cell
+def _(mo, processed_data):
+    preview_section = mo.vstack([
+        mo.md('## Preview Your Documents'),
+        mo.md('---'),
+        mo.md('### Here is your résumé, how it looks like?'),
+        mo.md('---'),
+        mo.md(processed_data.get('resume')),
+        mo.md('---'),
+        mo.md('---'),
+        mo.md('### 💼 Here is your Cover Letter'),
+        mo.md('---'),
+        mo.md(processed_data.get('cover_letter')),
+        mo.md('---'),
+        mo.md('---'),
+        mo.md('### 📧 Here is your message to reach out to the recruiter'),
+        mo.md('---'),
+        mo.md(processed_data.get('recruiter_message')),
+        mo.md('---'),
+        mo.md('---'),
+        mo.md('### 💡 Here are some additional tips'),
+        mo.md('---'),
+        mo.md(processed_data.get('tips')),
+        mo.md('---'),
+        mo.md('---'),
+    ])
+    return (preview_section,)
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 4. Running notebooks as apps
-
-        marimo notebooks can double as apps. Click the app window icon in the
-        bottom-right to see this notebook in "app view."
-
-        Serve a notebook as an app with `marimo run` at the command-line.
-        Of course, you can use marimo just to level-up your
-        notebooking, without ever making apps.
-        """
-    )
+@app.cell
+def _(preview_section):
+    preview_section
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 5. The `marimo` command-line tool
-
-        **Creating and editing notebooks.** Use
-
-        ```
-        marimo edit
-        ```
-
-        in a terminal to start the marimo notebook server. From here
-        you can create a new notebook or edit existing ones.
-
-
-        **Running as apps.** Use
-
-        ```
-        marimo run notebook.py
-        ```
-
-        to start a webserver that serves your notebook as an app in read-only mode,
-        with code cells hidden.
-
-        **Convert a Jupyter notebook.** Convert a Jupyter notebook to a marimo
-        notebook using `marimo convert`:
-
-        ```
-        marimo convert your_notebook.ipynb > your_app.py
-        ```
+@app.cell
+def _(io):
+    from html4docx import HtmlToDocx
+    import mistune
+    from mistune.plugins.abbr import abbr
+    from mistune.plugins.def_list import def_list
+    from mistune.plugins.footnotes import footnotes
+    from mistune.plugins.formatting import insert, mark, strikethrough, subscript, superscript
+    from mistune.plugins.table import table
+    from mistune.plugins.task_lists import task_lists
+
+    # Define mistune plugins to use
+    MISTUNE_PLUGINS = [strikethrough, footnotes, table, task_lists, insert, def_list, abbr, mark, subscript, superscript]
+
+
+    def _build_markdown_parser(hard_wrap: bool = True):
+        """Create a Mistune Markdown parser with desired plugins and hard-wrap behavior."""
+        renderer = mistune.HTMLRenderer()
+        inline = mistune.InlineParser(hard_wrap=hard_wrap)
+        return mistune.Markdown(renderer=renderer, inline=inline, plugins=MISTUNE_PLUGINS)
+
+
+    def markdown_to_docx_bytes(markdown_text: str) -> bytes | str:
+        """Asynchronously converts markdown text to DOCX bytes with legal formatting."""
+        try:
+            markdown_parser = _build_markdown_parser(hard_wrap=True)
+            html_content = markdown_parser(markdown_text)
+            try:
+                parser = HtmlToDocx()
+
+                docx_document = parser.parse_html_string(html_content)
+                # Save to memory
+                docx_bytes = io.BytesIO()
+                docx_document.save(docx_bytes)
+                docx_bytes.seek(0)
+
+                print('Successfully converted markdown to DOCX using html4docx with mistune')
+                return docx_bytes.getvalue()
+
+            except Exception as e:
+                print("Couldn't do it")
+                return markdown_text
+
+        except Exception as e:
+            print("Couldn't do it")
+            return markdown_text
+    return (markdown_to_docx_bytes,)
 
-        **Tutorials.** marimo comes packaged with tutorials:
 
-        - `dataflow`: more on marimo's automatic execution
-        - `ui`: how to use UI elements
-        - `markdown`: how to write markdown, with interpolated values and
-           LaTeX
-        - `plots`: how plotting works in marimo
-        - `sql`: how to use SQL
-        - `layout`: layout elements in marimo
-        - `fileformat`: how marimo's file format works
-        - `markdown-format`: for using `.md` files in marimo
-        - `for-jupyter-users`: if you are coming from Jupyter
+@app.cell
+def _(markdown_to_docx_bytes, mo, processed_data):
+    final_resume = markdown_to_docx_bytes(processed_data.get('resume'))
+    final_cover_letter = markdown_to_docx_bytes(processed_data.get('cover_letter'))
+    final_recruiter_message = markdown_to_docx_bytes(processed_data.get('recruiter_message'))
 
-        Start a tutorial with `marimo tutorial`; for example,
 
-        ```
-        marimo tutorial dataflow
-        ```
+    resume_download = mo.download(data=final_resume, filename='resume.docx', label='Résumé')
 
-        In addition to tutorials, we have examples in our
-        [our GitHub repo](https://www.github.com/marimo-team/marimo/tree/main/examples).
-        """
-    )
-    return
+    cover_letter_download = mo.download(data=final_cover_letter, filename='cover_letter.docx', label='Cover Letter')
 
+    message_download = mo.download(data=final_recruiter_message, filename='recruiter_message.docx', label='Recruiter Message')
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 6. The marimo editor
+    downloads_section = mo.vstack([
+        mo.md('## 🎉 Your Documents Are Ready!'),
+        mo.md('Click the buttons below to download your documents:'),
+        mo.hstack([resume_download, cover_letter_download, message_download], justify='center', gap=2),
+        mo.md('---'),
+        mo.callout(mo.md('✅ **Success!** Your documents have been generated and are ready to download.'), kind='success'),
+    ])
 
-        Here are some tips to help you get started with the marimo editor.
-        """
-    )
+    downloads_section
     return
 
 
 @app.cell
-def __(mo, tips):
-    mo.accordion(tips)
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md("""## Finally, a fun fact""")
+def _(mo):
+    mo.md('# <center>Time to do another application! You got this!')
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        The name "marimo" is a reference to a type of algae that, under
-        the right conditions, clumps together to form a small sphere
-        called a "marimo moss ball". Made of just strands of algae, these
-        beloved assemblages are greater than the sum of their parts.
-        """
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __():
-    tips = {
-        "Saving": (
-            """
-            **Saving**
-
-            - _Name_ your app using the box at the top of the screen, or
-              with `Ctrl/Cmd+s`. You can also create a named app at the
-              command line, e.g., `marimo edit app_name.py`.
-
-            - _Save_ by clicking the save icon on the bottom right, or by
-              inputting `Ctrl/Cmd+s`. By default marimo is configured
-              to autosave.
-            """
-        ),
-        "Running": (
-            """
-            1. _Run a cell_ by clicking the play ( ▷ ) button on the top
-            right of a cell, or by inputting `Ctrl/Cmd+Enter`.
-
-            2. _Run a stale cell_  by clicking the yellow run button on the
-            right of the cell, or by inputting `Ctrl/Cmd+Enter`. A cell is
-            stale when its code has been modified but not run.
-
-            3. _Run all stale cells_ by clicking the play ( ▷ ) button on
-            the bottom right of the screen, or input `Ctrl/Cmd+Shift+r`.
-            """
-        ),
-        "Console Output": (
-            """
-            Console output (e.g., `print()` statements) is shown below a
-            cell.
-            """
-        ),
-        "Creating, Moving, and Deleting Cells": (
-            """
-            1. _Create_ a new cell above or below a given one by clicking
-                the plus button to the left of the cell, which appears on
-                mouse hover.
-
-            2. _Move_ a cell up or down by dragging on the handle to the 
-                right of the cell, which appears on mouse hover.
-
-            3. _Delete_ a cell by clicking the trash bin icon. Bring it
-                back by clicking the undo button on the bottom right of the
-                screen, or with `Ctrl/Cmd+Shift+z`.
-            """
-        ),
-        "Disabling Automatic Execution": (
-            """
-            Via the notebook settings (gear icon) or footer panel, you
-            can disable automatic execution. This is helpful when
-            working with expensive notebooks or notebooks that have
-            side-effects like database transactions.
-            """
-        ),
-        "Disabling Cells": (
-            """
-            You can disable a cell via the cell context menu.
-            marimo will never run a disabled cell or any cells that depend on it.
-            This can help prevent accidental execution of expensive computations
-            when editing a notebook.
-            """
-        ),
-        "Code Folding": (
-            """
-            You can collapse or fold the code in a cell by clicking the arrow
-            icons in the line number column to the left, or by using keyboard
-            shortcuts.
-
-            Use the command palette (`Ctrl/Cmd+k`) or a keyboard shortcut to
-            quickly fold or unfold all cells.
-            """
-        ),
-        "Code Formatting": (
-            """
-            If you have [ruff](https://github.com/astral-sh/ruff) installed,
-            you can format a cell with the keyboard shortcut `Ctrl/Cmd+b`.
-            """
-        ),
-        "Command Palette": (
-            """
-            Use `Ctrl/Cmd+k` to open the command palette.
-            """
-        ),
-        "Keyboard Shortcuts": (
-            """
-            Open the notebook menu (top-right) or input `Ctrl/Cmd+Shift+h` to
-            view a list of all keyboard shortcuts.
-            """
-        ),
-        "Configuration": (
-            """
-           Configure the editor by clicking the gears icon near the top-right
-           of the screen.
-           """
-        ),
-    }
-    return (tips,)
-
-
 if __name__ == "__main__":
     app.run()

layouts/app.slides.json

@@ -0,0 +1,4 @@
+{
+  "type": "slides",
+  "data": {}
+}

requirements.txt

@@ -1,5 +1,603 @@
-marimo
-# Or a specific version
-# marimo>=0.9.0
-
-# Add other dependencies as needed
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+ag-ui-protocol==0.1.9
+    # via pydantic-ai-slim
+aiohappyeyeballs==2.6.1
+    # via aiohttp
+aiohttp==3.13.0
+    # via huggingface-hub
+aiosignal==1.4.0
+    # via aiohttp
+annotated-types==0.7.0
+    # via pydantic
+anthropic==0.70.0
+    # via
+    #   resume-generator (pyproject.toml)
+    #   pydantic-ai-slim
+anyio==4.11.0
+    # via
+    #   anthropic
+    #   google-genai
+    #   groq
+    #   httpx
+    #   mcp
+    #   openai
+    #   pydantic-evals
+    #   sse-starlette
+    #   starlette
+argcomplete==3.6.2
+    # via pydantic-ai-slim
+attrs==25.4.0
+    # via
+    #   aiohttp
+    #   cyclopts
+    #   jsonschema
+    #   referencing
+authlib==1.6.5
+    # via fastmcp
+basedpyright==1.31.7
+    # via resume-generator (pyproject.toml)
+beautifulsoup4==4.14.2
+    # via
+    #   html-for-docx
+    #   markdownify
+    #   markitdown
+black==25.9.0
+    # via python-lsp-server
+boto3==1.40.53
+    # via pydantic-ai-slim
+botocore==1.40.53
+    # via
+    #   boto3
+    #   s3transfer
+cachetools==6.2.1
+    # via google-auth
+certifi==2025.10.5
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+cffi==2.0.0
+    # via cryptography
+charset-normalizer==3.4.4
+    # via
+    #   markitdown
+    #   pdfminer-six
+    #   requests
+click==8.3.0
+    # via
+    #   black
+    #   magika
+    #   marimo
+    #   uvicorn
+cobble==0.1.4
+    # via mammoth
+cohere==5.19.0
+    # via pydantic-ai-slim
+colorama==0.4.6
+    # via griffe
+coloredlogs==15.0.1
+    # via onnxruntime
+cryptography==46.0.3
+    # via
+    #   authlib
+    #   pdfminer-six
+cyclopts==3.24.0
+    # via fastmcp
+defusedxml==0.7.1
+    # via markitdown
+distro==1.9.0
+    # via
+    #   anthropic
+    #   groq
+    #   openai
+dnspython==2.8.0
+    # via email-validator
+docstring-parser==0.17.0
+    # via
+    #   anthropic
+    #   cyclopts
+docstring-to-markdown==0.17
+    # via python-lsp-server
+docutils==0.22.2
+    # via
+    #   marimo
+    #   rich-rst
+email-validator==2.3.0
+    # via pydantic
+eval-type-backport==0.2.2
+    # via mistralai
+exceptiongroup==1.3.0
+    # via fastmcp
+executing==2.2.1
+    # via logfire
+fastavro==1.12.1
+    # via cohere
+fastmcp==2.12.4
+    # via resume-generator (pyproject.toml)
+filelock==3.20.0
+    # via huggingface-hub
+flatbuffers==25.9.23
+    # via onnxruntime
+frozenlist==1.8.0
+    # via
+    #   aiohttp
+    #   aiosignal
+fsspec==2025.9.0
+    # via huggingface-hub
+genai-prices==0.0.32
+    # via pydantic-ai-slim
+google-auth==2.41.1
+    # via
+    #   google-genai
+    #   pydantic-ai-slim
+google-genai==1.45.0
+    # via pydantic-ai-slim
+googleapis-common-protos==1.70.0
+    # via opentelemetry-exporter-otlp-proto-http
+griffe==1.14.0
+    # via pydantic-ai-slim
+groq==0.32.0
+    # via pydantic-ai-slim
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+hf-xet==1.1.10
+    # via huggingface-hub
+html-for-docx==1.0.10
+    # via resume-generator (pyproject.toml)
+httpcore==1.0.9
+    # via httpx
+httpx==0.28.1
+    # via
+    #   anthropic
+    #   cohere
+    #   fastmcp
+    #   genai-prices
+    #   google-genai
+    #   groq
+    #   mcp
+    #   mistralai
+    #   openai
+    #   pydantic-ai-slim
+    #   pydantic-graph
+httpx-sse==0.4.0
+    # via
+    #   cohere
+    #   mcp
+huggingface-hub==0.35.3
+    # via
+    #   pydantic-ai-slim
+    #   tokenizers
+humanfriendly==10.0
+    # via coloredlogs
+idna==3.11
+    # via
+    #   anyio
+    #   email-validator
+    #   httpx
+    #   requests
+    #   yarl
+importlib-metadata==8.7.0
+    # via
+    #   docstring-to-markdown
+    #   opentelemetry-api
+iniconfig==2.1.0
+    # via pytest
+invoke==2.2.1
+    # via mistralai
+isodate==0.7.2
+    # via openapi-core
+itsdangerous==2.2.0
+    # via marimo
+jedi==0.19.2
+    # via
+    #   marimo
+    #   python-lsp-server
+jiter==0.11.0
+    # via
+    #   anthropic
+    #   openai
+jmespath==1.0.1
+    # via
+    #   boto3
+    #   botocore
+jsonschema==4.25.1
+    # via
+    #   mcp
+    #   openapi-core
+    #   openapi-schema-validator
+    #   openapi-spec-validator
+jsonschema-path==0.3.4
+    # via
+    #   openapi-core
+    #   openapi-spec-validator
+jsonschema-specifications==2025.9.1
+    # via
+    #   jsonschema
+    #   openapi-schema-validator
+lazy-object-proxy==1.12.0
+    # via openapi-spec-validator
+logfire==4.13.2
+    # via pydantic-ai-slim
+logfire-api==4.13.2
+    # via
+    #   pydantic-evals
+    #   pydantic-graph
+loro==1.8.1
+    # via marimo
+lxml==6.0.2
+    # via
+    #   markitdown
+    #   python-docx
+magika==0.6.2
+    # via markitdown
+mammoth==1.11.0
+    # via markitdown
+marimo==0.17.0
+    # via resume-generator (pyproject.toml)
+markdown==3.9
+    # via
+    #   marimo
+    #   pymdown-extensions
+markdown-it-py==4.0.0
+    # via rich
+markdownify==1.2.0
+    # via markitdown
+markitdown==0.1.3
+    # via resume-generator (pyproject.toml)
+markupsafe==3.0.3
+    # via werkzeug
+mcp==1.17.0
+    # via
+    #   resume-generator (pyproject.toml)
+    #   fastmcp
+    #   pydantic-ai-slim
+mdurl==0.1.2
+    # via markdown-it-py
+mistralai==1.9.11
+    # via pydantic-ai-slim
+mistune==3.1.4
+    # via resume-generator (pyproject.toml)
+more-itertools==10.8.0
+    # via openapi-core
+mpmath==1.3.0
+    # via sympy
+msgspec-m==0.19.2
+    # via marimo
+multidict==6.7.0
+    # via
+    #   aiohttp
+    #   yarl
+mypy-extensions==1.1.0
+    # via black
+narwhals==2.8.0
+    # via marimo
+nest-asyncio==1.6.0
+    # via resume-generator (pyproject.toml)
+nexus-rpc==1.1.0
+    # via temporalio
+nodejs-wheel-binaries==22.20.0
+    # via basedpyright
+numpy==2.3.4
+    # via
+    #   magika
+    #   onnxruntime
+onnxruntime==1.23.1
+    # via magika
+openai==2.3.0
+    # via
+    #   resume-generator (pyproject.toml)
+    #   pydantic-ai-slim
+openapi-core==0.19.5
+    # via fastmcp
+openapi-pydantic==0.5.1
+    # via fastmcp
+openapi-schema-validator==0.6.3
+    # via
+    #   openapi-core
+    #   openapi-spec-validator
+openapi-spec-validator==0.7.2
+    # via openapi-core
+opentelemetry-api==1.37.0
+    # via
+    #   opentelemetry-exporter-otlp-proto-http
+    #   opentelemetry-instrumentation
+    #   opentelemetry-instrumentation-httpx
+    #   opentelemetry-sdk
+    #   opentelemetry-semantic-conventions
+    #   pydantic-ai-slim
+opentelemetry-exporter-otlp-proto-common==1.37.0
+    # via opentelemetry-exporter-otlp-proto-http
+opentelemetry-exporter-otlp-proto-http==1.37.0
+    # via logfire
+opentelemetry-instrumentation==0.58b0
+    # via
+    #   logfire
+    #   opentelemetry-instrumentation-httpx
+opentelemetry-instrumentation-httpx==0.58b0
+    # via logfire
+opentelemetry-proto==1.37.0
+    # via
+    #   opentelemetry-exporter-otlp-proto-common
+    #   opentelemetry-exporter-otlp-proto-http
+opentelemetry-sdk==1.37.0
+    # via
+    #   logfire
+    #   opentelemetry-exporter-otlp-proto-http
+opentelemetry-semantic-conventions==0.58b0
+    # via
+    #   opentelemetry-instrumentation
+    #   opentelemetry-instrumentation-httpx
+    #   opentelemetry-sdk
+opentelemetry-util-http==0.58b0
+    # via opentelemetry-instrumentation-httpx
+packaging==25.0
+    # via
+    #   black
+    #   huggingface-hub
+    #   marimo
+    #   onnxruntime
+    #   opentelemetry-instrumentation
+    #   pytest
+parse==1.20.2
+    # via openapi-core
+parso==0.8.5
+    # via jedi
+pathable==0.4.4
+    # via jsonschema-path
+pathspec==0.12.1
+    # via black
+pdfminer-six==20250506
+    # via markitdown
+platformdirs==4.5.0
+    # via black
+pluggy==1.6.0
+    # via
+    #   pytest
+    #   python-lsp-server
+prompt-toolkit==3.0.52
+    # via pydantic-ai-slim
+propcache==0.4.1
+    # via
+    #   aiohttp
+    #   yarl
+protobuf==6.33.0
+    # via
+    #   googleapis-common-protos
+    #   logfire
+    #   onnxruntime
+    #   opentelemetry-proto
+    #   temporalio
+psutil==7.1.0
+    # via marimo
+pyasn1==0.6.1
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.4.2
+    # via google-auth
+pycparser==2.23
+    # via cffi
+pydantic==2.12.2
+    # via
+    #   resume-generator (pyproject.toml)
+    #   ag-ui-protocol
+    #   anthropic
+    #   cohere
+    #   fastmcp
+    #   genai-prices
+    #   google-genai
+    #   groq
+    #   mcp
+    #   mistralai
+    #   openai
+    #   openapi-pydantic
+    #   pydantic-ai-slim
+    #   pydantic-evals
+    #   pydantic-graph
+    #   pydantic-settings
+pydantic-ai==1.1.0
+    # via resume-generator (pyproject.toml)
+pydantic-ai-slim==1.1.0
+    # via
+    #   pydantic-ai
+    #   pydantic-evals
+pydantic-core==2.41.4
+    # via
+    #   cohere
+    #   pydantic
+pydantic-evals==1.1.0
+    # via pydantic-ai-slim
+pydantic-graph==1.1.0
+    # via pydantic-ai-slim
+pydantic-settings==2.11.0
+    # via mcp
+pygments==2.19.2
+    # via
+    #   marimo
+    #   pytest
+    #   rich
+pymdown-extensions==10.16.1
+    # via marimo
+pyperclip==1.11.0
+    # via
+    #   fastmcp
+    #   pydantic-ai-slim
+pytest==8.4.2
+    # via resume-generator (pyproject.toml)
+python-dateutil==2.9.0.post0
+    # via
+    #   botocore
+    #   mistralai
+python-docx==1.2.0
+    # via
+    #   resume-generator (pyproject.toml)
+    #   html-for-docx
+    #   python-docx-replace
+python-docx-replace==0.4.4
+    # via resume-generator (pyproject.toml)
+python-dotenv==1.1.1
+    # via
+    #   resume-generator (pyproject.toml)
+    #   fastmcp
+    #   magika
+    #   pydantic-settings
+python-lsp-jsonrpc==1.1.2
+    # via python-lsp-server
+python-lsp-server==1.13.1
+    # via resume-generator (pyproject.toml)
+python-multipart==0.0.20
+    # via mcp
+pytokens==0.2.0
+    # via black
+pyyaml==6.0.3
+    # via
+    #   huggingface-hub
+    #   jsonschema-path
+    #   marimo
+    #   mistralai
+    #   pydantic-evals
+    #   pymdown-extensions
+referencing==0.36.2
+    # via
+    #   jsonschema
+    #   jsonschema-path
+    #   jsonschema-specifications
+requests==2.32.5
+    # via
+    #   cohere
+    #   google-genai
+    #   huggingface-hub
+    #   jsonschema-path
+    #   markitdown
+    #   opentelemetry-exporter-otlp-proto-http
+    #   pydantic-ai-slim
+rfc3339-validator==0.1.4
+    # via openapi-schema-validator
+rich==14.2.0
+    # via
+    #   cyclopts
+    #   fastmcp
+    #   logfire
+    #   pydantic-ai-slim
+    #   pydantic-evals
+    #   rich-rst
+rich-rst==1.3.2
+    # via cyclopts
+rpds-py==0.27.1
+    # via
+    #   jsonschema
+    #   referencing
+rsa==4.9.1
+    # via google-auth
+ruff==0.14.0
+    # via resume-generator (pyproject.toml)
+s3transfer==0.14.0
+    # via boto3
+six==1.17.0
+    # via
+    #   markdownify
+    #   python-dateutil
+    #   rfc3339-validator
+sniffio==1.3.1
+    # via
+    #   anthropic
+    #   anyio
+    #   groq
+    #   openai
+soupsieve==2.8
+    # via beautifulsoup4
+sqlglot==27.27.0
+    # via resume-generator (pyproject.toml)
+sse-starlette==3.0.2
+    # via mcp
+starlette==0.48.0
+    # via
+    #   marimo
+    #   mcp
+    #   pydantic-ai-slim
+sympy==1.14.0
+    # via onnxruntime
+temporalio==1.18.0
+    # via pydantic-ai-slim
+tenacity==9.1.2
+    # via
+    #   google-genai
+    #   pydantic-ai-slim
+tokenizers==0.22.1
+    # via cohere
+tomlkit==0.13.3
+    # via marimo
+tqdm==4.67.1
+    # via
+    #   huggingface-hub
+    #   openai
+ty==0.0.1a22
+    # via resume-generator (pyproject.toml)
+types-protobuf==6.32.1.20250918
+    # via temporalio
+types-requests==2.32.4.20250913
+    # via cohere
+typing-extensions==4.15.0
+    # via
+    #   anthropic
+    #   beautifulsoup4
+    #   cohere
+    #   docstring-to-markdown
+    #   google-genai
+    #   groq
+    #   huggingface-hub
+    #   logfire
+    #   nexus-rpc
+    #   openai
+    #   openapi-core
+    #   opentelemetry-api
+    #   opentelemetry-exporter-otlp-proto-http
+    #   opentelemetry-sdk
+    #   opentelemetry-semantic-conventions
+    #   pydantic
+    #   pydantic-core
+    #   python-docx
+    #   temporalio
+    #   typing-inspection
+typing-inspection==0.4.2
+    # via
+    #   mistralai
+    #   pydantic
+    #   pydantic-ai-slim
+    #   pydantic-graph
+    #   pydantic-settings
+ujson==5.11.0
+    # via
+    #   python-lsp-jsonrpc
+    #   python-lsp-server
+urllib3==2.5.0
+    # via
+    #   botocore
+    #   requests
+    #   types-requests
+uvicorn==0.37.0
+    # via
+    #   marimo
+    #   mcp
+uvloop==0.21.0
+    # via resume-generator (pyproject.toml)
+wcwidth==0.2.14
+    # via prompt-toolkit
+websockets==15.0.1
+    # via
+    #   resume-generator (pyproject.toml)
+    #   google-genai
+    #   marimo
+werkzeug==3.1.1
+    # via openapi-core
+wrapt==1.17.3
+    # via
+    #   opentelemetry-instrumentation
+    #   opentelemetry-instrumentation-httpx
+yarl==1.22.0
+    # via aiohttp
+zipp==3.23.0
+    # via importlib-metadata