Clean up initial blacklist download on install #14
|
@ -12,12 +12,11 @@ python:
|
|||
install:
|
||||
|
||||
- python -m pip install -U pip wheel setuptools
|
||||
- python -m pip install -U isort flake8
|
||||
- python -m pip install -r requirements.txt
|
||||
- python -Wd setup.py sdist
|
||||
- python -Wd -m pip install dist/py3-validate-email-*.tar.gz
|
||||
- python -Wd setup.py sdist -v
|
||||
- python -Wd -m pip install -v dist/py3-validate-email-*.tar.gz
|
||||
|
||||
# command to run tests
|
||||
script:
|
||||
```suggestion
- python -m unittest discover -v -s tests
```
`-I` isolates the user environment (`~/.local/lib...` under linux), not the virtual env you intended, I think. Even if there's no venv in the case of travis tests, it makes no difference in isolating python here. The point of the `InstallTest.test_datadir_is_in_place` is to not use the locally deployed `validate_email` directory, hence the `sys.path.remove("")` in the test.
|
||||
- python -m isort -c --skip-glob=venv
|
||||
- python -m flake8 tests/ validate_email/ setup.py
|
||||
- python -m unittest discover -v
|
||||
- python -m unittest discover -v -s tests
|
||||
|
|
|
@ -2,7 +2,6 @@ include AUTHORS
|
|||
include LICENSE
|
||||
include README.rst
|
||||
include CHANGELOG.txt
|
||||
recursive-include validate_email *
|
||||
recursive-exclude tests *
|
||||
recursive-exclude * __pycache__
|
||||
recursive-exclude * *.pyc
|
||||
|
|
|
@ -1,3 +0,0 @@
|
|||
dnspython==1.16.0
|
||||
idna==2.8
|
||||
filelock>=3.0.12
|
108
setup.py
|
@ -1,106 +1,72 @@
|
|||
```suggestion
def run_initial_updater(path: Path):
```
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
import sys
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
from distutils import log
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
from pathlib import Path
|
||||
from shutil import move, rmtree
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
from subprocess import check_call
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
from tempfile import mkdtemp
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
from setuptools import find_packages, setup
|
||||
from setuptools.command.build_py import build_py
|
||||
from setuptools.command.develop import develop
|
||||
from setuptools.command.sdist import sdist
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
try:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
# OSX Homebrew fix: https://stackoverflow.com/a/53190037/1067833
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
from sys import _base_executable as executable
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
except ImportError:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
from sys import executable
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
_EGG_REQ_PATH = Path(__file__).parent.joinpath(
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
'py3_validate_email.egg-info', 'requires.txt')
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
_REQ_PATH = Path(__file__).parent.joinpath('requirements.txt')
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
with open(_REQ_PATH if _REQ_PATH.exists() else _EGG_REQ_PATH) as fd:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
_req_content = fd.readlines()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
_DEPENDENCIES = [x.strip() for x in _req_content if x.strip()]
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
with open(Path(__file__).parent.joinpath('README.rst')) as fd:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
_LONG_DESC = fd.read()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
|
||||
def run_initial_updater():
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
def run_initial_updater(path: Path):
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
'Download an initial blacklist.txt on install time.'
|
||||
# Install dependencies so the initial update can run
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
check_call([executable, '-m', 'pip', 'install'] + _DEPENDENCIES)
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
# The updater will walk code stack frames and see if this
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
# variable is set in locals() to determine if it is run from the
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
# setup, in which case it won't autoupdate.
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
_IS_VALIDATEEMAIL_SETUP = True
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
from validate_email.updater import BlacklistUpdater, LIB_PATH_DEFAULT
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
LIB_PATH_DEFAULT.mkdir(exist_ok=True)
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
blacklist_updater = BlacklistUpdater()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
blacklist_updater._is_install_time = _IS_VALIDATEEMAIL_SETUP
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
blacklist_updater.process(force=True)
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
# Only import the updater module to avoid requiring all the dependencies
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
# and auto-running the updater.
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
sys.path.append(str(path.joinpath('validate_email')))
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
orig_dont_write_bytecode = sys.dont_write_bytecode
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
sys.dont_write_bytecode = True
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
try:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
from updater import BLACKLIST_FILEPATH_INSTALLED, BlacklistUpdater
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
log.info(f'downloading blacklist to {BLACKLIST_FILEPATH_INSTALLED}')
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
BlacklistUpdater()._install()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
finally:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
sys.path = sys.path[:-1]
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
sys.dont_write_bytecode = orig_dont_write_bytecode
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
|
||||
class DevelopCommand(develop):
|
||||
'Develop command.'
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
"""
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
Adapted version of the 'develop' command.
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
After finishing the usual build run, download the blacklist and
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
store it into the source directory, because that is from where the
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
library will run in a developer install.
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
"""
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
def run(self):
|
||||
if self.dry_run:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
return super().run()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
run_initial_updater()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
super().run()
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
class SdistCommand(sdist):
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
'Sdist command.'
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
def run(self):
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
"""
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
Manually remove the data directory before creating the
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
distribution package, every install will create it for
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
themselves when installing created the python wheel.
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
`MANIFEST.in` should not remove the data dir since install and
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
develop/install would exclude it!
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
"""
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
if self.dry_run:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
return super().run()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
tempdir = Path(mkdtemp()).joinpath('data')
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
data_dir = Path(
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
__file__).absolute().parent.joinpath('validate_email', 'data')
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
do_move = data_dir.exists()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
if do_move:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
move(src=data_dir, dst=tempdir)
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
super().run()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
if do_move:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
move(src=tempdir, dst=data_dir)
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
rmtree(path=tempdir.parent)
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
if not self.dry_run:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
run_initial_updater(Path(__file__).parent)
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
|
||||
class BuildPyCommand(build_py):
|
||||
'BuildPy command.'
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
"""
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
Adapted version of the 'build_py' command.
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
After finishing the usual build run, download the blacklist and
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
store it into the build directory. A subsequent 'install' step will
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
copy the full contents of the build directory to the install
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
target, thus including the blacklist.
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
"""
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Please store and restore the original value of Please store and restore the original value of `dont_write_bytecode`, in order to not interfere with other installers.
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
Okay. Okay.
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
def run(self):
|
||||
if self.dry_run:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
return super().run()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
run_initial_updater()
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
super().run()
|
||||
if not self.dry_run:
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
run_initial_updater(Path(self.build_lib))
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
|
||||
|
||||
setup(
|
||||
```suggestion
install_requires=['dnspython~=1.16', 'idna~=2.8', 'filelock~=3.0'],
```
|
||||
name='py3-validate-email',
|
||||
version='0.2.6',
|
||||
packages=find_packages(exclude=['tests']),
|
||||
install_requires=_DEPENDENCIES,
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
install_requires=['dnspython~=1.16', 'idna~=2.8', 'filelock~=3.0'],
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
author='László Károlyi',
|
||||
author_email='laszlo@karolyi.hu',
|
||||
include_package_data=True,
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
description=(
|
||||
'Email validator with regex, blacklisted domains and SMTP checking.'),
|
||||
long_description=_LONG_DESC,
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
long_description=Path(__file__).parent.joinpath('README.rst').read_text(),
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
long_description_content_type='text/x-rst',
|
||||
keywords='email validation verification mx verify',
|
||||
url='http://github.com/karolyi/py3-validate-email',
|
||||
cmdclass=dict(
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
develop=DevelopCommand, sdist=SdistCommand, build_py=BuildPyCommand),
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
cmdclass=dict(build_py=BuildPyCommand, develop=DevelopCommand),
|
||||
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
||||
license='LGPL',
|
||||
)
|
||||
|
|
|||
```suggestion
def run_initial_updater(path: Path):
```
```suggestion
def run_initial_updater(path: Path):
```
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/ Do you have a tool to check the completeness of type annotations, or are you just so attentive? I really try to pay attention but I seem to forget this at least in one place for each of my commits :-/
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
One could use mypy for that, I don't because I couldn't set it up properly with Django. I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me. One could use mypy for that, I don't because I couldn't set it up properly with Django.
I use python-language-server with sublime, and that will show completions for function input parameters only if the type is specified there. So basically it's grown to be a habit for me.
|
|
@ -1,5 +1,7 @@
|
|||
from pathlib import Path
|
||||
from subprocess import check_output
|
||||
from tarfile import TarInfo
|
||||
from tarfile import open as tar_open
|
||||
from unittest.case import TestCase
|
||||
|
||||
try:
|
||||
|
@ -26,3 +28,11 @@ class InstallTest(TestCase):
|
|||
self.assertTrue(
|
||||
expr=Path(etag_path).exists(),
|
||||
msg=f'{etag_path!r} doesn\'t exist.')
|
||||
|
||||
def test_sdist_excludes_datadir(self):
|
||||
'The created sdist should not contain the data dir.'
|
||||
latest_sdist = list(Path('dist').glob(pattern='*.tar.gz'))[-1]
|
||||
tar_file = tar_open(name=latest_sdist, mode='r:gz')
|
||||
for tarinfo in tar_file: # type: TarInfo
|
||||
self.assertNotIn(
|
||||
member='/validate_email/data/', container=tarinfo.name)
|
||||
|
|
|
@ -9,10 +9,6 @@ from typing import Callable, Optional
|
|||
from urllib.error import HTTPError
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
from filelock import FileLock
|
||||
|
||||
from .utils import is_setuptime
|
||||
|
||||
LOGGER = getLogger(__name__)
|
||||
TMP_PATH = Path(gettempdir()).joinpath(
|
||||
f'{gettempprefix()}-py3-validate-email-{geteuid()}')
|
||||
|
@ -37,57 +33,30 @@ class BlacklistUpdater(object):
|
|||
"""
|
||||
|
||||
_refresh_when_older_than: int = 5 * 24 * 60 * 60 # 5 days
|
||||
_is_install_time: bool = False
|
||||
|
||||
@property
|
||||
def _etag_filepath(self) -> str:
|
||||
'Return the ETag file path to use.'
|
||||
return ETAG_FILEPATH_INSTALLED \
|
||||
if self._is_install_time else ETAG_FILEPATH_TMP
|
||||
|
||||
@property
|
||||
def _blacklist_filepath(self) -> str:
|
||||
'Return the blacklist file path to use.'
|
||||
return BLACKLIST_FILEPATH_INSTALLED \
|
||||
if self._is_install_time else BLACKLIST_FILEPATH_TMP
|
||||
|
||||
def _read_etag(self) -> Optional[str]:
|
||||
'Read the etag header from the stored etag file when exists.'
|
||||
for path in [ETAG_FILEPATH_TMP, ETAG_FILEPATH_INSTALLED]:
|
||||
try:
|
||||
with open(path) as fd:
|
||||
return fd.read().strip()
|
||||
return path.read_text().strip()
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
|
||||
def _write_etag(self, content: str):
|
||||
'Write the etag of the newly received file to the cache.'
|
||||
path = self._etag_filepath
|
||||
LOGGER.debug(msg=f'Storing ETag response into {path}.')
|
||||
with open(path, 'w') as fd:
|
||||
fd.write(content)
|
||||
|
||||
@property
|
||||
def _is_old(self) -> bool:
|
||||
'Return `True` if the locally stored file is old.'
|
||||
true_when_older_than = time() - self._refresh_when_older_than
|
||||
try:
|
||||
ctime = BLACKLIST_FILEPATH_TMP.stat().st_ctime
|
||||
if ctime >= true_when_older_than:
|
||||
# Downloaded tmp file is still fresh enough
|
||||
return False
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
try:
|
||||
ctime = BLACKLIST_FILEPATH_INSTALLED.stat().st_ctime
|
||||
except FileNotFoundError:
|
||||
return True
|
||||
return ctime < true_when_older_than
|
||||
for path in [BLACKLIST_FILEPATH_TMP, BLACKLIST_FILEPATH_INSTALLED]:
|
||||
try:
|
||||
return path.stat().st_ctime < true_when_older_than
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
return True # no file found at all
|
||||
|
||||
def _get_headers(self, force_update: bool = False) -> dict:
|
||||
'Compile a header with etag if available.'
|
||||
headers = dict()
|
||||
if force_update or self._is_install_time:
|
||||
if force_update:
|
||||
return headers
|
||||
etag = self._read_etag()
|
||||
if not etag:
|
||||
|
@ -95,31 +64,44 @@ class BlacklistUpdater(object):
|
|||
headers['If-None-Match'] = etag
|
||||
return headers
|
||||
|
||||
def _write_new_file(self, response: HTTPResponse):
|
||||
'Write new data file on its arrival.'
|
||||
def _download(self, headers: dict, blacklist_path: Path, etag_path: Path):
|
||||
'Downlad and store blacklist file.'
|
||||
LOGGER.debug(msg=f'Checking {BLACKLIST_URL}')
|
||||
request = Request(url=BLACKLIST_URL, headers=headers)
|
||||
response = urlopen(url=request) # type: HTTPResponse
|
||||
# New data available
|
||||
LOGGER.debug(msg=f'Writing response into {blacklist_path}')
|
||||
blacklist_path.write_bytes(response.fp.read())
|
||||
if 'ETag' in response.headers:
|
||||
self._write_etag(response.headers.get('ETag'))
|
||||
path = self._blacklist_filepath
|
||||
LOGGER.debug(msg=f'Writing response into {path}')
|
||||
with open(path, 'wb') as fd:
|
||||
fd.write(response.fp.read())
|
||||
LOGGER.debug(msg=f'Storing ETag response into {etag_path}.')
|
||||
etag_path.write_text(response.headers['ETag'])
|
||||
|
||||
def _install(self):
|
||||
"""
|
||||
Download and store the blacklist file and the matching etag file
|
||||
into the library path. This is executed from setup.py upon
|
||||
installation of the library. Don't call this in your
|
||||
application.
|
||||
"""
|
||||
LIB_PATH_DEFAULT.mkdir(exist_ok=True)
|
||||
self._download(
|
||||
headers={}, blacklist_path=BLACKLIST_FILEPATH_INSTALLED,
|
||||
etag_path=ETAG_FILEPATH_INSTALLED)
|
||||
|
||||
def _process(self, force: bool = False):
|
||||
'Start optionally updating the blacklist.txt file, while locked.'
|
||||
if not force and not self._is_old:
|
||||
This here serves a purpose, an edge case. If the preinstalled file path doesn't exist (for example at install time), it should return This here serves a purpose, an edge case.
If the preinstalled file path doesn't exist (for example at install time), it should return `True` so that the updater will start an update. Besides, your updated version does return `None`, which is not a strict `bool` just boolish.
Yes, right, there's a "return True" at the end of my version missing. In practice, this should never happen (this code is not run at install time any more), but I absolutely agree that it's better to have it there. Yes, right, there's a "return True" at the end of my version missing. In practice, this should never happen (this code is not run at install time any more), but I absolutely agree that it's better to have it there.
|
||||
LOGGER.debug(msg='Not updating because file is fresh enough.')
|
||||
return
|
||||
LOGGER.debug(msg=f'Checking {BLACKLIST_URL}')
|
||||
request = Request(
|
||||
url=BLACKLIST_URL, headers=self._get_headers(force_update=force))
|
||||
try:
|
||||
response = urlopen(url=request) # type: HTTPResponse
|
||||
# New data available
|
||||
self._write_new_file(response=response)
|
||||
self._download(
|
||||
headers=self._get_headers(force_update=force),
|
||||
blacklist_path=BLACKLIST_FILEPATH_TMP,
|
||||
etag_path=ETAG_FILEPATH_TMP)
|
||||
except HTTPError as exc:
|
||||
if exc.code == 304:
|
||||
# Not modified, update date on the tmp file
|
||||
LOGGER.debug(msg=f'Local file is fresh enough (same ETag).')
|
||||
LOGGER.debug(msg='Local file is fresh enough (same ETag).')
|
||||
BLACKLIST_FILEPATH_TMP.touch()
|
||||
return
|
||||
raise
|
||||
|
@ -128,6 +110,8 @@ class BlacklistUpdater(object):
|
|||
self, force: bool = False, callback: Optional[Callable] = None):
|
||||
'Start optionally updating the blacklist.txt file.'
|
||||
# Locking to avoid multi-process update on multi-process startup
|
||||
# Import filelock locally because this module is als used by setup.py
|
||||
from filelock import FileLock
|
||||
with FileLock(lock_file=LOCK_PATH):
|
||||
self._process(force=force)
|
||||
# Always execute callback because multiple processes can have
|
||||
|
@ -144,8 +128,6 @@ def update_builtin_blacklist(
|
|||
Update and reload the built-in blacklist. Return the `Thread` used
|
||||
to do the background update, so it can be `join()`-ed.
|
||||
"""
|
||||
if is_setuptime():
|
||||
return
|
||||
LOGGER.info(msg='Starting optional update of built-in blacklist.')
|
||||
blacklist_updater = BlacklistUpdater()
|
||||
kwargs = dict(force=force, callback=callback)
|
||||
|
|
|
@ -1,20 +0,0 @@
|
|||
try:
|
||||
from sys import _getframe
|
||||
getframe = _getframe
|
||||
except ImportError:
|
||||
getframe = None
|
||||
|
||||
from traceback import walk_stack
|
||||
|
||||
|
||||
def is_setuptime() -> bool:
|
||||
'Return `True` if called from setup.'
|
||||
if getframe is None:
|
||||
# This is not CPython, can't know if this is setup time
|
||||
return False
|
||||
for frame, lineno in walk_stack(f=getframe()):
|
||||
# @See setup.py
|
||||
if frame.f_locals and \
|
||||
frame.f_locals.get('_IS_VALIDATEEMAIL_SETUP') is True:
|
||||
return True
|
||||
return False
|
Nope!
The point here is to install the package as if it were installed from pypi.
setup.py develop
is not the way of doing it!Okay, understood!