Comments by "Lawrence D’Oliveiro" (@lawrencedoliveiro9104) on "ArjanCodes" channel.

  1. 15:13 You could leave out both the “await” and the “async”. So “send‗async‗request” becomes a regular function which returns an awaitable.
    33
  2. ORMs don’t make any sense to me. The code doesn’t end up any simpler.
    11
  3. “Machine” does not have to mean “hardware”. For example, bytecode interpreters are commonly called “virtual machines” nowadays.
    10
  4. I started my career back in the early Apple Macintosh days. Back then, there was this document called the “User Interface Guidelines”, which carefully spelled out concepts like “interface stability” and “progressive disclosure” and feedback to confirm user actions. We were taught to care about actual user-interface testing, rather than just assuming that what we were doing would be “intuitive” to the user. But increasingly, I found that app vendors didn’t bother following these rules. And even Apple itself seemed to be moving away from them. Nowadays, it all seems to be about looks and following fashionable “design trends”. Hence the move away from the “3D” look to the “flat” look, which may be going back to “3D” now. Or what about this “dark theme” fad? What happened to usability testing? Seems nobody even bothers with that any more.
    8
  5. Another thing is, there are no language-independent ORMs. I do some stuff in PHP also, so I have to learn SQL anyway, I might as well do it properly.
    8
  6. 6:16 Just a note that splitting things out into separate files will slow down loading, compared to having it all in the same file.
    6
  7. An alternative way is to have the argument default to None. The function checks for this value, and replaces it with the current time (or other dynamically-computed value, as appropriate).
    6
  8. 12:35 But you could replace it with a docstring. Which could be dynamically generated, to incorporate the actual limit, and assigned to the ＿＿doc＿＿ property of the function object being returned.
    5
  9. 6:24 The argument is called “discount_perc”, but its interpretation is as a fraction, not as a percentage. I would say that is bad.
    5
  10. I think with nearly any GUI app, if it becomes really useful, then somebody will want to automate tasks with it. This is a good argument for separating the GUI frontend from the backend engine. So then you can invoke the backend via some kind of script or CLI, independent of the GUI. In fact, you could start your new app by writing it as CLI-only, and adding a GUI later.
    5
  11.  @ER-oj8mo  I have written seven-way joins in SQL. I don’t use triggers; all the business logic is in the application code, and anything repetitive can be put in a suitable function or class. That gives me much more power than SQL itself. Like being able to dynamically include/exclude fields/tables in a query.
    4
  12. Nothing specific to asyncio there.
    4
  13. 8:50 Properties are useful for wrapping getter/setter functions when you are creating a Python wrapper around an external C library using ctypes.
    4
  14. 2:04 I don’t have a problem with from-imports. If you search for “my_function”, eventually you will have to encounter either an actual definition or an import. That’s what your editor’s search function is for.
    4
  15. This is why we rely on the Olson zoneinfo database to manage all those headaches for us. Use standard library routines and let them worry about it.
    3
  16. If you have read/write properties on a class, specifying slots is a very good idea.
    3
  17. People seem to be very afraid of the various forms of injection attacks. In fact, they are quite easy to avoid.
    3
  18. 22:38 You shouldn’t have bothered with functools.partial. Just do with_default_logging = with_logging(logger)
    3
  19. 8:02 DBMSes themselves usually provide some kind of introspection facilities, though this varies a lot. For example, SQLite provides enough information that you should be able to programmatically derive the entire database schema without having to parse actual SQL, while MySQL/MariaDB is a bit more limited. The question is: do ORMs make use of this? Doesn’t seem like it.
    3
  20. I have used operator functions with functools.reduce(). Fun fact: reduce() was a built-in function in Python 2, demoted to being part of the functools module in Python 3.
    3
  21. 1:16 Unquoted brackets!
    2
  22. People think Emacs is old, but they forget that it was built by a whole bunch of smart hackers who lived and breathed coding, knew what they were doing, and were not beholden to marketing managers at any company. For example, they used an advanced programming language (LISP), which can still scare the pants off the Java/C♯/PHP crowd today. Does the automation language in your favourite editor understand closures and lexical binding? (Interestingly, the sort of concepts discussed in this very video.)
    2
  23. I would include an exception traceback as part of “some response our customer can send us”. Your subsystem writes logfiles, doesn’t it? Any exception crash should end up in there; tell them to send those.
    2
  24. 12:51 Yeah, but starting daylight saving is the easy transition to handle; what about ending daylight saving, when 3 a.m. occurs twice?
    2
  25. 7:38 As soon as you said it uses subclassing, I immediately thought “there must be a metaclass involved”. Had a look at the source code, and yes, that is how it works.
    2
  26. I notice you only talked about function decorators, not class decorators. They have their uses, too. I think the most extensive use I have made of custom decorators so far has been in my DBussy package, a pure-Python wrapper for libdbus. The information defining the D-Bus interface to a Python class is specified via a function decorator on each Python method implementing a D-Bus interface method, with a class decorator to tie it all together. Then when you register your class to receive messages, the dispatch mechanism knows how to decode incoming D-Bus method calls, convert the arguments and dispatch to the appropriate Python method. As a bonus, this same information is used to automatically generate the D-Bus XML introspection format, when another D-Bus peer sends you the introspection message. And conversely, when you introspect another D-Bus peer, this info is used to dynamically generate a “proxy interface class” -- a Python class whose methods simply send the appropriate D-Bus messages and return the responses.
    2
  27.  @kurt7020  Here’s a function which works in all cases: def sql_string_list(the_list) : "returns a list containing the quoted items of the_list, suitable" \ " for use in an “in” clause⋅" return \ "(" + ", "⋅join([sql_string(s) for s in the_list]) + ")" ♯end sql_string_list Another situation is: what about LIKE clauses?
    2
  28. A common use of a LIKE clause is to allow partial matches on user input, by bracketing it with “%” wildcard symbols. But consider, you want whatever the user types to be matched exactly, even if it happens to contain wildcard symbols.
    2
  29. 9:43 Still, it could be worse: it could be Java. I was doing some date/time conversions in an Android app some years ago, and it took me a while to realize that while every single method in a class might be deprecated, the class itself was still required elsewhere!
    2
  30. Perspective foreshortening, aka 1990s music video styleeee ...
    2
  31.  @christoferberruzchungata2722  It’s already a large chunk of the code in a single function. Splitting it off doesn’t seem very helpful, when the error message is already supposed to explain what the check is trying to achieve.
    2
  32. I don’t think there’s such a thing as “NoSQL” any more. Even the non-relational DBMSes are adopting forms of SQL for their query languages.
    2
  33. 12:50 I deal with that in one of two ways: * For some projects, there will be a schema file containing the requisite CREATE TABLE statements, included in the source tree and version-controlled along with everything else. * For other projects, particularly ones using SQLite, the program itself will automatically create the necessary tables each time it is asked to create a new database, so the CREATE TABLE statements will be in the program source code.
    2
  34.  @leftblank5315  Precisely. If you are after a “seamless” experience, then you have to avoid Windows.
    2
  35. I used islice() in a presentation I was giving on continued fractions. This was because I couldn’t be bothered putting a termination condition in the generator functions that were producing the coefficients, so islice() had the job of cutting an infinite series down to a finite length.
    2
  36. It can also help prevent typos.
    2
  37. Travelling faster than light inevitably leads to time travel.
    2
  38. It would be nice to make parts of the plumbing more declarative. For example, I share Arjan’s distaste for carrying around large amounts of XML. Why not define a Pythonic representation for that XML info? This is what I did in DBussy, my pure-Python wrapper for libdbus.
    2
  39. 4:07 Why not use the Decimal type?
    2
  40. Callable objects seem useful where you have a lot of state to hold. And perhaps you want to provide additional caller-visible methods to manage that state. Otherwise it would be simpler to use a closure.
    2
  41. You notice that Python effectively already has full generics, since function objects and class objects are constructed at runtime?
    1
  42.  @RitchieDiamond  Did you try assigning a suitably unique ＿name＿ to your lambda, to see if that helped with pickling? Presumably the problem is that pickling doesn’t actually include the code of the function, just some way to tie the recreation of the function object back to the original program code -- which almost certainly means the function name.
    1
  43. How about something as simple as mask = qah.ImageSurface.create \ ( format = CAIRO.FORMAT_A8, dimensions = resolution * raster_frac.denominator ) because I can never remember whether the format arg comes first, or the dimensions?
    1
  44. Just make sure your zoneinfo is up to date. Changes happen several times a year.
    1
  45. For long function/method calls, put the arguments one to a line, and give the whole expression a two-dimensional layout, e .g.:     aqsis_output = ReasonablePerms.subprocess.check_output \       (         args = ["aqsis"] + extra + [self._filename],         stdin = subprocess.DEVNULL,         stderr = subprocess.STDOUT,         universal_newlines = True,         cwd = self._parent._workdir,         timeout = self._parent.timeout       )
    1
  46. 4:50 Sounds like defining key fields in a database record.
    1
  47. 2:55 Have you looked at apsw? I prefer that to the standard Python sqlite module.
    1
  48. async-for needs the additional ‗‗aiter‗‗ mechanism in order to work, ‗‗await‗‗ on its own isn’t enough. I haven’t found async-for to be all that useful. So far, anyway.
    1
  49.  @ArjanCodes  That could be done if you could define your own custom operators, like “=>”.
    1
  50.  @Gnaritas42  Let’s compare actual code, then. Here’s the level-break example I posted in another comment: out․write("<TABLE>\n") out․write("<TR><TH>Planet<∕TH><TH>Moon<∕TH><∕TR>\n") items_iter = db_iter \ ( db, "select planets․name, moons․name" " from planets left join moons on planets․id = moons․parent" " order by planets․name, moons․name" ) cur_planet = None while True ∶ item = next(items_iter, None) if item == None or cur_planet != None and item[0] != cur_planet ∶ if cur_planet != None ∶ out․write \ ( "<TR><TD><I>Count∶<∕I><∕TD><TD>%d<∕TD><∕TR>\n" % count ) cur_planet = None ♯end if if item == None ∶ break ♯end if out․write("<TR><TD>") if cur_planet == None ∶ ♯ first moon for next planet cur_planet = item[0] count = 0 out․write("<B>" + html․escape(item[0]) + "<∕B>") else ∶ ♯ second or subsequent moon, don’t repeat planet name out․write(" ") ♯end if out․write("<∕TD><TD>") if item[1] != None ∶ ♯ there is a moon out․write(html․escape(item[1])) count += 1 else ∶ ♯ that’s no moon out․write("<I>(none)<∕I>") ♯end if out․write("<∕TD><∕TR>\n") ♯end while out․write("<∕TABLE>\n") Show us how an ORM will make that simpler.
    1
  51. Let’s compare actual code, then. Here’s the level-break example I posted in another comment: out․write("<TABLE>\n") out․write("<TR><TH>Planet<∕TH><TH>Moon<∕TH><∕TR>\n") items_iter = db_iter \ ( db, "select planets․name, moons․name" " from planets left join moons on planets․id = moons․parent" " order by planets․name, moons․name" ) cur_planet = None while True ∶ item = next(items_iter, None)
    1
  52. if item == None or cur_planet != None and item[0] != cur_planet ∶ if cur_planet != None ∶ out․write \ ( "<TR><TD><I>Count∶<∕I><∕TD><TD>%d<∕TD><∕TR>\n" % count ) cur_planet = None ♯end if if item == None ∶ break ♯end if
    1
  53. if item == None or cur_planet != None and item[0] != cur_planet ∶ if cur_planet != None ∶ out․write \ ( "<TR><TD><I>Count∶<∕I><∕TD><TD>%d<∕TD><∕TR>\n" % count
    1
  54. ) cur_planet = None ♯end if if item == None ∶ break ♯end if
    1
  55. out․write("<TR><TD>") if cur_planet == None ∶ ♯ first moon for next planet cur_planet = item[0] count = 0 out․write("<B>" + html․escape(item[0]) + "<∕B>") else ∶ ♯ second or subsequent moon, don’t repeat planet name out․write(" ") ♯end if
    1
  56. out․write("<∕TD><TD>") if item[1] != None ∶ ♯ there is a moon out․write(html․escape(item[1])) count += 1 else ∶ ♯ that’s no moon out․write("<I>(none)<∕I>") ♯end if out․write("<∕TD><∕TR>\n") ♯end while out․write("<∕TABLE>\n") Show us how an ORM will make that simpler.
    1
  57.  @Gnaritas42  Show your output.
    1
  58. Code taken from here: aHR0cHM6Ly9naXRodWIuY29tL2xkby9weXRob25fdG9waWNzX25vdGVib29rcy9ibG9iL21hc3Rlci9EYXRhYmFzZXMlMkMlMjBJdGVyYXRvcnMlMjAlMjYlMjBMb29waW5nLmlweW5i
    1
  59. I would assume “whatever is currently supported”. At the moment this would be 3.7 or later.
    1
  60.  @tmseth1  Such as?
    1
  61.  @_DRMR_  I’m sure he has, but most of us like to, indeed have to, deploy on stable platforms.
    1
  62. 4:28 Also on inheritance, which you didn’t actually bother with here. Python’s duck typing to the fore!
    1
  63. So you end up predefining your queries statically in the ORM, rather than being able to construct them dynamically at run-time. Not sure that’s an advantage.
    1
  64. I do hand-coded database schemas and queries. And I often make changes to them, with the need for corresponding changes to the code. “Missed issues” will manifest themselves with SQL errors, so they won’t stay “missed”.
    1
  65.  @ipadista  Same reasoning applies to ORMs.
    1
  66.  @ipadista  I’ve never used code completion. I learned how to touch-type long before I ever got my hands on a computer. Have a look at that level-break example I posted in another comment, and see how your ORM would deal with that.
    1
  67. Cursor creation and extraction of results is such a common pattern that I like to wrap it up in a generator function, e.g. def db_iter(conn, cmd, values = None, mapfn = lambda x : x) : for item in conn.cursor().execute(cmd, values) : yield mapfn(item) ♯end for ♯end db_iter What is the point of the mapfn arg? When returning a given list of field_names, you can turn the result into a dict with something as simple as mapfn = lambda row : dict(zip(field_names, row))
    1
  68.  @MessLeadingProgramming  If your system maintains an up-to-date copy of the Olson database, then I guess that counts as “doing timezones properly”.
    1
  69. Depends on the error.
    1
  70.  @ahasibrifat7568  Start by describing exactly what the error is.
    1
  71.  @ahasibrifat7568  “unable to get local issuer certificate” sounds like something you should look into.
    1
  72. Demand your money back.
    1
  73. If your tasks are not CPU-bound, then asyncio would make things simpler because it greatly reduces the opportunities for race conditions.
    1
  74. I don’t know why people are so scared of SQL injection attacks. Properly escaping values in standard SQL is as easy as def sql_string(s) : "returns an SQL string literal that evaluates to s⋅" if s == None : q = "null" elif isinstance(s, int) : q = "%d" % s elif isinstance(s, (bytes, bytearray)) : q = "X'" + ""⋅join("%02x" % d for d in s) + "'" elif isinstance(s, str) : q = "'" + str(s)⋅replace("'", "''") + "'" else : raise TypeError("can only convert bytes, str, int or None types") ♯end if return q ♯end sql_string
    1
  75. How would you use placeholders in, say, a list of values for an IN clause?
    1
  76. 16:25 Actually days of the week should numbered from 0, aren’t they?
    1
  77. If they didn’t know it at the time, is there any record of it actually happening?
    1
  78. 11:44 The situation you’re describing -- accessing an undeclared variable declared in an outer scope, followed by an assignment to it -- is a Python language error. So it cannot lead to “unexpected behaviour”. Python requires you to declare the variable as either “global” or “nonlocal” before it permits this sort of thing.
    1
  79. Remember that, in Python, functions are objects too.
    1
  80. The magic phrase is “lexical binding”. Any language that incorporates this feature automatically gains coolness points. You only lose a few if you do it in clumsy PHP style.
    1
  81. The largest Python project I built using a DBMS was about 15,000 lines. I’ve never used an ORM.
    1
  82.  @marcotroster8247  I still don’t see the need for one. I was looking back at the old code, and it still makes sense to me.
    1
  83. I have used both together.
    1
  84.  @comfuse  So feel free to offer an alternative.
    1
  85. Think of coroutines as an alternative to callbacks. Maybe you already have an event loop to handle multiple concurrent requests (pretty much mandatory in GUI programs, for example). Say you have a task which requires several steps, with waiting in-between for other tasks to do their part, and you don’t want to block the whole event loop while waiting. The conventional approach would be to break each step into a separate callback. As each callback ends, it queues the asynchronous request which invokes the next callback when done. This makes it harder to follow the logic between the separate steps. Making the task into a coroutine allows you to keep all the steps together in a single linear sequence.
    1
  86.  @zacharythatcher7328  Threads are not an alternative to callbacks. Threaded event loops (in fact, threaded everything) were all the rage in the 1990s, until it was realized that they made the code very hard to debug. That’s why we now stick to single-threaded event loops, select(2)/poll(2)/epoll(2) etc. But then, time-consuming tasks required the use of callbacks to maximize responsiveness, until the old technique of coroutines was revived more recently as a way to make such code more readable. This has required language changes, but a lot of languages (Python included) have adopted those changes. What Arjan is using threads for here, and what I have done with them myself, is to turn blocking calls into non-blocking ones. That’s all. Luckily, in POSIX, “blocking” normally means “thread-blocking”, not “process-blocking”. That’s why we can get away with it. Again, it’s all in the cause of maximizing responsiveness, without getting back into the hell of full-on multithreading.
    1
  87. The concept of relational databases arose from the mathematics of data relations. Remember what came before: there “hierarchical” databases (e.g. IBM’s IMS) and “network” databases, a.k.a. the CODASYL model (which some are now trying to revive in the form of “graph” databases). Both of these were very much tied up with on-disk structures and explicit indexing and linking and all the rest of it. So any changes to your database structures, even just wanting to optimize things a little, required changes to your code. Relational databases abstracted away from all these implementation issues, and helped a lot with decoupling code from low-level on-disk structures.
    1
  88. I think it would make sense with the upcoming “nogil” changes, and some of the potential backward-compatibility breakage, to start calling that the 4.x series.
    1
  89. Doesn’t the “Zen of Python” say that “flat is better than nested”? (Not that I pay attention to the “Zen of Python” anyway...)
    1
  90.  @blue_meets_blue  The CS term for that binding of names is the “environment”. In Python terms, “function” (code) + “environment” (data) = “function object” (code + data).
    1
  91. I sum this up in something I call Van Rossum’s Triangle: https://
    1
  92. ww
    1
  93. w.
    1
  94. devi
    1
  95. antart.
    1
  96. com/
    1
  97. default-cube/
    1
  98. art/
    1
  99. Van-Rossum-s-Triangle-
    1
  100. 67979
    1
  101. 1228
    1
  102. There is a common and very old way of doing asynchronous calls without special language syntax, and that is to use callbacks. The drawback with this is it breaks up the logic of your handler into multiple separate pieces, rather than being able to write it all in one block.
    1
  103. Python’s asyncio event loop supports both ways of working. It is instructive to compare the two. I did this with a “rocket launcher” example which you can find in the archives of our local Python user group here:
    1
  104. https://
    1
  105. git
    1
  106. hub.
    1
  107. com
    1
  108. /HamPUG/meetings
    1
  109. /tree/master
    1
  110. /2017/2017-05-08
    1
  111. /ldo-generators
    1
  112. -coroutines-asyncio
    1
  113. Here’s another tip: use a two-dimensional layout to make the structure of complex expressions clearer. Example:     if (             not isinstance(cmds, (list, tuple))         or             not all(isinstance(elt, (list, tuple)) and len(elt) == 2 for elt in cmds)         or             not all               (                     isinstance(elt[0], str)                 and                     elt[0] in valid_cmds                 and                     isinstance(elt[1], (list, tuple))                 and                     len(elt[1]) == len(steps)                 for elt in cmds               )     ) :         raise TypeError("cmds must be sequence of («cmd», «args_seq»).")     #end if
    1
  114.  @christoferberruzchungata2722  It’s already in a function.
    1
  115. If you want to see that snippet in context, have a look here https://
    1
  116. /ldo/aleqsei , in the method Context.Rib.motion().
    1
  117. com
    1
  118. git
    1
  119. hub
    1
  120. By all means, show us the actual code you would write, and we can compare them.
    1
  121. So you didn’t actually understand what the code was doing before trying to “improve” it?
    1
  122. I find it’s an easy way to scare away the armchair programmers, by asking them to actually write some code.
    1
  123. I try to design my cleanup code to never throw an error. So for example if a connection was never opened, then the connection-closing logic should automatically become a noop in this case. That helps to keep things simple.
    1
  124. Just avoid wildcard imports, and you’ll be fine.
    1
  125.  @TylerLarson  I hope you’re not trying to offer up YouTube as an example of “perfect” code ...
    1
  126.  @TylerLarson  None of which is relevant to the point. And that is, providing a point you can search for, to find the origin of a name. A from-import statement works fine for that, so long as it’s not a wildcard import.
    1
  127. Impedance mismatch between static-oriented IDE and dynamic language. So sad.
    1
  128. 12:20 By the way, forgetting the “await” in front of “asyncio.sleep()” is a mistake I have made a few times. How about you?
    1
  129. Microsoft Windows trouble?
    1
  130. If you avoid deploying mission-critical systems on Windows, that reduces your embarrassment exposure.
    1
  131. I have created worker threads to turn blocking calls into non-blocking.
    1
  132. 3.7 is obsolete. Why do you feel the need to do the extra work?
    1
  133. How would you handle a level break? Here’s a fairly simple two-column example, which lists the moons for each planet on a separate line. The planet name only appears for the first moon, and the last one is followed by a count line for that planet. out⋅write("<TABLE>\n") out⋅write("<TR><TH>Planet</TH><TH>Moon</TH></TR>\n") items_iter = db_iter \ ( db, "select planets⋅name, moons⋅name" " from planets left join moons on planets⋅id = moons⋅parent" " order by planets⋅name, moons⋅name" ) cur_planet = None while True : item = next(items_iter, None) if item == None or cur_planet != None and item[0] != cur_planet : if cur_planet != None : out⋅write \ ( "<TR><TD><I>Count:</I></TD><TD>%d</TD></TR>\n" % count ) cur_planet = None ♯end if if item == None : break ♯end if out⋅write("<TR><TD>") if cur_planet == None : ♯ first moon for next planet cur_planet = item[0] count = 0 out⋅write("<B>" + html⋅escape(item[0]) + "</B>") else : ♯ second or subsequent moon, don’t repeat planet name out⋅write(" ") ♯end if out⋅write("</TD><TD>") if item[1] != None : ♯ there is a moon out⋅write(html⋅escape(item[1])) count += 1 else : ♯ that’s no moon out⋅write("<I>(none)</I>") ♯end if out⋅write("</TD></TR>\n") ♯end while out⋅write("</TABLE>\n")
    1
  134. No, because Rust is not a dynamic heap-based language, while Python is.
    1
  135. Notice that Python effectively already has generics, because function objects and class objects are constructed at runtime?
    1
  136. Text formats are the easiest to use for interchange purposes.
    1
  137. That’s quite a reasonable use. Do you introspect the procedure prototype to do typechecking against the arguments before actually invoking it?
    1
  138.  @NathanHedglin  So do I ... mainly in PHP code.
    1
  139. 10:38 I like to use a name like “def_should_buy_avg”. The extra “def” on the front looks like the keyword for defining a function -- which is what the function does.
    1
  140. If those functions are only called from the “main” function, why not make them local to that “main” function?
    1
  141. Have difficulty navigating nested blocks? This is why I have editor commands defined to quickly jump between lines with matching indentation.
    1
  142. 4:13 “await” is actually an expression, not (necessarily) a statement.
    1
  143. 4:16 Fun fact: the awkward “PostgreSQL” name arises from the fact that the original Postgres DBMS had its own query language, called QUEL. This was in the early days of relational DBMSes, when SQL was still gathering momentum but hadn’t quite become totally dominant yet. So when they finally gave in and adopted SQL as a query language, they had to indicate this by grafting this new thing on the end of their name, with slightly unfortunate results.
    1
  144. PHP user?
    1
  145.  @greggoog7559  What has changed in Python in the last “few weeks”? Hint: Python 3.11 was released nearly a year ago.
    1
  146. 5:05 If it was a “%d” format specifier and you used printf-style formatting, then it cannot be substituted with anything other than a decimal integer. Problem solved.
    1
  147. The low-level mechanism of a coroutine object is that it executes when you call its “send” method. The coroutine blocks itself by calling a generator which does a “yield” back to the caller that did the “send”. On top of this, you can build an entire event-loop scheduling system. I drew up a diagram of how all this interconnects, that I call “Van Rossum’s Triangle”. If you search for “python topics notebooks ldo”, I cover this in one of those notebooks.
    1
  148. PHP user?
    1
  149. AbstractComponent provides an enforcement check that all abstract methods have been overridden before allowing instancing. Just typesafeness, that’s all.
    1
  150.  @jeancerrien3016  So that he can predeclare exactly which abstract methods need overriding.
    1
  151. 3:45 Threads share everything, not just memory: open files, process privileges -- the entire process context.
    1
  152. Just use cron (or systemd timers) on Linux.
    1
  153. 17:55 No need to bring in yet another module. Just add this to the decorator functions: wrapper.‗‗name‗‗ = func.‗‗name‗‗
    1
  154.  @dane2565  Easy enough to copy name and docstring. Annotations may not necessarily be valid.
    1