pythonlings 0.3.0__py3-none-any.whl

pythonlings/docs/topics/sets.md

@@ -0,0 +1,97 @@
+# Sets
+
+Source: https://docs.python.org/3/tutorial/datastructures.html#sets
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Sets store unique values and support membership tests and set operations.
+
+## Extracted reference
+
+5.4. Sets
+
+Python also includes a data type for sets. A set is
+an unordered collection with no duplicate elements. Basic uses include
+membership testing and eliminating duplicate entries. Set objects also
+support mathematical operations like union, intersection, difference, and
+symmetric difference.
+
+Curly braces or the `set()` function can be used to create sets. Note: to
+create an empty set you have to use `set()`, not `{}`; the latter creates an
+empty dictionary, a data structure that we discuss in the next section.
+
+Because sets are unordered, iterating over them or printing them can
+produce the elements in a different order than you expect.
+
+Here is a brief demonstration:
+
+```python
+>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
+>>> print(basket) # show that duplicates have been removed
+{'orange', 'banana', 'pear', 'apple'}
+>>> 'orange' in basket # fast membership testing
+True
+>>> 'crabgrass' in basket
+False
+
+>>> # Demonstrate set operations on unique letters from two words
+>>>
+>>> a = set('abracadabra')
+>>> b = set('alacazam')
+>>> a # unique letters in a
+{'a', 'r', 'b', 'c', 'd'}
+>>> a - b # letters in a but not in b
+{'r', 'd', 'b'}
+>>> a | b # letters in a or b or both
+{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
+>>> a & b # letters in both a and b
+{'a', 'c'}
+>>> a ^ b # letters in a or b but not both
+{'r', 'd', 'b', 'm', 'z', 'l'}
+
+## More reference
+
+Source: https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset
+
+set and frozenset methods for membership and set relationships.
+
+Set Types — `set`, `frozenset`
+
+A set object is an unordered collection of distinct hashable objects.
+Common uses include membership testing, removing duplicates from a sequence, and
+computing mathematical operations such as intersection, union, difference, and
+symmetric difference.
+(For other containers see the built-in `dict`, `list`,
+and `tuple` classes, and the `collections` module.)
+
+Like other collections, sets support `x in set`, `len(set)`, and `for x in
+set`. Being an unordered collection, sets do not record element position or
+order of insertion. Accordingly, sets do not support indexing, slicing, or
+other sequence-like behavior.
+
+There are currently two built-in set types, `set` and `frozenset`.
+The `set` type is mutable — the contents can be changed using methods
+like `add()` and `remove()`.
+Since it is mutable, it has no hash value and cannot be used as
+either a dictionary key or as an element of another set.
+The `frozenset` type is immutable and hashable —
+its contents cannot be altered after it is created;
+it can therefore be used as a dictionary key or as an element of another set.
+
+Non-empty sets (not frozensets) can be created by placing a comma-separated list
+of elements within braces, for example: `{'jack', 'sjoerd'}`, in addition to the
+`set` constructor.
+
+The constructors for both classes work the same:
+
+class set(iterable=(), /)
+
+class frozenset(iterable=(), /)
+
+Return a new set or frozenset object whose elements are taken from
+iterable. The elements of a set must be hashable. To
+represent sets of sets, the inner sets must be `frozenset`
+objects. If iterable is not specified, a new empty set is
+returned.
+
+Sets can be created by several means:

pythonlings/docs/topics/strings.md

@@ -0,0 +1,96 @@
+# Strings
+
+Source: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Strings are immutable text sequences with indexing, slicing, and many useful methods.
+
+## Extracted reference
+
+Text Sequence Type — `str`
+
+Textual data in Python is handled with `str` objects, or strings.
+Strings are immutable
+sequences of Unicode code points. String literals are
+written in a variety of ways:
+
+-
+
+Single quotes: `'allows embedded "double" quotes'`
+
+-
+
+Double quotes: `"allows embedded 'single' quotes"`
+
+-
+
+Triple quoted: `'''Three single quotes'''`, `"""Three double quotes"""`
+
+Triple quoted strings may span multiple lines - all associated whitespace will
+be included in the string literal.
+
+String literals that are part of a single expression and have only whitespace
+between them will be implicitly converted to a single string literal. That
+is, `("spam " "eggs") == "spam eggs"`.
+
+See String and Bytes literals for more about the various forms of string literal,
+including supported escape sequences, and the `r` (“raw”) prefix that
+disables most escape sequence processing.
+
+Strings may also be created from other objects using the `str`
+constructor.
+
+Since there is no separate “character” type, indexing a string produces
+strings of length 1. That is, for a non-empty string s, `s[0] == s[0:1]`.
+
+There is also no mutable string type, but `str.join()` or
+`io.StringIO` can be used to efficiently construct strings from
+multiple fragments.
+
+## More reference
+
+Source: https://docs.python.org/3/library/stdtypes.html#string-methods
+
+Full reference of string methods with signatures and behaviors.
+
+String Methods
+
+Strings implement all of the common sequence
+operations, along with the additional methods described below.
+
+Strings also support two styles of string formatting, one providing a large
+degree of flexibility and customization (see `str.format()`,
+Format string syntax and Custom string formatting) and the other based on C
+`printf` style formatting that handles a narrower range of types and is
+slightly harder to use correctly, but is often faster for the cases it can
+handle (printf-style String Formatting).
+
+The Text Processing Services section of the standard library covers a number of
+other modules that provide various text related utilities (including regular
+expression support in the `re` module).
+
+str.capitalize()
+
+Return a copy of the string with its first character capitalized and the
+rest lowercased.
+
+Changed in version 3.8: The first character is now put into titlecase rather than uppercase.
+This means that characters like digraphs will only have their first
+letter capitalized, instead of the full character.
+
+str.casefold()
+
+Return a casefolded copy of the string. Casefolded strings may be used for
+caseless matching.
+
+Casefolding is similar to lowercasing but more aggressive because it is
+intended to remove all case distinctions in a string. For example, the German
+lowercase letter `'ß'` is equivalent to `"ss"`. Since it is already
+lowercase, `lower()` would do nothing to `'ß'`; `casefold()`
+converts it to `"ss"`.
+For example:
+
+```python
+>>> 'straße'.lower()
+'straße'

pythonlings/docs/topics/testing.md

@@ -0,0 +1,97 @@
+# Testing
+
+Source: https://docs.python.org/3/library/unittest.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Tests encode expected behavior so code can be checked repeatedly.
+
+## Extracted reference
+
+unittest — Unit testing framework — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Standard Library »
+
+- Development Tools »
+
+- `unittest` — Unit testing framework
+
+-
+
+|
+
+-
+
+Theme
+
+## More reference
+
+Source: https://docs.python.org/3/library/doctest.html#how-it-works
+
+How doctest finds and runs examples embedded in docstrings.
+
+How It Works
+
+This section examines in detail how doctest works: which docstrings it looks at,
+how it finds interactive examples, what execution context it uses, how it
+handles exceptions, and how option flags can be used to control its behavior.
+This is the information that you need to know to write doctest examples; for
+information about actually running doctest on these examples, see the following
+sections.
+
+Which Docstrings Are Examined?
+
+The module docstring, and all function, class and method docstrings are
+searched. Objects imported into the module are not searched.
+
+In addition, there are cases when you want tests to be part of a module but not part
+of the help text, which requires that the tests not be included in the docstring.
+Doctest looks for a module-level variable called `__test__` and uses it to locate other
+tests. If `M.__test__` exists, it must be a dict, and each
+entry maps a (string) name to a function object, class object, or string.
+Function and class object docstrings found from `M.__test__` are searched, and
+strings are treated as if they were docstrings. In output, a key `K` in
+`M.__test__` appears with name `M.__test__.K`.
+
+For example, place this block of code at the top of `example.py`:
+
+```python
+__test__ = {
+'numbers': """
+>>> factorial(6)
+720
+
+>>> [factorial(n) for n in range(6)]
+[1, 1, 2, 6, 24, 120]
+"""
+}
+
+```
+
+The value of `example.__test__["numbers"]` will be treated as a
+docstring and all the tests inside it will be run. It is

pythonlings/docs/topics/tuples.md

@@ -0,0 +1,97 @@
+# Tuples
+
+Source: https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Tuples group ordered values and are commonly unpacked into multiple names.
+
+## Extracted reference
+
+5.3. Tuples and Sequences
+
+We saw that lists and strings have many common properties, such as indexing and
+slicing operations. They are two examples of sequence data types (see
+Sequence Types — list, tuple, range). Since Python is an evolving language, other sequence data
+types may be added. There is also another standard sequence data type: the
+tuple.
+
+A tuple consists of a number of values separated by commas, for instance:
+
+```python
+>>> t = 12345, 54321, 'hello!'
+>>> t[0]
+12345
+>>> t
+(12345, 54321, 'hello!')
+>>> # Tuples may be nested:
+>>> u = t, (1, 2, 3, 4, 5)
+>>> u
+((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
+>>> # Tuples are immutable:
+>>> t[0] = 88888
+Traceback (most recent call last):
+File "<stdin>", line 1, in <module>
+TypeError: 'tuple' object does not support item assignment
+>>> # but they can contain mutable objects:
+>>> v = ([1, 2, 3], [3, 2, 1])
+>>> v
+([1, 2, 3], [3, 2, 1])
+
+```
+
+As you see, on output tuples are always enclosed in parentheses, so that nested
+tuples are interpreted correctly; they may be input with or without surrounding
+parentheses, although often parentheses are necessary anyway (if the tuple is
+part of a larger expression). It is not possible to assign to the individual
+items of a tuple, however it is possible to create tuples which contain mutable
+objects, such as lists.
+
+Though tuples may seem similar to lists, they are often used in different
+
+## More reference
+
+Source: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
+
+Operations shared by all sequence types: indexing, slicing, concatenation.
+
+Common Sequence Operations
+
+The operations in the following table are supported by most sequence types,
+both mutable and immutable. The `collections.abc.Sequence` ABC is
+provided to make it easier to correctly implement these operations on
+custom sequence types.
+
+This table lists the sequence operations sorted in ascending priority. In the
+table, s and t are sequences of the same type, n, i, j and k are
+integers and x is an arbitrary object that meets any type and value
+restrictions imposed by s.
+
+The `in` and `not in` operations have the same priorities as the
+comparison operations. The `+` (concatenation) and `*` (repetition)
+operations have the same priority as the corresponding numeric operations. [3]
+
+Operation
+
+Result
+
+Notes
+
+`x in s`
+
+`True` if an item of s is
+equal to x, else `False`
+
+(1)
+
+`x not in s`
+
+`False` if an item of s is
+equal to x, else `True`
+
+(1)
+
+`s + t`
+
+the concatenation of s and
+t

pythonlings/docs/topics/type_hints.md

@@ -0,0 +1,97 @@
+# Type Hints
+
+Source: https://docs.python.org/3/library/typing.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Type hints annotate expected values and help tools reason about your code.
+
+## Extracted reference
+
+typing — Support for type hints — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Standard Library »
+
+- Development Tools »
+
+- `typing` — Support for type hints
+
+-
+
+|
+
+-
+
+Theme
+
+## More reference
+
+Source: https://docs.python.org/3/reference/datamodel.html#annotations
+
+How annotations are stored in `__annotations__`.
+
+3.3.12. Annotations
+
+Functions, classes, and modules may contain annotations,
+which are a way to associate information (usually type hints)
+with a symbol.
+
+object.__annotations__
+
+This attribute contains the annotations for an object. It is
+lazily evaluated, so accessing the attribute may
+execute arbitrary code and raise exceptions. If evaluation is successful, the
+attribute is set to a dictionary mapping from variable names to annotations.
+
+Changed in version 3.14: Annotations are now lazily evaluated.
+
+object.__annotate__(format)
+
+An annotate function.
+Returns a new dictionary object mapping attribute/parameter names to their annotation values.
+
+Takes a format parameter specifying the format in which annotations values should be provided.
+It must be a member of the `annotationlib.Format` enum, or an integer with
+a value corresponding to a member of the enum.
+
+If an annotate function doesn’t support the requested format, it must raise
+`NotImplementedError`. Annotate functions must always support
+`VALUE` format; they must not raise
+`NotImplementedError()` when called with this format.
+
+When called with `VALUE` format, an annotate function may raise
+`NameError`; it must not raise `NameError` when called requesting any other format.
+
+If an object does not have any annotations, `__annotate__` should preferably be set
+to `None` (it can’t be deleted), rather than set to a function that returns an empty dict.
+
+Added in version 3.14.
+
+See also
+
+PEP 649 — Deferred evaluation of annotation using descriptors

pythonlings/docs/topics/variables.md

@@ -0,0 +1,97 @@
+# Variables
+
+Source: https://docs.python.org/3/tutorial/introduction.html#using-python-as-a-calculator
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Assigning names with `=` lets you keep values for later expressions.
+
+## Extracted reference
+
+3.1. Using Python as a Calculator
+
+Let’s try some simple Python commands. Start the interpreter and wait for the
+primary prompt, `>>>`. (It shouldn’t take long.)
+
+3.1.1. Numbers
+
+The interpreter acts as a simple calculator: you can type an expression into it
+and it will write the value. Expression syntax is straightforward: the
+operators `+`, `-`, `*` and `/` can be used to perform
+arithmetic; parentheses (`()`) can be used for grouping.
+For example:
+
+```python
+>>> 2 + 2
+4
+>>> 50 - 5*6
+20
+>>> (50 - 5*6) / 4
+5.0
+>>> 8 / 5 # division always returns a floating-point number
+1.6
+
+```
+
+The integer numbers (e.g. `2`, `4`, `20`) have type `int`,
+the ones with a fractional part (e.g. `5.0`, `1.6`) have type
+`float`. We will see more about numeric types later in the tutorial.
+
+Division (`/`) always returns a float. To do floor division and
+get an integer result you can use the `//` operator; to calculate
+the remainder you can use `%`:
+
+```python
+>>> 17 / 3 # classic division returns a float
+5.666666666666667
+>>>
+>>> 17 // 3 # floor division discards the fractional part
+5
+>>> 17 % 3 # the % operator returns the remainder of the division
+
+## More reference
+
+Source: https://docs.python.org/3/reference/simple_stmts.html#assignment-statements
+
+Assignment statement syntax and semantics, including multiple and unpacking targets.
+
+7.2. Assignment statements
+
+Assignment statements are used to (re)bind names to values and to modify
+attributes or items of mutable objects:
+
+```python
+
+assignment_stmt: (target_list "=")+ (starred_expression | yield_expression)
+target_list: target ("," target)* [","]
+target: identifier
+| "(" [target_list] ")"
+| "[" [target_list] "]"
+| attributeref
+| subscription
+| "*" target
+
+```
+
+(See section Primaries for the syntax definitions for attributeref
+and subscription.)
+
+An assignment statement evaluates the expression list (remember that this can be
+a single expression or a comma-separated list, the latter yielding a tuple) and
+assigns the single resulting object to each of the target lists, from left to
+right.
+
+Assignment is defined recursively depending on the form of the target (list).
+When a target is part of a mutable object (an attribute reference or
+subscription), the mutable object must ultimately perform the assignment and
+decide about its validity, and may raise an exception if the assignment is
+unacceptable. The rules observed by various types and the exceptions raised are
+given with the definition of the object types (see section The standard type hierarchy).
+
+Assignment of an object to a target list, optionally enclosed in parentheses or
+square brackets, is recursively defined as follows.
+
+-
+
+If the target list is a single target with no trailing comma,
+optionally in parentheses, the object is assigned to that target.

pythonlings/pythonlings.tcss

@@ -0,0 +1,123 @@
+Screen {
+    layout: vertical;
+}
+
+#progress {
+    height: 1;
+    background: $primary 30%;
+    color: $text;
+    padding: 0 1;
+}
+
+#main {
+    layout: horizontal;
+    height: 1fr;
+}
+
+#tree {
+    width: 25%;
+    border-right: solid $primary;
+    padding: 1;
+    display: none;
+}
+
+#editor {
+    width: 1fr;
+    border-right: solid $primary;
+}
+
+#editor #code {
+    height: 1fr;
+}
+
+#output {
+    width: 1fr;
+    padding: 1;
+}
+
+#output-header {
+    padding: 0 0 1 0;
+    border-bottom: solid $primary;
+    color: $text;
+}
+
+#output-body,
+#goal,
+#docs,
+#status,
+#next-step,
+#details {
+    padding: 1 0 0 0;
+}
+
+#output.passed {
+    background: $success 20%;
+}
+
+#output.failed {
+    background: $error 20%;
+}
+
+#output.pending {
+    background: $warning 20%;
+}
+
+#hint {
+    border-top: dashed $secondary;
+    padding: 1 0;
+    display: none;
+}
+
+#hint.visible {
+    display: block;
+}
+
+TopicPickerScreen #topics {
+    padding: 1 2;
+}
+
+#topic-banner {
+    height: auto;
+    padding: 1 2;
+    background: $primary 20%;
+    color: $text;
+    border-bottom: solid $primary;
+}
+
+.topic-row {
+    padding: 0 1;
+}
+
+DocsScreen {
+    align: center middle;
+}
+
+#docs-window {
+    width: 72%;
+    max-width: 80;
+    height: 70%;
+    max-height: 28;
+    min-height: 14;
+    padding: 1 2;
+    border: heavy $primary;
+    background: $surface;
+    color: $text;
+}
+
+#docs-title {
+    height: 1;
+}
+
+#docs-scroll {
+    height: 1fr;
+    margin: 1 0;
+}
+
+#docs-content {
+    width: 100%;
+}
+
+#docs-footer {
+    height: 1;
+    color: $text;
+}