<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Python in Plain English - Medium]]></title>
        <description><![CDATA[New Python content every day. Follow to join our 3.5M+ monthly readers. - Medium]]></description>
        <link>https://python.plainenglish.io?source=rss----78073def27b8---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Python in Plain English - Medium</title>
            <link>https://python.plainenglish.io?source=rss----78073def27b8---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 05:22:57 GMT</lastBuildDate>
        <atom:link href="https://python.plainenglish.io/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[DeepSeek Is Building an Agent That Can Hire Claude Code and Codex to Do Its Work.]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/deepseek-is-building-an-agent-that-can-hire-claude-code-and-codex-to-do-its-work-9126c1c41016?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/1672/1*O7XIzvS-n-3gGcNE9DLWHA.png" width="1672"></a></p><p class="medium-feed-snippet">DeepSeek&#x2019;s preview combines external CLI delegation, named agent teams and Git worktrees.</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/deepseek-is-building-an-agent-that-can-hire-claude-code-and-codex-to-do-its-work-9126c1c41016?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/deepseek-is-building-an-agent-that-can-hire-claude-code-and-codex-to-do-its-work-9126c1c41016?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/9126c1c41016</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[deepseek]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[openai]]></category>
            <dc:creator><![CDATA[Mehulpratapsingh]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 04:04:43 GMT</pubDate>
            <atom:updated>2026-11-18T04:04:42.452Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[5 Python Libraries for Wikitext, Bit Packing, Markdown, WebSockets and ELF Files (One Has a Trap)]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/5-python-libraries-for-wikitext-bit-packing-markdown-websockets-and-elf-files-one-has-a-trap-87e9036e348d?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/1672/1*Kp2epdIpbvjhyHZ_A8GFxA.png" width="1672"></a></p><p class="medium-feed-snippet">Some Python libraries read one odd format so well that you stop writing fragile parsers.</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/5-python-libraries-for-wikitext-bit-packing-markdown-websockets-and-elf-files-one-has-a-trap-87e9036e348d?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/5-python-libraries-for-wikitext-bit-packing-markdown-websockets-and-elf-files-one-has-a-trap-87e9036e348d?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/87e9036e348d</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Abdul Ahad]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 00:01:03 GMT</pubDate>
            <atom:updated>2026-11-18T00:01:02.599Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[10 Developer Tools That Make Coding Almost Too Easy]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/10-developer-tools-that-make-coding-almost-too-easy-f656edd2b9bb?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/1672/1*5G7UNiiguc3MGedDD-tE4Q.png" width="1672"></a></p><p class="medium-feed-snippet">These tools make some surprisingly annoying coding tasks much easier.</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/10-developer-tools-that-make-coding-almost-too-easy-f656edd2b9bb?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/10-developer-tools-that-make-coding-almost-too-easy-f656edd2b9bb?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/f656edd2b9bb</guid>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Arham Ali]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 21:44:31 GMT</pubDate>
            <atom:updated>2026-11-17T21:44:30.054Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Python Typing — All You Need To Know]]></title>
            <link>https://python.plainenglish.io/python-typing-all-you-need-to-know-84f91cfef0d2?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/84f91cfef0d2</guid>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Filip Kosowski]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 19:27:32 GMT</pubDate>
            <atom:updated>2026-11-17T19:27:31.155Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>What typing is, why it exists, and how to use it to write better Python code.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AAKPRFqn0a5hcjqVXG6N7w.jpeg" /></figure><h3>The Problem: Why Does Typing Exist?</h3><p><strong>Python is a dynamically typed language.</strong> This means you don’t tell Python what type a variable is — it figures it out on its own at runtime. In typed languages like Java or C, you must declare the type upfront (int x = 42), while in Python you just write:</p><pre>x = 42          # x is an int<br>x = &quot;hello&quot;     # now x is a string - Python doesn&#39;t complain<br>x = [1, 2, 3]   # now x is a list - still no complaints</pre><p>This flexibility makes Python easy to learn and work with, but it creates a real problem.</p><p>Look at this function:</p><pre>def calculate_total(items, discount):<br>    total = sum(items)<br>    return total - (total * discount)</pre><p>Just by reading the code, you can’t answer:</p><ul><li><strong>What is</strong> items? → <em>A list of numbers? A tuple? Something else?</em></li><li><strong>What is </strong>discount? → <em>A float like </em>0.1<em> (meaning 10%)? An int like </em>10<em>?</em></li><li><strong>What does this function return?</strong></li></ul><p>Your only options are to read through the implementation, trace how the function is called somewhere else, or hope there’s a comment that explains it.</p><p>For a small script, that’s manageable. But in a codebase with hundreds of functions, it becomes a real problem that slows you down. You end up spending more time figuring out what code does and how to use it, instead of actually writing it.</p><p>Now look at the same function with type hints:</p><pre>def calculate_total(items: list[float], discount: float) -&gt; float:<br>    total = sum(items)<br>    return total - (total * discount)</pre><p>Now you know instantly:</p><ul><li>items <strong>is a list of floats</strong></li><li>discount <strong>is a float</strong></li><li>The<strong> function returns a float</strong></li></ul><p>No guessing needed.</p><blockquote><strong>This is what Python’s type hint system is for: making your code self-documenting and helping </strong>developer <strong>tools catch bugs before you run the code.</strong></blockquote><h3>The Key Insight → Type Hints Don’t Change How Python Runs</h3><p>This is the most important thing to understand upfront.</p><blockquote><strong>Python ignores type hints when your code runs.</strong> <strong>They have zero effect on execution.</strong></blockquote><pre>def greet(name: str) -&gt; str:<br>    return f&quot;Hello, {name}&quot;<br><br># We said name should be a str, but we&#39;re passing an int.<br># Python doesn&#39;t care — it runs without any error.<br>result = greet(42)<br>print(result)  # Output: Hello, 42</pre><p><strong>No error. No warning. Python doesn’t enforce type hints.</strong></p><p>So what’s the point of type hints? <strong>The value comes from three sources:</strong></p><pre>                            YOUR CODE<br>                         (with type hints)<br>                                │<br>                ┌───────────────┼───────────────┐<br>                │               │               │<br>                ▼               ▼               ▼<br>           Type Checker      Your IDE       Other Devs<br>           (e.g. mypy)      (PyCharm,      reading your<br>                             VS Code)         code<br>                │               │               │<br>                ▼               ▼               ▼<br>           Finds type       Autocomplete    &quot;This function<br>           mismatches       suggestions,     takes a list<br>           before code        inline          of floats.&quot;<br>            even runs        warnings</pre><h4><strong>a) Type checkers</strong> like mypy or pyright.</h4><p>These are tools you run against your code — similar to how you run tests. <strong>They read your code, check if the types match everywhere, and report mistakes.</strong></p><blockquote><strong>The key part:</strong> they do this without running your code. They catch bugs before you execute the program.</blockquote><blockquote>Think of a spell-checker in a text editor — but instead of catching spelling mistakes, it catches type mistakes.</blockquote><h4><strong>b) Your IDE</strong> (VS Code, PyCharm).</h4><p>Your IDE reads type hints in the background as you write code. This is what powers smarter autocomplete — for example, when you type name. on a variable annotated as str, the IDE immediately suggests string methods like .upper() or .split(), because it already knows the type.</p><p>It also highlights type errors directly in your editor — for example, underlining a line in red when you pass a str where an int is expected.</p><h4><strong>c) Other developers</strong> (including future you).</h4><p>Type hints act as built-in documentation. Anyone reading the code can immediately see what a function expects as input and what it returns, without reading the implementation.</p><h3>The Basics — Built-In Type Hints</h3><p>Now that you know why type hints exist, let’s learn how to write them.</p><p>The syntax is simple. You add a colon : after a variable or parameter name, followed by the type. For functions return types, you add -&gt; followed by the type before the colon that starts the function body.</p><pre># Variable annotation:<br># variable_name: Type = value<br>age: int = 30<br><br># Function annotation:<br># def function_name(param: ParamType) -&gt; ReturnType:<br>def double(x: int) -&gt; int:<br>    return x * 2</pre><p>That’s the entire syntax. Everything else builds on top of this. Let’s look at where and how to use it.</p><h4>Variables</h4><p>For basic types — str, int, float, bool — you just write the type after the colon:</p><pre>name: str = &quot;Alice&quot;<br>age: int = 30<br>height: float = 5.9<br>is_active: bool = True</pre><p>In practice, <strong>you rarely need to annotate simple variables</strong> like this. Python and your IDE can already see that name = &quot;Alice&quot; is a str. <strong>The annotation adds no new information.</strong></p><p><strong>Variable annotations become useful when the type</strong> <strong>isn’t obvious</strong> from the value:</p><pre># An empty list - what type of elements will it hold?<br># The annotation answers that question.<br>user_ids: list[int] = []<br>config: dict[str, str] = {}</pre><h4>Function Parameters and Return Types</h4><p>This is <strong>where type hints give you the most value</strong> — at the <strong>interface level</strong>. You annotate what goes in <em>(parameters)</em> and what comes out <em>(return type)</em>:</p><pre># The syntax:<br># def function_name(param: ParamType) -&gt; ReturnType:<br><br>def get_full_name(first: str, last: str) -&gt; str:<br>    return f&quot;{first} {last}&quot;<br><br>def calculate_area(width: float, height: float) -&gt; float:<br>    return width * height<br><br>def is_adult(age: int) -&gt; bool:<br>    return age &gt;= 18</pre><p>Reading these signatures, you immediately know what each function expects and returns. No need to read the body.</p><h4>Functions That Return Nothing</h4><p>Some functions don’t return a value — they just perform an action <em>(printing, logging, writing to a file)</em>. Annotate these with -&gt; None:</p><pre>def log_message(message: str) -&gt; None:<br>    print(f&quot;[LOG] {message}&quot;)<br>    # No return statement.<br>    # Python returns None automatically.</pre><p><strong>This tells the reader: </strong><em>“Don’t try to use the return value of this function — there isn’t one.”</em></p><h3>Any Python Type Works as a Type Hint</h3><p>So far we’ve only used built-in types like str, int, list, and dict. But <strong>type hints are not limited to built-in types</strong>. <strong>You can use any Python class as a type hint</strong> —<em> classes from libraries, from the standard library, or your own custom classes.</em></p><pre>import pandas as pd<br><br>def clean_data(df: pd.DataFrame) -&gt; pd.DataFrame:<br>    &quot;&quot;&quot;Takes a DataFrame, returns a cleaned DataFrame.&quot;&quot;&quot;<br>    return df.dropna()</pre><pre>from datetime import datetime<br><br>def format_date(dt: datetime) -&gt; str:<br>    return dt.strftime(&quot;%Y-%m-%d&quot;)</pre><p>Your own custom classes work exactly the same way:</p><pre>class User:<br>    def __init__(self, name: str, age: int):<br>        self.name = name<br>        self.age = age<br><br>def greet_user(user: User) -&gt; str:<br>    return f&quot;Hello, {user.name}!&quot;<br><br>def find_oldest(users: list[User]) -&gt; User:<br>    return max(users, key=lambda u: u.age)</pre><blockquote><strong>The rule is straightforward:</strong> any class can be used as a type hint.</blockquote><h3>Collection Types — Lists, Dicts, Sets, Tuples</h3><p>When you type hint a collection, you often want to specify <strong>what’s inside it</strong>, not just that it’s a list or a dict:</p><pre>def process(items: list) -&gt; None: ...       # A list of what? Unclear.<br>def process(items: list[str]) -&gt; None: ...  # A list of strings. Clear.</pre><p>The<strong> type inside the square brackets</strong> <strong>is called a type parameter</strong>. It tells you the type of elements inside the collection.</p><p>Here are the most common ones:</p><pre># List - ordered, can have duplicates<br>names: list[str] = [&quot;Alice&quot;, &quot;Bob&quot;]<br><br># Dict - key-value pairs.<br># First type = key type, second type = value type.<br>ages: dict[str, int] = {&quot;Alice&quot;: 30, &quot;Bob&quot;: 25}<br><br># Set - unordered, no duplicates<br>unique_ids: set[int] = {1, 2, 3}<br><br># Tuple (fixed length) - you specify the type of EACH position<br>coordinate: tuple[float, float] = (3.14, 2.71)          # exactly 2 floats<br>record: tuple[str, int, bool] = (&quot;Alice&quot;, 30, True)     # str, int, bool<br><br># Tuple (variable length) - any number of elements, all the same type<br># The ... (ellipsis) means &quot;zero or more elements of this type&quot;<br>values: tuple[int, ...] = (1, 2, 3, 4, 5)</pre><blockquote><strong>Variable-length tuples</strong> — when you don’t know how many elements the tuple will have, but they’re all the same type. You write the element type once, followed by ... which means &quot;there can be any number of these elements&quot;:</blockquote><pre># A tuple of ints - could be 1 element, could be 100<br>values: tuple[int, ...] = (1, 2, 3, 4, 5)</pre><p>You can also describe more complex structures, as below:</p><pre># A list of dicts. Each dict maps a string key to an int value.<br>records: list[dict[str, int]] = [<br>    {&quot;age&quot;: 30, &quot;score&quot;: 95},<br>    {&quot;age&quot;: 25, &quot;score&quot;: 88},<br>]<br><br># A dict mapping a person&#39;s name to their list of grades<br>grades: dict[str, list[float]] = {<br>    &quot;Alice&quot;: [90.5, 85.0, 92.3],<br>    &quot;Bob&quot;: [78.0, 82.5],<br>}</pre><h3>The typing Module — Beyond the Basics</h3><p>Everything above uses Python’s built-in types — str, int, list, dict, etc. They cover simple cases. But real code has situations that<strong> built-in types can’t express. </strong>For example:</p><ul><li><em>“This </em><strong><em>value</em></strong><em> </em><strong><em>is either</em></strong><em> a string </em><strong><em>or</em></strong><em> None”</em></li><li><em>“This </em><strong><em>parameter is</em></strong><em> a </em><strong><em>function</em></strong><em>”</em></li><li><em>“This </em><strong><em>can be any type</em></strong><em>”</em></li></ul><p>The typing <strong>module covers the cases where built-in type hints aren&#39;t enough.</strong> Here are the most common ones:</p><h4>Optional — “This Type, or None”</h4><p>A common scenario: some functions can return either a real value or None <em>(for example, when a search finds nothing):</em></p><pre>from typing import Optional<br><br>def find_user(user_id: int) -&gt; Optional[str]:<br>    &quot;&quot;&quot;Returns the username if found, None if not.&quot;&quot;&quot;<br>    users = {1: &quot;Alice&quot;, 2: &quot;Bob&quot;}<br>    return users.get(user_id)  # .get() returns None if the key doesn&#39;t exist</pre><blockquote>Optional[str] means: <strong>&quot;either a </strong>str <strong>or </strong>None<strong>&quot;</strong>.</blockquote><p>In <strong>Python 3.10+</strong>, you can write the same thing with |:</p><pre># These two mean exactly the same thing:<br>def find_user(user_id: int) -&gt; Optional[str]: ...   # Older syntax<br>def find_user(user_id: int) -&gt; str | None: ...      # Modern syntax (3.10+)</pre><blockquote>The | syntax reads more naturally — means &quot;str <strong>or </strong>None&quot; —<strong> and doesn&#39;t need an import.</strong></blockquote><blockquote>Use it if your project runs on Python 3.10 or newer.</blockquote><h4>Union — “One of Several Types”</h4><p>Sometimes a value can be one of several types:</p><pre>from typing import Union<br><br>def process_id(id_value: Union[int, str]) -&gt; str:<br>    &quot;&quot;&quot;Accepts an ID as either an int or a string.&quot;&quot;&quot;<br>    return str(id_value)</pre><p>In Python 3.10+, use |:</p><pre>def process_id(id_value: int | str) -&gt; str:<br>    return str(id_value)</pre><blockquote><strong>Practical note:</strong> If you find yourself writing Union with many types (int | str | list | dict | None), it&#39;s usually a sign the function is trying to do too much. A function that accepts five different types is hard to understand and maintain.</blockquote><h4>Any — “Any Type”</h4><p>Sometimes you can’t know the type ahead of time, or it simply doesn’t matter. Any means<em> &quot;accept anything, and don&#39;t check it&quot;</em>:</p><pre>from typing import Any<br><br>def log_event(event_data: Any) -&gt; None:<br>    &quot;&quot;&quot;Logs whatever you give it. Could be a string, dict, int, anything.&quot;&quot;&quot;<br>    print(f&quot;Event: {event_data}&quot;)</pre><blockquote>Think of Any as a way to tell both the users and the type checker tools: &quot;anything works here.&quot; <em>Any </em>means accept whatever comes in — the type checker won&#39;t verify this value, won&#39;t flag mismatches, because all types are accepted here.</blockquote><ul><li><strong>When to use it:</strong> When you don’t know or can’t predict the type. <em>For example, data coming from an external API where the structure is unpredictable, or a utility function that works with any type.</em></li><li><strong>When NOT to use it:</strong> As a shortcut because you don’t want to figure out the correct type. That defeats the purpose of typing entirely.</li></ul><p><strong>Why not just leave the hint off entirely?</strong> Because Any is an explicit statement: <em>&quot;I looked at this and decided any type is acceptable here&quot;.</em><strong> No annotation at all is ambiguous</strong> — did you forget to add one, or did you intentionally skip it? Any removes that ambiguity.</p><h4>Callable — “This Parameter Is a Function”</h4><p><strong>In Python, functions are objects </strong>— just like strings, ints, or lists. You can store a function in a variable, put it in a list, or pass it as an argument to another function.</p><p>When a function accepts another function as a parameter, we can use Callable to <strong>describe what kind of function is expected</strong> <strong><em>(</em></strong><em>what arguments it takes and what it returns)</em>:</p><pre>from typing import Callable<br><br>def apply_twice(x: int, operation: Callable[[int], int]) -&gt; int:<br>    &quot;&quot;&quot;<br>    Takes a number and a function.<br>    Applies the function to the number twice.<br><br>    Callable[[int], int] reads as:<br>      - [int]   → the function takes one int argument<br>      - int     → and returns an int<br>    &quot;&quot;&quot;<br>    return operation(operation(x))<br><br># Example functions that match Callable[[int], int]:<br>def double(n: int) -&gt; int:<br>    return n * 2<br><br>def add_ten(n: int) -&gt; int:<br>    return n + 10<br><br># Pass the function itself (no parentheses — we&#39;re not calling it,<br># we&#39;re passing it so apply_twice can call it)<br>apply_twice(5, double)    # double(double(5)) = double(10) = 20<br>apply_twice(5, add_ten)   # add_ten(add_ten(5)) = add_ten(15) = 25</pre><ul><li><strong>The syntax: </strong>Callable[[ParamType1, ParamType2, ...], ReturnType].</li></ul><p>A few more examples to make the pattern clear:</p><pre>Callable[[int], int]           # takes one int, returns int<br>Callable[[str, str], bool]     # takes two strings, returns bool<br>Callable[[], None]             # takes no arguments, returns None</pre><p>Without Callable, you would have to write operation: ??? and hope the reader figures out what kind of function to pass.</p><h3>Type Aliases — Giving Complex Types a Short Name</h3><p>As your code grows, type hints can get long. Look at this:</p><pre>def process(data: list[dict[str, list[tuple[int, float]]]]) -&gt; None: ...<br>def validate(row: dict[str, list[tuple[int, float]]]) -&gt; bool: ...<br>def transform(row: dict[str, list[tuple[int, float]]]) -&gt; dict[str, list[tuple[int, float]]]: ...</pre><p>The type dict[str, list[tuple[int, float]]] is repeated three times. <strong>It&#39;s hard to read, and if its structure changes, you have to update it everywhere.</strong></p><p><strong>Type aliases</strong> solve this. You <strong>give the complex type a short name, and use that name instead</strong>:</p><pre>from typing import TypeAlias<br><br># Create an alias — a short name for a complex type<br>DataRow: TypeAlias = dict[str, list[tuple[int, float]]]<br><br># Now use the alias everywhere — same meaning, much easier to read<br>def process(data: list[DataRow]) -&gt; None: ...<br>def validate(row: DataRow) -&gt; bool: ...<br>def transform(row: DataRow) -&gt; DataRow: ...</pre><p>DataRow and dict[str, list[tuple[int, float]]] mean exactly the same thing. The alias is just a name — it doesn&#39;t create a new type.</p><blockquote><strong>Note:</strong> In Python 3.12+, TypeAlias is deprecated. The recommended way to define type aliases is the new type statement — it&#39;s cleaner and doesn&#39;t require any import:</blockquote><pre># Python 3.12+ (recommended)<br>type DataRow = dict[str, list[tuple[int, float]]]<br><br># Python 3.10–3.11 (older syntax)<br>from typing import TypeAlias<br>DataRow: TypeAlias = dict[str, list[tuple[int, float]]]</pre><blockquote>If your project runs on Python 3.12 or newer, use the type statement. For older versions, TypeAlias still works fine.</blockquote><h3>Generics — Type Hints for Flexible Functions</h3><p>This topic is a bit less common, but understanding the concept will help you read code from libraries and frameworks that use it.</p><h4>The Problem</h4><p>Imagine you write a simple utility function:</p><pre>def first_element(items: list) -&gt; ???:<br>    &quot;&quot;&quot;Returns the first element of a list.&quot;&quot;&quot;<br>    return items[0]</pre><p>What should the return type be?</p><pre>first_element([1, 2, 3])        # returns 1       → an int<br>first_element([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;])  # returns &quot;a&quot;     → a str<br>first_element([True, False])    # returns True    → a bool</pre><blockquote><strong>The return type depends on what’s in the list…</strong></blockquote><p>We can’t write -&gt; int because it&#39;s not always int. We could write -&gt; Any, but then the type checker can&#39;t help us — it won&#39;t know that calling first_element([1, 2, 3]) gives us an int.</p><blockquote><em>What we want to say is: </em><strong>“I don’t know the type in advance. But whatever type goes into the list, the same type comes out.”</strong></blockquote><h4>The Solution: TypeVar</h4><p>We need a way to say: <em>“The return type isn’t fixed — it’s the same as the input type in the list”.</em> If the input is list[int], return int. If the input is list[str], return str.</p><p>To express this, we create a <strong>placeholder type</strong> using TypeVar. A<strong> placeholder means:</strong> <em>“I don’t know the actual type yet. Each time the function is called, the type checker will look at the current call’s input, see what type it has, and use that same type for the output.”</em></p><pre>from typing import TypeVar<br><br># Step 1: Create a temporary type called T<br>T = TypeVar(&quot;T&quot;)<br><br># Step 2: Use T in both the input and the output.<br>#          This tells the type checker: &quot;input type and output type are linked&quot;<br>def first_element(items: list[T]) -&gt; T:<br>    return items[0]</pre><p>Now when you call the function, the type checker looks at the current call’s input, sees what type it has, and uses that same type for the output:</p><pre>x = first_element([1, 2, 3])   # input is list[int] → T = int → output is int<br>y = first_element([&quot;a&quot;, &quot;b&quot;])  # input is list[str] → T = str → output is str</pre><p>Here’s the mental model — watch how T gets replaced:</p><pre># First call: type checker looks at the input and sees list[int]<br>first_element([1, 2, 3])<br><br>    items: list[T]  →  items: list[int]  →  T = int<br>    return: T       →  return: int       ✓  type checker knows x is int<br><br># Second call: independent from the first — type checker sees list[str]<br>first_element([&quot;a&quot;, &quot;b&quot;])<br><br>    items: list[T]  →  items: list[str]  →  T = str<br>    return: T       →  return: str       ✓  type checker knows y is str</pre><blockquote>The whole idea is simple: T appears in two places — input and output — and <strong>both must be the same type</strong>. That&#39;s the link. If int goes in, int comes out.</blockquote><p>Without TypeVar, you&#39;d have two bad options:</p><ul><li>Write -&gt; int — wrong, because the function doesn&#39;t always return int.</li><li>Write -&gt; Any — the type checker stops checking and can&#39;t catch mistakes.</li></ul><p>TypeVar gives you a third option.</p><blockquote><strong>Side note on syntax:</strong> When you write T = TypeVar(&quot;T&quot;), the string &quot;T&quot; inside the parentheses must match the variable name on the left side. So if you named it Item = TypeVar(...), the string must be &quot;Item&quot;. Python uses this string in error messages to identify the placeholder. Don&#39;t overthink it — just make sure both sides match.</blockquote><h3>Practical Tips</h3><h4>1. Focus on Function Signatures First</h4><p>I<strong>f there is one thing you should always type-hint, it’s your function parameters and return types. </strong>This is where 90% of the value comes from:</p><pre>def fetch_users(active_only: bool, limit: int = 100) -&gt; list[dict[str, Any]]:<br>    ...</pre><p>This single line tells you everything about what the function expects and what it returns. That’s what matters most.</p><h4>2. Run a Type Checker in CI</h4><p>For team projects, add mypy or pyright to your <strong>CI pipeline</strong>. CI <em>(Continuous Integration)</em> is the system that runs automated checks when someone pushes code.<strong> Adding a type checker means type errors are caught before code is merged</strong>:</p><pre># Install mypy<br>pip install mypy<br><br># Check your project<br>mypy your_project/<br><br># Example output:<br># your_project/utils.py:15: error: Argument 1 to &quot;process&quot;<br>#   has incompatible type &quot;str&quot;; expected &quot;int&quot;</pre><blockquote><strong>Think of it as an extra layer of automated testing — it catches bugs that regular tests might miss.</strong></blockquote><h4>3. Don’t Over-Annotate</h4><p>Type hints should help, not clutter your code. Don’t annotate things where the type is already obvious:</p><pre># ✘ Unnecessary — the type is obvious from the value<br>x: int = 5<br>name: str = &quot;Alice&quot;<br>items: list[int] = [1, 2, 3]<br><br># ✔ Useful — the type is NOT obvious<br>user_ids: list[int] = []        # Can&#39;t tell from [] what goes inside<br>response: dict[str, Any] = {}   # Can&#39;t tell from {} what the structure is</pre><blockquote><strong>Rule of thumb: if the type is obvious from context, skip the annotation.</strong></blockquote><h3>THE END</h3><p>That’s it for this article! I hope I gave you a clear picture of what Python typing is, why it exists, and how to use it effectively in your everyday code.</p><p>You now have everything you need to start adding type hints with confidence and make your code easier to read and easier to maintain.</p><h4>Before you go</h4><blockquote>Did this help? If you found this article useful, I’d really appreciate your support: 👏 clap for this story (once or 50!), 🔔 follow for more content, ✍ ️leave a comment telling me what you think!</blockquote><blockquote>Check out my other articles — I’ve grouped them by category so you can easily find what’s relevant to you: <a href="https://medium.com/@FKosa/lists">My Articles by Category.</a></blockquote><blockquote>I’ll be sharing more material on data and software engineering concepts!</blockquote><p><strong>You can find me also on </strong><a href="https://www.linkedin.com/in/filip-koss"><strong>LinkedIn</strong></a><strong>.</strong></p><p><strong>Cheers, see you next time!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84f91cfef0d2" width="1" height="1" alt=""><hr><p><a href="https://python.plainenglish.io/python-typing-all-you-need-to-know-84f91cfef0d2">Python Typing — All You Need To Know</a> was originally published in <a href="https://python.plainenglish.io">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Python Tool That Predicts Which Freelance Proposals Are Most Likely to Win]]></title>
            <link>https://python.plainenglish.io/i-built-a-python-tool-that-predicts-which-freelance-proposals-are-most-likely-to-win-33e252e4a74e?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/33e252e4a74e</guid>
            <dc:creator><![CDATA[Suleman Safdar]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 18:12:39 GMT</pubDate>
            <atom:updated>2026-11-17T18:12:38.061Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>I used to think winning freelance projects was mostly about writing better proposals and sending more applications. Then I noticed something some opportunities were almost impossible to win, while others had clear requirements, realistic budgets, responsive clients, and a strong match with my skills. The problem wasn’t always the proposal. It was deciding which opportunities deserved the effort. So I built a Python-powered freelance opportunity intelligence system that analyzes project descriptions, scores client fit, detects warning signs, and helps freelancers prioritize the proposals worth sending.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SL-pKesz_f6tSG1kp7igwg.jpeg" /></figure><h3>1. I Realized Sending More Proposals Wasn’t Always the Answer</h3><p>Imagine you’re a freelance developer looking for your next project.</p><p>You open a freelancing platform and find 40 new opportunities.</p><p>One client wants a complete e-commerce website for $100. Another needs a Python automation script and offers a realistic budget. A third wants an experienced developer to fix a production system but provides almost no technical details.</p><p>Which one should you apply for?</p><p>Most freelancers make this decision quickly. They scan the title, check the budget, and decide whether the project sounds interesting.</p><p>But this approach creates a problem.</p><p>You might spend an hour writing a proposal for a client who has an unrealistic budget, unclear requirements, or an impossible deadline.</p><p>Meanwhile, a better opportunity gets ignored.</p><p>I wanted to build a tool that could answer a more useful question:</p><p><strong>Which freelance opportunities deserve my time, and what should I know before applying?</strong></p><p>The idea became a Python project called ProposalRadar.</p><p>Its purpose was to analyze freelance project descriptions and generate an evidence-based opportunity score.</p><p>It wouldn’t guarantee that a project would be won. It would help freelancers make better decisions about where to invest their time.</p><h3>2. I Stopped Looking at Projects as Just Titles and Budgets</h3><p>A project title rarely tells the complete story.</p><p>Consider these two opportunities:</p><p><strong>Project A</strong></p><p>“Need Python developer urgently. Budget $50. Complete automation system required.”</p><p><strong>Project B</strong></p><p>“Looking for a Python developer to automate monthly invoice processing. Existing workflow uses Excel files. Need CSV validation, PDF generation, and automated email delivery. Budget $600–$900.”</p><p>Project A might attract attention because it sounds exciting.</p><p>But Project B provides more useful information:</p><ul><li>A clearly defined problem.</li><li>Specific technical requirements.</li><li>A realistic deliverable.</li><li>A budget range.</li><li>A business use case.</li></ul><p>I decided to analyze opportunities across six dimensions:</p><ol><li>Skill compatibility.</li><li>Budget suitability.</li><li>Requirement clarity.</li><li>Project complexity.</li><li>Client risk indicators.</li><li>Competition and application context, when available.</li></ol><p>The important thing was to avoid treating one factor as the whole decision.</p><p>A high-budget project isn’t automatically a good opportunity, and a lower-budget project isn’t automatically worthless.</p><h3>3. I Created a Dataset of Freelance Opportunities</h3><p>Before building the scoring engine, I needed a consistent data format.</p><p>For the first version, I used a CSV file.</p><pre>project_id,title,description,budget_min,budget_max,client_rating,proposals_count,skills<br>101,Python Automation,Automate invoice processing,400,800,4.8,5,&quot;Python, Pandas, Automation&quot;<br>102,Website Fix,Fix website urgently,20,50,3.2,35,&quot;HTML, CSS, JavaScript&quot;<br>103,Data Analysis,Analyze sales spreadsheet,250,500,4.6,8,&quot;Python, Pandas, Excel&quot;</pre><p>This is sample data for development, not real marketplace information.</p><p>I installed the dependencies:</p><pre>mkdir proposal-radar<br>cd proposal-radar</pre><pre>python -m venv venv</pre><pre># Windows<br>venv\Scripts\activate</pre><pre># macOS / Linux<br>source venv/bin/activate</pre><pre>pip install pandas numpy scikit-learn sentence-transformers pydantic fastapi uvicorn python-dotenv pytest</pre><p>Then I organized the application:</p><pre>proposal-radar/<br>│<br>├── app/<br>│   ├── __init__.py<br>│   ├── loader.py<br>│   ├── matching.py<br>│   ├── scoring.py<br>│   ├── risk_analysis.py<br>│   ├── recommendations.py<br>│   └── main.py<br>│<br>├── data/<br>│   └── projects.csv<br>│<br>├── tests/<br>│   └── test_scoring.py<br>│<br>├── .env<br>└── requirements.txt</pre><p>I wanted a modular application so I could improve the matching engine without rewriting the entire system.</p><h3>4. I Built a Skill-Matching Engine</h3><p>The first question was simple:</p><p>Does this project actually match the freelancer’s skills?</p><p>A Python developer might be interested in a project involving data automation, but a React-only frontend project might not be a good fit.</p><p>I started with keyword matching.</p><pre># app/matching.py<br>def calculate_skill_match(<br>    project_skills: list[str],<br>    freelancer_skills: list[str]<br>) -&gt; dict:<br>    project_set = {<br>        skill.strip().lower()<br>        for skill in project_skills<br>    }<br>    freelancer_set = {<br>        skill.strip().lower()<br>        for skill in freelancer_skills<br>    }<br>    if not project_set:<br>        return {<br>            &quot;score&quot;: 0,<br>            &quot;matched_skills&quot;: [],<br>            &quot;missing_skills&quot;: []<br>        }<br>    matched = project_set &amp; freelancer_set<br>    missing = project_set - freelancer_set<br>    score = (<br>        len(matched) / len(project_set)<br>    ) * 100<br>    return {<br>        &quot;score&quot;: round(score, 2),<br>        &quot;matched_skills&quot;: sorted(matched),<br>        &quot;missing_skills&quot;: sorted(missing)<br>    }</pre><p>Suppose the project requires:</p><pre>project_skills = [<br>    &quot;Python&quot;,<br>    &quot;Pandas&quot;,<br>    &quot;Automation&quot;,<br>    &quot;SQL&quot;<br>]<br>freelancer_skills = [<br>    &quot;Python&quot;,<br>    &quot;Pandas&quot;,<br>    &quot;Automation&quot;,<br>    &quot;Excel&quot;<br>]<br>result = calculate_skill_match(<br>    project_skills,<br>    freelancer_skills<br>)<br>print(result)</pre><p>The result would identify three matching skills and one missing skill.</p><p>This gives freelancers a quick indication of whether they can reasonably deliver the work.</p><p>However, keyword matching has an obvious weakness.</p><p>A client might request “data processing,” while the freelancer describes their experience as “data automation.”</p><p>The terminology differs, but the underlying skills might overlap.</p><p>I planned to introduce semantic matching later using sentence embeddings.</p><h3>5. I Used AI Embeddings to Understand Project Requirements</h3><p>This was where the system became more intelligent.</p><p>Instead of comparing only exact words, I wanted to compare the meaning of project descriptions with a freelancer’s capabilities.</p><p>For example:</p><ul><li>“Automate Excel reports.”</li><li>“Build a Python workflow for processing spreadsheet data.”</li></ul><p>These descriptions are different, but they may represent similar work.</p><p>I used Sentence Transformers.</p><pre># app/matching.py<br>from sentence_transformers import SentenceTransformer<br>from sklearn.metrics.pairwise import cosine_similarity<br><br>model = SentenceTransformer(<br>    &quot;all-MiniLM-L6-v2&quot;<br>)<br><br>def semantic_match(<br>    project_description: str,<br>    freelancer_profile: str<br>) -&gt; float:<br>    embeddings = model.encode([<br>        project_description,<br>        freelancer_profile<br>    ])<br>    similarity = cosine_similarity(<br>        [embeddings[0]],<br>        [embeddings[1]]<br>    )[0][0]<br>    return round(<br>        float(similarity) * 100,<br>        2<br>    )</pre><p>The function converts both descriptions into vectors and calculates cosine similarity.</p><p>A higher score indicates that the descriptions are semantically closer.</p><p>But this is not a true probability of being qualified.</p><p>Two descriptions can sound similar while requiring very different levels of expertise.</p><p>I would therefore combine semantic similarity with explicit skill checks and project-specific requirements.</p><h3>6. I Created a Budget Suitability Calculator</h3><p>Skill compatibility is only one side of the decision.</p><p>A project might be technically interesting but financially unrealistic.</p><p>I wanted freelancers to define their expected budget range and compare it with the client’s offer.</p><pre># app/scoring.py<br>def calculate_budget_match(<br>    budget_min: float,<br>    budget_max: float,<br>    expected_min: float,<br>    expected_max: float<br>) -&gt; float:<br>    if budget_max &lt; budget_min:<br>        raise ValueError(<br>            &quot;Invalid client budget range.&quot;<br>        )<br>    if expected_max &lt; expected_min:<br>        raise ValueError(<br>            &quot;Invalid freelancer budget range.&quot;<br>        )<br>    overlap_start = max(<br>        budget_min,<br>        expected_min<br>    )<br>    overlap_end = min(<br>        budget_max,<br>        expected_max<br>    )<br>    if overlap_end &lt; overlap_start:<br>        return 0.0<br>    overlap = overlap_end - overlap_start<br>    expected_width = (<br>        expected_max - expected_min<br>    )<br>    if expected_width == 0:<br>        return 100.0<br>    score = (<br>        overlap / expected_width<br>    ) * 100<br>    return round(<br>        min(score, 100),<br>        2<br>    )</pre><p>For example, suppose a freelancer wants $500–$900 and the client offers $600–$800.</p><p>There is a strong budget overlap.</p><p>If the client offers $100–$200, the opportunity becomes financially unsuitable.</p><p>This is more useful than simply sorting projects by their maximum budget.</p><p>For a more advanced system, I would also consider payment milestones, estimated working hours, platform fees, currency conversion, and expected revision time.</p><h3>7. I Built a Project Clarity Detector</h3><p>Some projects contain detailed requirements.</p><p>Others say something like:</p><p>“Need a professional developer to build a complete system. Contact me for details.”</p><p>That isn’t enough information to estimate the work accurately.</p><p>I wanted to detect whether a project description contained useful details.</p><p>For the first version, I created a simple rule-based detector.</p><pre># app/risk_analysis.py<br>CLARITY_TERMS = [<br>    &quot;requirements&quot;,<br>    &quot;deliverables&quot;,<br>    &quot;deadline&quot;,<br>    &quot;integration&quot;,<br>    &quot;database&quot;,<br>    &quot;api&quot;,<br>    &quot;design&quot;,<br>    &quot;workflow&quot;,<br>    &quot;documentation&quot;,<br>    &quot;testing&quot;<br>]<br><br>def calculate_clarity_score(<br>    description: str<br>) -&gt; float:<br>    text = description.lower()<br>    matched_terms = [<br>        term<br>        for term in CLARITY_TERMS<br>        if term in text<br>    ]<br>    score = (<br>        len(matched_terms)<br>        / len(CLARITY_TERMS)<br>    ) * 100<br>    return round(score, 2)</pre><p>This gives me an initial clarity indicator.</p><p>But I knew keyword counting was limited.</p><p>A project can be detailed without using these exact terms. Another project can include all ten terms without explaining anything properly.</p><p>The next version could use an LLM to extract:</p><ul><li>Required deliverables.</li><li>Technical constraints.</li><li>Expected timeline.</li><li>Client dependencies.</li><li>Missing information.</li><li>Acceptance criteria.</li></ul><p>The AI should explain what is unclear rather than automatically labeling a client as unreliable.</p><h3>8. I Added Warning Signals for Risky Opportunities</h3><p>I wanted the system to highlight conditions that deserved additional attention.</p><p>For example</p><ul><li>Extremely low budgets relative to stated requirements.</li><li>Unrealistic deadlines.</li><li>Contradictory project descriptions.</li><li>Unclear payment arrangements.</li><li>Excessive scope for the stated budget.</li><li>Missing technical details.</li></ul><p>I created a basic risk analyzer:</p><pre># app/risk_analysis.py<br>def identify_project_warnings(<br>    project: dict<br>) -&gt; list[str]:<br>    warnings = []<br>    description = project.get(<br>        &quot;description&quot;,<br>        &quot;&quot;<br>    )<br>    budget_min = project.get(<br>        &quot;budget_min&quot;,<br>        0<br>    )<br>    budget_max = project.get(<br>        &quot;budget_max&quot;,<br>        0<br>    )<br>    proposals = project.get(<br>        &quot;proposals_count&quot;,<br>        0<br>    )<br>    if not description.strip():<br>        warnings.append(<br>            &quot;Project description is missing.&quot;<br>        )<br>    if budget_min &lt;= 0 or budget_max &lt;= 0:<br>        warnings.append(<br>            &quot;Budget information requires verification.&quot;<br>        )<br>    if budget_max &lt; budget_min:<br>        warnings.append(<br>            &quot;The supplied budget range is invalid.&quot;<br>        )<br>    if proposals &gt; 30:<br>        warnings.append(<br>            &quot;Competition may be relatively high.&quot;<br>        )<br>    if len(description.split()) &lt; 20:<br>        warnings.append(<br>            &quot;Project description contains limited detail.&quot;<br>        )<br>    return warnings</pre><p>These are warnings, not fraud accusations.</p><p>A project with 40 proposals might still be worth applying for if the freelancer is a particularly strong match.</p><p>Likewise, a short description doesn’t necessarily mean the client is untrustworthy.</p><p>The tool should help freelancers ask better questions before investing their time.</p><h3>9. I Combined Everything Into One Opportunity Score</h3><p>Now I had several separate indicators:</p><ul><li>Skill compatibility</li><li>Semantic relevance.</li><li>Budget suitability.</li><li>Project clarity.</li><li>Competition.</li></ul><p>I wanted one score to make opportunities easier to prioritize.</p><p>I used a weighted scoring system.</p><pre># app/scoring.py<br>def calculate_opportunity_score(<br>    skill_score: float,<br>    semantic_score: float,<br>    budget_score: float,<br>    clarity_score: float,<br>    competition_score: float<br>) -&gt; float:<br>    weights = {<br>        &quot;skills&quot;: 0.30,<br>        &quot;semantic&quot;: 0.20,<br>        &quot;budget&quot;: 0.25,<br>        &quot;clarity&quot;: 0.15,<br>        &quot;competition&quot;: 0.10<br>    }<br>    score = (<br>        skill_score * weights[&quot;skills&quot;]<br>        + semantic_score * weights[&quot;semantic&quot;]<br>        + budget_score * weights[&quot;budget&quot;]<br>        + clarity_score * weights[&quot;clarity&quot;]<br>        + competition_score * weights[&quot;competition&quot;]<br>    )<br>    return round(<br>        max(0, min(score, 100)),<br>        2<br>    )</pre><p>The weights are illustrative and should be configurable.</p><p>For example, a highly experienced freelancer might care more about budget suitability, while someone building a portfolio might prioritize relevant experience.</p><p>I also wanted the dashboard to display the individual components instead of presenting only one mysterious number.</p><p>An opportunity score of 82 should come with an explanation:</p><ul><li>Strong technical match.</li><li>Budget fits the freelancer’s expectations.</li><li>Clear deliverables.</li><li>Moderate competition.</li><li>One missing requirement needs clarification.</li></ul><p>That explanation is more valuable than the score itself.</p><h3>10. I Turned the Analysis Into an API</h3><p>Once the individual components worked, I wanted the system to accept opportunities through an API.</p><p>I used FastAPI.</p><pre># app/main.py<br>from fastapi import FastAPI<br>from pydantic import BaseModel<br>from app.matching import calculate_skill_match<br>from app.scoring import (<br>    calculate_budget_match,<br>    calculate_opportunity_score<br>)<br>from app.risk_analysis import (<br>    calculate_clarity_score,<br>    identify_project_warnings<br>)<br><br>app = FastAPI(<br>    title=&quot;ProposalRadar API&quot;,<br>    version=&quot;1.0.0&quot;<br>)<br><br>class ProjectRequest(BaseModel):<br>    title: str<br>    description: str<br>    project_skills: list[str]<br>    freelancer_skills: list[str]<br>    budget_min: float<br>    budget_max: float<br>    expected_min: float<br>    expected_max: float<br>    proposals_count: int = 0<br><br>@app.post(&quot;/analyze-project&quot;)<br>def analyze_project(<br>    project: ProjectRequest<br>):<br>    skill_result = calculate_skill_match(<br>        project.project_skills,<br>        project.freelancer_skills<br>    )<br>    budget_score = calculate_budget_match(<br>        project.budget_min,<br>        project.budget_max,<br>        project.expected_min,<br>        project.expected_max<br>    )<br>    clarity_score = calculate_clarity_score(<br>        project.description<br>    )<br>    competition_score = max(<br>        0,<br>        100 - project.proposals_count * 2<br>    )<br>    opportunity_score = calculate_opportunity_score(<br>        skill_score=skill_result[&quot;score&quot;],<br>        semantic_score=skill_result[&quot;score&quot;],<br>        budget_score=budget_score,<br>        clarity_score=clarity_score,<br>        competition_score=competition_score<br>    )<br>    warnings = identify_project_warnings(<br>        project.model_dump()<br>    )<br>    return {<br>        &quot;project_title&quot;: project.title,<br>        &quot;opportunity_score&quot;: opportunity_score,<br>        &quot;skill_match&quot;: skill_result,<br>        &quot;budget_match&quot;: budget_score,<br>        &quot;clarity_score&quot;: clarity_score,<br>        &quot;competition_score&quot;: competition_score,<br>        &quot;warnings&quot;: warnings<br>    }</pre><p>Run the application:</p><pre>uvicorn app.main:app --reload</pre><p>Open:</p><pre>http://127.0.0.1:8000/docs</pre><p>You can submit a project and receive its analysis.</p><p>This first API uses the keyword score as a placeholder for semantic matching. In the full version, I would call the embedding-based function from the matching module and keep both scores separate.</p><p>I would also add authentication, request validation, persistent storage, and rate limiting before deploying it.</p><h3>11. I Tested the Scoring Engine Before Using It to Rank Opportunities</h3><p>I didn’t want a scoring system that produced attractive numbers but failed on basic inputs.</p><p>So I added tests for skill matching and budget suitability.</p><pre># tests/test_scoring.py<br>import pytest<br>from app.matching import calculate_skill_match<br>from app.scoring import calculate_budget_match<br><br>def test_perfect_skill_match():<br>    result = calculate_skill_match(<br>        [&quot;Python&quot;, &quot;Pandas&quot;],<br>        [&quot;Python&quot;, &quot;Pandas&quot;, &quot;Excel&quot;]<br>    )<br>    assert result[&quot;score&quot;] == 100<br><br>def test_no_skill_match():<br>    result = calculate_skill_match(<br>        [&quot;Python&quot;, &quot;SQL&quot;],<br>        [&quot;Photoshop&quot;, &quot;Illustrator&quot;]<br>    )<br>    assert result[&quot;score&quot;] == 0<br><br>def test_budget_overlap():<br>    score = calculate_budget_match(<br>        600,<br>        800,<br>        500,<br>        900<br>    )<br>    assert score == 50<br><br>def test_invalid_budget():<br>    with pytest.raises(ValueError):<br>        calculate_budget_match(<br>            900,<br>            500,<br>            400,<br>            800<br>        )</pre><p>Run the tests:</p><pre>pytest -v</pre><p>Before turning this into a commercial product, I would test it against historical freelance opportunities and actual outcomes.</p><p>Useful evaluation metrics would include:</p><ul><li>How often highly ranked projects receive replies.</li><li>How often proposals lead to interviews.</li><li>How often interviews become contracts.</li><li>Average project value.</li><li>Time saved per application.</li><li>Performance across different freelance categories.</li></ul><p>A project that looks promising isn’t necessarily a project that will be won.</p><p>The system should learn from actual outcomes rather than pretending that a weighted score is a guaranteed success probability.</p><h3>12. I Found a Product Opportunity Beyond Freelance Proposal Writing</h3><p>At first, I imagined this as a personal productivity tool.</p><p>But the same engine could support a much larger freelance business workflow.</p><p><strong>1. Freelance opportunity intelligence SaaS</strong></p><p>Offer freelancers a dashboard that evaluates projects according to their skills, budget expectations, and availability.</p><p><strong>2. Agency opportunity management</strong></p><p>Help agencies prioritize incoming client requests and identify projects that match their capabilities.</p><p><strong>3. Proposal preparation assistant</strong></p><p>Once an opportunity is selected, generate a customized proposal outline using the client’s requirements and the freelancer’s verified experience.</p><p><strong>4. Freelancer performance analytics</strong></p><p>Track which project categories generate the most interviews, contracts, and revenue.</p><p>A practical first product could include:</p><ul><li>Manual project submission.</li><li>Skill matching.</li><li>Budget analysis.</li><li>Project clarity assessment.</li><li>Risk warnings.</li><li>Opportunity ranking.</li><li>Customized proposal outlines.</li><li>Application outcome tracking.</li></ul><p>One important business consideration is platform compliance. I would initially allow users to paste or upload opportunities themselves, or connect only through officially supported integrations. I wouldn’t build unauthorized scraping or automated application submission into the product.</p><p>The most valuable part of this idea isn’t generating another proposal with AI.</p><p>It’s helping freelancers make a better decision before they spend 45 minutes writing one.</p><p>Because sometimes the biggest improvement in a freelance business doesn’t come from sending more applications. It comes from recognizing which opportunities are worth pursuing in the first place.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33e252e4a74e" width="1" height="1" alt=""><hr><p><a href="https://python.plainenglish.io/i-built-a-python-tool-that-predicts-which-freelance-proposals-are-most-likely-to-win-33e252e4a74e">I Built a Python Tool That Predicts Which Freelance Proposals Are Most Likely to Win</a> was originally published in <a href="https://python.plainenglish.io">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Side Project to Side Income: How Python Quietly Became My Second Paycheck]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/from-side-project-to-side-income-how-python-quietly-became-my-second-paycheck-1df07f70a42b?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/1*QmoNR9fVZGn7nzoDgLLT5Q.png" width="2720"></a></p><p class="medium-feed-snippet">I wasn&#x2019;t trying to build a business. I was trying to stop doing a boring task by hand &#x2014; and somewhere along the way, that habit turned&#x2026;</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/from-side-project-to-side-income-how-python-quietly-became-my-second-paycheck-1df07f70a42b?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/from-side-project-to-side-income-how-python-quietly-became-my-second-paycheck-1df07f70a42b?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/1df07f70a42b</guid>
            <category><![CDATA[side-hustle]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[freelancing]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Mohsin Abro]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 17:04:00 GMT</pubDate>
            <atom:updated>2026-11-17T17:03:59.494Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Day 12 — Arithmetic, Comparisons and Boolean Logic]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/day-12-arithmetic-comparisons-and-boolean-logic-54d6be1c5360?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/1400/1*Q0vDH_D5BSTLspgEYpeM5g.png" width="1400"></a></p><p class="medium-feed-snippet">4 traps in Polars boolean logic, from parentheses to nulls&#x200A;&#x2014;&#x200A;Arithmetic, comparisons, is_between and the three-valued logic nobody warns&#x2026;</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/day-12-arithmetic-comparisons-and-boolean-logic-54d6be1c5360?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/day-12-arithmetic-comparisons-and-boolean-logic-54d6be1c5360?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/54d6be1c5360</guid>
            <category><![CDATA[polars-dataframe]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[100daysofpolars]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[pandas]]></category>
            <dc:creator><![CDATA[Double Espresso Data]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 16:12:22 GMT</pubDate>
            <atom:updated>2026-11-17T04:47:21.471Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[I Used Python and AI to Build Things People Would Actually Pay For]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/i-used-python-and-ai-to-build-things-people-would-actually-pay-for-dd4b8d94d569?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*9f6ooBSKx_mil3rA" width="6000"></a></p><p class="medium-feed-snippet">&#x201C;Want to get started with Python from beginning to Expert?&#x201D; click here&#x201D;</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/i-used-python-and-ai-to-build-things-people-would-actually-pay-for-dd4b8d94d569?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/i-used-python-and-ai-to-build-things-people-would-actually-pay-for-dd4b8d94d569?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/dd4b8d94d569</guid>
            <category><![CDATA[make-money-online]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[money]]></category>
            <dc:creator><![CDATA[Maria Ali]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 15:33:14 GMT</pubDate>
            <atom:updated>2026-11-17T15:33:13.162Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How to Turn Python Scripts Into Sellable Desktop Software]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/how-to-turn-python-scripts-into-sellable-desktop-software-71916183495b?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/1280/1*b7xGASSNK2L7Y7ldvnKPKA.png" width="1280"></a></p><p class="medium-feed-snippet">Package your code, build a clean interface, and create something customers can actually use</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/how-to-turn-python-scripts-into-sellable-desktop-software-71916183495b?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/how-to-turn-python-scripts-into-sellable-desktop-software-71916183495b?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/71916183495b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Hassan Nauman]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 15:15:22 GMT</pubDate>
            <atom:updated>2026-11-17T15:15:21.252Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Day #6 of Learning Python for Machine Learning and Data Science]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/day-6-of-learning-python-for-machine-learning-and-data-science-b987710dbb4d?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*MjNXjkeVyKQs0xe7" width="14467"></a></p><p class="medium-feed-snippet">Loops in Python: How to Make a Program Repeat a Task Without Repeating the Code</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/day-6-of-learning-python-for-machine-learning-and-data-science-b987710dbb4d?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/day-6-of-learning-python-for-machine-learning-and-data-science-b987710dbb4d?source=rss----78073def27b8---4</link>
            <guid isPermaLink="false">https://medium.com/p/b987710dbb4d</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Ekta Soni]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 14:57:29 GMT</pubDate>
            <atom:updated>2026-11-17T14:57:28.004Z</atom:updated>
        </item>
    </channel>
</rss>