pythonlings 0.3.0__py3-none-any.whl

pythonlings/curriculum/solutions/type_hints5.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/type_hints6.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/type_hints7.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/type_hints8.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables1.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables10.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables2.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables3.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables4.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables5.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables6.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables7.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables8.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/curriculum/solutions/variables9.py

@@ -0,0 +1,2 @@
+from solutions._answers import apply
+apply(__file__, globals())

pythonlings/docs/NOTICE.md

@@ -0,0 +1,9 @@
+# Bundled Python Documentation Snippets
+
+These snippets are generated from the official Python documentation at
+https://docs.python.org/3/ and trimmed for use inside pythonlings.
+
+Python documentation pages are licensed under the Python Software
+Foundation License Version 2. Examples, recipes, and other code in the
+documentation are additionally licensed under the Zero Clause BSD License.
+See https://docs.python.org/3/copyright.html for details.

pythonlings/docs/__init__.py

@@ -0,0 +1 @@
+"""Bundled local Python documentation snippets."""

pythonlings/docs/index.json

@@ -0,0 +1,160 @@
+{
+  "generated_from": "https://docs.python.org/3/",
+  "topics": {
+    "async": {
+      "file": "topics/async.md",
+      "source_url": "https://docs.python.org/3/library/asyncio.html",
+      "title": "Asyncio"
+    },
+    "classes": {
+      "file": "topics/classes.md",
+      "source_url": "https://docs.python.org/3/tutorial/classes.html#a-first-look-at-classes",
+      "title": "Classes"
+    },
+    "collections": {
+      "file": "topics/collections.md",
+      "source_url": "https://docs.python.org/3/library/collections.html",
+      "title": "Collections"
+    },
+    "comprehensions": {
+      "file": "topics/comprehensions.md",
+      "source_url": "https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions",
+      "title": "Comprehensions"
+    },
+    "conditionals": {
+      "file": "topics/conditionals.md",
+      "source_url": "https://docs.python.org/3/tutorial/controlflow.html#if-statements",
+      "title": "Conditionals"
+    },
+    "context_managers": {
+      "file": "topics/context_managers.md",
+      "source_url": "https://docs.python.org/3/reference/compound_stmts.html#the-with-statement",
+      "title": "Context Managers"
+    },
+    "dataclasses": {
+      "file": "topics/dataclasses.md",
+      "source_url": "https://docs.python.org/3/library/dataclasses.html",
+      "title": "Dataclasses"
+    },
+    "datetime": {
+      "file": "topics/datetime.md",
+      "source_url": "https://docs.python.org/3/library/datetime.html",
+      "title": "Datetime"
+    },
+    "decorators": {
+      "file": "topics/decorators.md",
+      "source_url": "https://docs.python.org/3/reference/compound_stmts.html#function-definitions",
+      "title": "Decorators"
+    },
+    "dictionaries": {
+      "file": "topics/dictionaries.md",
+      "source_url": "https://docs.python.org/3/tutorial/datastructures.html#dictionaries",
+      "title": "Dictionaries"
+    },
+    "enums": {
+      "file": "topics/enums.md",
+      "source_url": "https://docs.python.org/3/library/enum.html",
+      "title": "Enums"
+    },
+    "exceptions": {
+      "file": "topics/exceptions.md",
+      "source_url": "https://docs.python.org/3/tutorial/errors.html#handling-exceptions",
+      "title": "Exceptions"
+    },
+    "file_io": {
+      "file": "topics/file_io.md",
+      "source_url": "https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files",
+      "title": "File I/O"
+    },
+    "functional": {
+      "file": "topics/functional.md",
+      "source_url": "https://docs.python.org/3/howto/functional.html",
+      "title": "Functional Tools"
+    },
+    "functions": {
+      "file": "topics/functions.md",
+      "source_url": "https://docs.python.org/3/tutorial/controlflow.html#defining-functions",
+      "title": "Functions"
+    },
+    "generators": {
+      "file": "topics/generators.md",
+      "source_url": "https://docs.python.org/3/tutorial/classes.html#generators",
+      "title": "Generators"
+    },
+    "itertools": {
+      "file": "topics/itertools.md",
+      "source_url": "https://docs.python.org/3/library/itertools.html",
+      "title": "Itertools"
+    },
+    "json": {
+      "file": "topics/json.md",
+      "source_url": "https://docs.python.org/3/library/json.html",
+      "title": "JSON"
+    },
+    "lists": {
+      "file": "topics/lists.md",
+      "source_url": "https://docs.python.org/3/tutorial/datastructures.html#more-on-lists",
+      "title": "Lists"
+    },
+    "loops": {
+      "file": "topics/loops.md",
+      "source_url": "https://docs.python.org/3/tutorial/controlflow.html#for-statements",
+      "title": "Loops"
+    },
+    "modules": {
+      "file": "topics/modules.md",
+      "source_url": "https://docs.python.org/3/tutorial/modules.html#modules",
+      "title": "Modules"
+    },
+    "oop_advanced": {
+      "file": "topics/oop_advanced.md",
+      "source_url": "https://docs.python.org/3/tutorial/classes.html",
+      "title": "Advanced OOP"
+    },
+    "pathlib": {
+      "file": "topics/pathlib.md",
+      "source_url": "https://docs.python.org/3/library/pathlib.html",
+      "title": "Pathlib"
+    },
+    "recursion": {
+      "file": "topics/recursion.md",
+      "source_url": "https://docs.python.org/3/tutorial/controlflow.html#defining-functions",
+      "title": "Recursion"
+    },
+    "regex": {
+      "file": "topics/regex.md",
+      "source_url": "https://docs.python.org/3/library/re.html",
+      "title": "Regular Expressions"
+    },
+    "sets": {
+      "file": "topics/sets.md",
+      "source_url": "https://docs.python.org/3/tutorial/datastructures.html#sets",
+      "title": "Sets"
+    },
+    "strings": {
+      "file": "topics/strings.md",
+      "source_url": "https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str",
+      "title": "Strings"
+    },
+    "testing": {
+      "file": "topics/testing.md",
+      "source_url": "https://docs.python.org/3/library/unittest.html",
+      "title": "Testing"
+    },
+    "tuples": {
+      "file": "topics/tuples.md",
+      "source_url": "https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences",
+      "title": "Tuples"
+    },
+    "type_hints": {
+      "file": "topics/type_hints.md",
+      "source_url": "https://docs.python.org/3/library/typing.html",
+      "title": "Type Hints"
+    },
+    "variables": {
+      "file": "topics/variables.md",
+      "source_url": "https://docs.python.org/3/tutorial/introduction.html#using-python-as-a-calculator",
+      "title": "Variables"
+    }
+  }
+}

pythonlings/docs/topics/__init__.py

@@ -0,0 +1 @@
+"""Topic snippets generated from official Python documentation."""

pythonlings/docs/topics/async.md

@@ -0,0 +1,97 @@
+# Asyncio
+
+Source: https://docs.python.org/3/library/asyncio.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`asyncio` runs concurrent I/O-bound work with coroutines and an event loop.
+
+## Extracted reference
+
+asyncio — Asynchronous I/O — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Standard Library »
+
+- Networking and Interprocess Communication »
+
+- `asyncio` — Asynchronous I/O
+
+-
+
+|
+
+-
+
+Theme
+
+## More reference
+
+Source: https://docs.python.org/3/library/asyncio-task.html#coroutines
+
+Coroutines and `async`/`await` with execution examples.
+
+Coroutines
+
+Source code: Lib/asyncio/coroutines.py
+
+Coroutines declared with the async/await syntax is the
+preferred way of writing asyncio applications. For example, the following
+snippet of code prints “hello”, waits 1 second,
+and then prints “world”:
+
+```python
+>>> import asyncio
+
+>>> async def main():
+... print('hello')
+... await asyncio.sleep(1)
+... print('world')
+
+>>> asyncio.run(main())
+hello
+world
+
+```
+
+Note that simply calling a coroutine will not schedule it to
+be executed:
+
+```python
+>>> main()
+<coroutine object main at 0x1053bb7c8>
+
+```
+
+To actually run a coroutine, asyncio provides the following mechanisms:
+
+-
+
+The `asyncio.run()` function to run the top-level
+entry point “main()” function (see the above example.)
+
+-

pythonlings/docs/topics/classes.md

@@ -0,0 +1,97 @@
+# Classes
+
+Source: https://docs.python.org/3/tutorial/classes.html#a-first-look-at-classes
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Classes combine data and behavior into reusable types.
+
+## Extracted reference
+
+9.3. A First Look at Classes
+
+Classes introduce a little bit of new syntax, three new object types, and some
+new semantics.
+
+9.3.1. Class Definition Syntax
+
+The simplest form of class definition looks like this:
+
+```python
+class ClassName:
+<statement-1>
+.
+.
+.
+<statement-N>
+
+```
+
+Class definitions, like function definitions (`def` statements) must be
+executed before they have any effect. (You could conceivably place a class
+definition in a branch of an `if` statement, or inside a function.)
+
+In practice, the statements inside a class definition will usually be function
+definitions, but other statements are allowed, and sometimes useful — we’ll
+come back to this later. The function definitions inside a class normally have
+a peculiar form of argument list, dictated by the calling conventions for
+methods — again, this is explained later.
+
+When a class definition is entered, a new namespace is created, and used as the
+local scope — thus, all assignments to local variables go into this new
+namespace. In particular, function definitions bind the name of the new
+function here.
+
+When a class definition is left normally (via the end), a class object is
+created. This is basically a wrapper around the contents of the namespace
+created by the class definition; we’ll learn more about class objects in the
+next section. The original local scope (the one in effect just before the class
+definition was entered) is reinstated, and the class object is bound here to the
+class name given in the class definition header (`ClassName` in the
+
+## More reference
+
+Source: https://docs.python.org/3/reference/datamodel.html#special-method-names
+
+Special methods like `__init__`, `__str__`, and `__repr__`.
+
+3.3. Special method names
+
+A class can implement certain operations that are invoked by special syntax
+(such as arithmetic operations or subscripting and slicing) by defining methods
+with special names. This is Python’s approach to operator overloading,
+allowing classes to define their own behavior with respect to language
+operators. For instance, if a class defines a method named
+`__getitem__()`,
+and `x` is an instance of this class, then `x[i]` is roughly equivalent
+to `type(x).__getitem__(x, i)`. Except where mentioned, attempts to execute an
+operation raise an exception when no appropriate method is defined (typically
+`AttributeError` or `TypeError`).
+
+Setting a special method to `None` indicates that the corresponding
+operation is not available. For example, if a class sets
+`__iter__()` to `None`, the class is not iterable, so calling
+`iter()` on its instances will raise a `TypeError` (without
+falling back to `__getitem__()`). [2]
+
+When implementing a class that emulates any built-in type, it is important that
+the emulation only be implemented to the degree that it makes sense for the
+object being modelled. For example, some sequences may work well with retrieval
+of individual elements, but extracting a slice may not make sense.
+(One example of this is the NodeList interface
+in the W3C’s Document Object Model.)
+
+3.3.1. Basic customization
+
+object.__new__(cls[, ...])
+
+Called to create a new instance of class cls. `__new__()` is a static
+method (special-cased so you need not declare it as such) that takes the class
+of which an instance was requested as its first argument. The remaining
+arguments are those passed to the object constructor expression (the call to the
+class). The return value of `__new__()` should be the new object instance
+(usually an instance of cls).
+
+Typical implementations create a new instance of the class by invoking the
+superclass’s `__new__()` method using `super().__new__(cls[, ...])`
+with appropriate arguments and then modifying the newly created instance

pythonlings/docs/topics/collections.md

@@ -0,0 +1,96 @@
+# Collections
+
+Source: https://docs.python.org/3/library/collections.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`collections` provides specialized containers beyond the built-in list, dict, set, and tuple.
+
+## Extracted reference
+
+collections — Container datatypes — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Standard Library »
+
+- Data Types »
+
+- `collections` — Container datatypes
+
+-
+
+|
+
+-
+
+Theme
+
+## More reference
+
+Source: https://docs.python.org/3/library/collections.html#collections.Counter
+
+`Counter` tallies hashable objects and finds the most common ones.
+
+class collections.Counter(**kwargs)
+
+class collections.Counter(iterable, /, **kwargs)
+
+class collections.Counter(mapping, /, **kwargs)
+
+A `Counter` is a `dict` subclass for counting hashable objects.
+It is a collection where elements are stored as dictionary keys
+and their counts are stored as dictionary values. Counts are allowed to be
+any integer value including zero or negative counts. The `Counter`
+class is similar to bags or multisets in other languages.
+
+Elements are counted from an iterable or initialized from another
+mapping (or counter):
+
+```python
+>>> c = Counter() # a new, empty counter
+>>> c = Counter('gallahad') # a new counter from an iterable
+>>> c = Counter({'red': 4, 'blue': 2}) # a new counter from a mapping
+>>> c = Counter(cats=4, dogs=8) # a new counter from keyword args
+
+```
+
+Counter objects have a dictionary interface except that they return a zero
+count for missing items instead of raising a `KeyError`:
+
+```python
+>>> c = Counter(['eggs', 'ham'])
+>>> c['bacon'] # count of a missing element is zero
+0
+
+```
+
+Setting a count to zero does not remove an element from a counter.
+Use `del` to remove it entirely:
+
+```python
+>>> c['sausage'] = 0 # counter entry with a zero count
+>>> del c['sausage'] # del actually removes the entry

pythonlings/docs/topics/comprehensions.md

@@ -0,0 +1,97 @@
+# Comprehensions
+
+Source: https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Comprehensions build new collections by combining an expression with one or more loops.
+
+## Extracted reference
+
+5.1.3. List Comprehensions
+
+List comprehensions provide a concise way to create lists.
+Common applications are to make new lists where each element is the result of
+some operations applied to each member of another sequence or iterable, or to
+create a subsequence of those elements that satisfy a certain condition.
+
+For example, assume we want to create a list of squares, like:
+
+```python
+>>> squares = []
+>>> for x in range(10):
+... squares.append(x**2)
+...
+>>> squares
+[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+```
+
+Note that this creates (or overwrites) a variable named `x` that still exists
+after the loop completes. We can calculate the list of squares without any
+side effects using:
+
+```python
+squares = list(map(lambda x: x**2, range(10)))
+
+```
+
+or, equivalently:
+
+```python
+squares = [x**2 for x in range(10)]
+
+```
+
+which is more concise and readable.
+
+A list comprehension consists of brackets containing an expression followed
+by a `for` clause, then zero or more `for` or `if`
+clauses. The result will be a new list resulting from evaluating the expression
+
+## More reference
+
+Source: https://docs.python.org/3/tutorial/datastructures.html#nested-list-comprehensions
+
+Nested comprehensions that build lists of lists from multiple loops.
+
+5.1.4. Nested List Comprehensions
+
+The initial expression in a list comprehension can be any arbitrary expression,
+including another list comprehension.
+
+Consider the following example of a 3x4 matrix implemented as a list of
+3 lists of length 4:
+
+```python
+>>> matrix = [
+... [1, 2, 3, 4],
+... [5, 6, 7, 8],
+... [9, 10, 11, 12],
+... ]
+
+```
+
+The following list comprehension will transpose rows and columns:
+
+```python
+>>> [[row[i] for row in matrix] for i in range(4)]
+[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
+
+```
+
+As we saw in the previous section, the inner list comprehension is evaluated in
+the context of the `for` that follows it, so this example is
+equivalent to:
+
+```python
+>>> transposed = []
+>>> for i in range(4):
+... transposed.append([row[i] for row in matrix])
+...
+>>> transposed
+[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
+
+```
+
+which, in turn, is the same as: