I took my Django HyperText Coffee Pot Control Protocol Middleware implementation and released it as my first ever package on PyPi, would love to get some feedback and critique.

Here's the link to the package:
https://pypi.python.org/pypi/django-htcpcp/0.2.1

and here's a link to the github repo:
https://github.com/dashdanw/django-htcpcp

I tried to make it compatible for django 1.8-1.11 and python 2/3 and I would love to hear some feedback on code style and if it's actually working, or anything else I can do to make it a stable package.

This one is sort of a novelty but in the future I would like to start developing more libraries so any advice whatsoever, even if it may seem like overkill for a package this small, would be useful to me.

/r/django
https://redd.it/6cvgbr

PEP 518 is added to pip
https://github.com/pypa/pip/pull/4144

/r/Python
https://redd.it/6cvbpo

Kernels in Docker Containers?

Hey, has anyone experimented with using docker containers as kernels? For example, you might spin up a docker container running a python3 kernel, but within the container you have some additional software resources that you can access with Python's subprocess calls.

/r/IPython
https://redd.it/6cx79u

ZEUS Build System now features python support
https://www.github.com/dreadl0ck/zeus

/r/Python
https://redd.it/6cxum9

Why is it named flask?

I'm literally filling up a flask currently and for the past month or so all I've been working on is the flask framework, and this question hit me. What's the significance?

/r/flask
https://redd.it/6cs1b2

Quick simple Django app

I'm new to Django.
I have experience with Web2PY.

I wondering if there is a pre-canned app framework that provides authentication and menu system.
I'm looking to just modify the model and view files to support a single table DB.

My requirements are minimal.
It's really a glorified web based spreadsheet.

/r/djangolearning
https://redd.it/6crgat

How do I handle %20 into spaces for a django filter for queries?

class SomeFilter(filters.FilterSet):
class Meta:
model = SomeModel
fields = {
'column1': '__all__',
'column2': '__all__'
}
So basically lets say I have a GET request using this filter like www.someAPI.com/?column2=something%20or%20Another

When I apply the filter above, it doesn't work because it's querying column 2 with %20 instead of spaces (which is what is in the sql database) how can I handle this so it queries correctly?

/r/django
https://redd.it/6czbac

Skater is a new Python library for model agnostic interpretation
https://github.com/datascienceinc/Skater

/r/pystats
https://redd.it/6cxmle

Gulp Js and Django

Im new using gulp and django I want to use both systems but don't know how. Right now my gulp is only setup to use and map javascript files only meaning instead of using the loadstatic command at the top of my html file I am using a meta file .

If anyone could provide an example or a good tutorial I would appreciate it. Thanks in advance.

/r/django
https://redd.it/6cxizt

Switching from ruby to python, any good starting point tutorial I can use? Thank you!



/r/Python
https://redd.it/6d1bbm

Regex Hell: Is there a good way of combining multiple regex's into one?

Hi all,

I'm reimplementing the following regex I found in a paper. We're essentially trying to do name entity recognition for medical documents.

> import re
>
> """
> Reimplementation of regular expression for measurement extraction described in the
> paper found here: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4586346/
> """
>
x = "(\d+\.( )?\d+" + "|\d+( )?\.\d+" + "|\.\d+|\d+) *"
>
> by = "( )?(by|x)( )?"
>
> cm = "([\- ](mm|cm|millimeter(s)?|centimeter(s)?)(?![a-z/]))"
>
> x_cm = "(("+x+"*(to|\-)*" + cm + ")" + "|(" + x + cm + "))"
>
> xy_cm = "(("+x+cm+by+x+")" + \
> "|(" + x + by + x + cm + ")" + \
> "|(" + x + by + x + "))"
>
> xyz_cm = "(("+x+cm+by+x+cm+by+x+cm+")"+ \
> "|(" + x + by + x + by + x + cm +")" + \
> "|(" + x + by + x + by + x + "))"
>
> \# Final regular expression

> m = "((" + xyz_cm + ")" + \
> "|(" + xy_cm + ")" + \
> "|(" + x_cm + "))"

Whenever I run re.compiles(m) on the final expression, I'm getting a runtime error. Do you all have any suggestions on how I can cleanly break this up or where the error is? I'm trying to avoid having to use a context free grammar.

/r/Python
https://redd.it/6d1yg6

export as a normal Python session

Can we export the current session as if we had worked in the default Python shell? Here is what I mean. IPython session:

In [1]: li = [1, 2, 3]

In [2]: li
Out[2]: [1, 2, 3]

In [3]:

I want to paste it in a blog post, but it's too verbose (imagine that it's longer). I'd like to export it like this:

>>> li = [1,2,3]
>>> li
[1, 2, 3]
>>>

Is it possible?

/r/IPython
https://redd.it/6d2zi2

PyCon 2017 VoDs
https://www.youtube.com/channel/UCrJhliKNQ8g0qoE_zvL8eVg/videos

/r/Python
https://redd.it/6d2edm

Save a django object getting another model instance as foreign key from a form

I am getting the URL tag from formnumber, but I would like to save the value in another model named ExpenseForecast. Any ideas?


def inputsexp(request, number):
formnumber = Projectsummary.objects.all().get(number=number)
form = ProjExpField(data=request.POST or None, instance=formnumber)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('app:test_forecast_data', kwargs={'number': number}))
context = {'form': form, 'formnumber': formnumber}
return render(request, 'projexpfield.html', context)

/r/django
https://redd.it/6d4pts

build a django-cms apphook
https://medium.com/@cleopatradouglas/building-django-cms-apphooks-5d4bdc44a906

/r/django
https://redd.it/6d59qd

What is a good ecommerce support for Django? More info below.

I need to provide a utility for the users to purchase items, select shipping address & pick up address, and delivery date & time. I also need to be able to use payment APIs such as Stripe, PayPal, etc.
Any suggestions?

/r/django
https://redd.it/6d4nwq

Does flask have any plugins to manipulate and render database instances conveniently?

I have been using Flask with SQLAlchemy and WTForms for a while now.

At first, I've been following something along these lines:
* Create SQLAlchemy model class
* Create WTForm class based on the SQLAlchemy model (it's almost always line to line mapping)
* Create a view template to render the form for viewing and for displaying the model data in Jinja.

I find this approach to be very cumbersome: If I change a field in my SQLAlchemy class, I have to update my WTForm and my view template as well.

Then I came across WTForms-Alchemy. Now,

* I just have to create the SQLAlchemy class
* WTForms-Alchemy will map that to a WTForm
* And I render that form for creating/viewing/updating in my Jinja.

This made my job a lot easier but WTForms-Alchemy has a lot of bugs that makes it very difficult for me to continue using it (check my history).

#Are there other plugins for Flask which makes this whole process simpler from my point of view?



/r/flask
https://redd.it/6d378b

Is it just me or does json serializing take forever?

I'm running all localhost and a 2mb json file takes like a minute to load.

I'm making a web map so I need to in geojson format. Are there any ways to make this go faster?

/r/django
https://redd.it/6d6ss3

The story of adding type hints to one of my projects - things I learned and issues encountered

Adding type hints to Tale
-------------------------

**TL;DR:** I wanted to share my experience with adding type hints to one of my projects. There were some benefits, mypy discovered a couple of bugs, there are a few annoyances for me, and I am not really sold on it yet.
Please correct my mistakes or help me solve some problems if possible :)


Intro
-----

'Tale - an Interactive Fiction, MUD & mudlib framework' is
a medium sized Python project. At the time of writing (just after
releasing version 3.1 of the project),
it has about 15000 SLOC (~9500 in the tale library,
~3800 in the test suite, and ~2100 in the demo stories).

You can find it on Github; https://github.com/irmen/Tale

Tale started as a Python 2.x-and-3.x compatible library but I decided
I want to be able to use modern Python (3.5+) features and not worry
anymore about backwards compatibility, so I cleaned up and modernized the code a while ago.

After finishing that, one of the major new Python features I still hadn't used anywhere,
was _type hinting_. Because I wanted to learn to use it, I took Tale as
a test case and added type hints to all of the code.
I wanted to learn about the syntax,
how to apply it to an existing code base,
to see what benefits it gives,
and to discover what problems it introduces and what limitations it has.

Below are the results.


Benefits
--------

The following things have proven to be beneficial to me:

- PyCharm (my IDE of choice) is giving more detailed warning messages and code completion suggestions:
it adds inferred types or type hints to it.
- The MyPy tool (http://mypy.readthedocs.io/en/latest/index.html) is able to statically find type related errors in the code
at _compile time_ rather than having to run into them during _run time_.
It correctly identified several mistakes that were in the code that I had
not discovered yet and weren't caught by the unit tests.
- Mypy is pretty smart, I was quite surprised by its capability to infer
the type of things and how it propagates through the code.
- Type hinting is optional so you can mix code with and without type hints.



Things I'm not happy with
-------------------------

- It takes a lot of effort to add correct type hints everywhere.
Before this task is complete, mypy can and will report lots of
errors that are wrong or can be misleading.

- Mypy has bugs. One of the most obvious is that it doesn't know about
several modules and classes from the standard library.

- Shutting mypy up is done via a `# type: ignore` comment.
Tale now has about 60 of these...
Some of them can and should be removed once mypy gets smarter,
but I have no way of knowing which ones they are. How am I going to maintain these?
It strongly reminds me of the 'suppress-warning' type of comments found
in other languages. This is problematic because it hides possible errors
in a way that is hard to find later.

- I really don't like these two major aspects of the type hint syntax:
1. Sometimes you have to use _strings_ rather than the type itself.
This is because the hints are parsed at the same time as all other code,
and sometimes you need "forward references" to types that are not yet defined.
This can sometimes be fixed by rearranging the definition order
of your classes, but if classes reference each other (which is common)
this doesn't help. I find the most irritating that you have to
do this for the actual class that you're type hinting the methods of!
I understand the reason (the class is still being parsed, and is not
yet _defined_) but I find it very cumbersome.
2. Type hints for variables are often required to help mypy. Especially
if you're initializing names with empty collection types such as `[]` or `{}`
which is common. Also you have to do this via a _comment_ such as `# type: List[str]`
The latter is improved in Python 3.6 (see PEP-526) but I want to
s

tick with 3.5 as a minimum for a while.


- Because type hints are parsed by Python itself, and because mypy
even parses the comments as well,
you'll have to import all types that you use in hints.
This causes a lot of extra imports in every module.
In my case this even led to some circular import problems that
were only fixable by changing the modules itself. (One can argue
that this is a good thing! Because circular references often
are a code smell)
Some types are only used in a _comment_, which
causes the IDE to warn me about unused imports that it wants to
clean up (but if I do this, it breaks mypy). PyCharm is not (yet)
smart enough to see that an import is really used even if it is just a type hint comment.
To be honest, PyCharm has a point, because it is *mypy* that uses it, not *python*...
But it causes me to have to accept several warnings that aren't.

- The code becomes harder to read. In some cases, _a lot harder_ because
some type hints can become quite elaborate (list of dicts mapping str to tuple... etc)
You can ease the pain a bit by creating your own type classes but
this clutters the module namespace.



Things learned, thougts
-----------------------

After adding type hints to all of Tale's code, a lot of time
was spent fixing mistakes (in the hints I wrote) and several bugs (that mypy found).

After all of this, I learned that

- using type hints helps uncover bugs and improves IDE feedback and code understanding
- it is quite a lot of work to add it to an existing code base and "get it right" (= no mypy errors)
- it has to be done in an 'unnatural' way sometimes, because of the way Python parses stuff
- it can clutter up code that was very concise and clean before.


But the most important thing really:

**...static typing (via type hints + mypy tooling) clashes with Python's dynamic duck type nature.**
It all still feels 'off' to me, in the context of Python. It introduces new kinds of problems, that we didn't have
without them, and the syntax is not as 'natural' as I hoped.

Right now, I am not really sure if I want to continue to use type hints.
In Tale I probably will because it now has them everywhere already, but
my other projects have to wait.

As this is the first and only time so far that I have used type hints,
it is very likely that I made some mistakes or missed a better solution to
some of the issues I encountered.
Please correct me on them or give me some tips on improving my application
and understanding of Python's type hints. Thank you!


/r/Python
https://redd.it/6d5haz