0%

Posted on

使用 acme.sh 自动申请泛域名证书

安装

curl  https://get.acme.sh | sh

使用 DNS API 申请证书

个人使用的是腾讯云的 DNSPod 解析服务，通过其提供的 API 可以自动添加 txt 解析以验证域名有效性

账号信息会存储在~/.acme.sh/account.conf

# 通过环境变量设置，信息会存在
export DP_Id="1234"
export DP_Key="sADDsdasdgdsf"

acme.sh --issue --dns dns_dp -d '*.co1in.com'

申请后的证书文件

/root/.acme.sh/*.co1in.com/
|-- ca.cer
|-- *.co1in.com.cer
|-- *.co1in.com.conf
|-- *.co1in.com.csr
|-- *.co1in.com.csr.conf
|-- *.co1in.com.key
`-- fullchain.cer

Posted on 
"""


Usage:
   1. Put this file in a django project directory
   2. Execute: python3 setup.py build_ext --inplace
"""


import os
import sys
import re
import shutil

from distutils.core import setup
from py_compile import compile

from Cython.Build import cythonize

if not os.path.exists('manage.py'):
    sys.exit(1)

PROJECT_DIR = os.path.abspath(os.path.dirname(__file__))

print('PROJECT_DIR:', PROJECT_DIR)

COMPILE_FILES = [
    'models.py'
]

APP_LIST = [
    'foo',
    'bar',
]


def remove_pycache():
    for app in APP_LIST:
        dir_path = os.path.join(PROJECT_DIR, app, '__pycache__')
        if os.path.exists(dir_path):
            print('rm', dir_path)


def compile_cython():
    # compile
    file_Set = set()
    for app in APP_LIST:
        for filename in COMPILE_FILES:
            file_Set.add(os.path.join(app, filename))

    setup(
        ext_modules=cythonize(file_Set)
    )

    # clean
    for app in APP_LIST:
        for filename in COMPILE_FILES:
            file_path = os.path.join(app, filename)
            print('rm', file_path)
            os.remove(file_path)


def compile_pyc():
    # compile
    for app in APP_LIST:
        for filename in os.listdir(app):
            if filename.endswith('.py'):
                filepath = os.path.join(app, filename)
                try:
                    compile(filepath)
                    print("Success compile file: %s" % filepath)

                    # remove source
                    if os.path.exists(filepath):
                        os.remove(filepath)
                except:
                    print("Can't compile file: %s" % filepath)


def move_pyc():
    # move and rename pyc
    for app in APP_LIST:
        for filename in os.listdir(os.path.join(app, '__pycache__')):
            src = os.path.join(app, '__pycache__', filename)
            new_filename = re.sub(r'\.cpython-\d+', '', filename)
            dest = os.path.join(app, new_filename)
            print('mv', src, dest)
            shutil.move(src, dest)

            # remove source
            if os.path.exists(src):
                os.remove(src)


if __name__ == "__main__":
    compile_cython()
    compile_pyc()
    move_pyc()
    remove_pycache()

Posted on

clean-code-python

https://github.com/zedr/clean-code-python

Table of Contents

  1. Introduction
  2. Variables
  3. Functions
  4. Objects and Data Structures
  5. Classes
    1. S: Single Responsibility Principle (SRP)
    2. O: Open/Closed Principle (OCP)
    3. L: Liskov Substitution Principle (LSP)
    4. I: Interface Segregation Principle (ISP)
    5. D: Dependency Inversion Principle (DIP)
  6. Don”t repeat yourself (DRY)

Introduction

Software engineering principles, from Robert C. Martin”s book
Clean Code,
adapted for Python. This is not a style guide. It”s a guide to producing
readable, reusable, and refactorable software in Python.

Not every principle herein has to be strictly followed, and even fewer will be universally
agreed upon. These are guidelines and nothing more, but they are ones codified over many
years of collective experience by the authors of Clean Code.

Inspired from clean-code-javascript

Targets Python3.7+

Variables

Use meaningful and pronounceable variable names

Bad:

import datetime


ymdstr = datetime.date.today().strftime("%y-%m-%d")

Good:

import datetime


current_date: str = datetime.date.today().strftime("%y-%m-%d")

Use the same vocabulary for the same type of variable

Bad:
Here we use three different names for the same underlying entity:

def get_user_info(): pass
def get_client_data(): pass
def get_customer_record(): pass

Good:
If the entity is the same, you should be consistent in referring to it in your functions:

def get_user_info(): pass
def get_user_data(): pass
def get_user_record(): pass

Even better
Python is (also) an object oriented programming language. If it makes sense, package the functions together with the concrete implementation
of the entity in your code, as instance attributes, property methods, or methods:

from typing import Union, Dict, Text


class Record:
    pass


class User:
    info : str

    @property
    def data(self) -> Dict[Text, Text]:
        return {}

    def get_record(self) -> Union[Record, None]:
        return Record()

Use searchable names

We will read more code than we will ever write. It”s important that the code we do write is
readable and searchable. By not naming variables that end up being meaningful for
understanding our program, we hurt our readers.
Make your names searchable.

Bad:

import time


# What is the number 86400 for again?
time.sleep(86400)

Good:

import time


# Declare them in the global namespace for the module.
SECONDS_IN_A_DAY = 60 * 60 * 24
time.sleep(SECONDS_IN_A_DAY)

Use explanatory variables

Bad:

import re


address = "One Infinite Loop, Cupertino 95014"
city_zip_code_regex = r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$"

matches = re.match(city_zip_code_regex, address)
if matches:
    print(f"{matches[1]}: {matches[2]}")

Not bad:

It”s better, but we are still heavily dependent on regex.

import re


address = "One Infinite Loop, Cupertino 95014"
city_zip_code_regex = r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$"
matches = re.match(city_zip_code_regex, address)

if matches:
    city, zip_code = matches.groups()
    print(f"{city}: {zip_code}")

Good:

Decrease dependence on regex by naming subpatterns.

import re


address = "One Infinite Loop, Cupertino 95014"
city_zip_code_regex = r"^[^,\\]+[,\\\s]+(?P<city>.+?)\s*(?P<zip_code>\d{5})?$"

matches = re.match(city_zip_code_regex, address)
if matches:
    print(f"{matches['city']}, {matches['zip_code']}")

Avoid Mental Mapping

Don’t force the reader of your code to translate what the variable means.
Explicit is better than implicit.

Bad:

seq = ("Austin", "New York", "San Francisco")

for item in seq:
    #do_stuff()
    #do_some_other_stuff()

    # Wait, what's `item` again?
    print(item)

Good:

locations = ("Austin", "New York", "San Francisco")

for location in locations:
    #do_stuff()
    #do_some_other_stuff()
    # ...
    print(location)

Don”t add unneeded context

If your class/object name tells you something, don”t repeat that in your
variable name.

Bad:

class Car:
    car_make: str
    car_model: str
    car_color: str

Good:

class Car:
    make: str
    model: str
    color: str

Use default arguments instead of short circuiting or conditionals

Tricky

Why write:

import hashlib


def create_micro_brewery(name):
    name = "Hipster Brew Co." if name is None else name
    slug = hashlib.sha1(name.encode()).hexdigest()
    # etc.

… when you can specify a default argument instead? This also makes it clear that
you are expecting a string as the argument.

Good:

from typing import Text
import hashlib


def create_micro_brewery(name: Text = "Hipster Brew Co."):
    slug = hashlib.sha1(name.encode()).hexdigest()
    # etc.

Functions

Function arguments (2 or fewer ideally)

Limiting the amount of function parameters is incredibly important because it makes
testing your function easier. Having more than three leads to a combinatorial explosion
where you have to test tons of different cases with each separate argument.

Zero arguments is the ideal case. One or two arguments is ok, and three should be avoided.
Anything more than that should be consolidated. Usually, if you have more than two
arguments then your function is trying to do too much. In cases where it”s not, most
of the time a higher-level object will suffice as an argument.

Bad:

def create_menu(title, body, button_text, cancellable):
    pass

Java-esque:

class Menu:
    def __init__(self, config: dict):
        self.title = config["title"]
        self.body = config["body"]
        # ...

menu = Menu(
    {
        "title": "My Menu",
        "body": "Something about my menu",
        "button_text": "OK",
        "cancellable": False
    }
)

Also good

from typing import Text


class MenuConfig:
    """A configuration for the Menu.

    Attributes:
        title: The title of the Menu.
        body: The body of the Menu.
        button_text: The text for the button label.
        cancellable: Can it be cancelled?
    """
    title: Text
    body: Text
    button_text: Text
    cancellable: bool = False


def create_menu(config: MenuConfig) -> None:
    title = config.title
    body = config.body
    # ...


config = MenuConfig()
config.title = "My delicious menu"
config.body = "A description of the various items on the menu"
config.button_text = "Order now!"
# The instance attribute overrides the default class attribute.
config.cancellable = True

create_menu(config)

Fancy

from typing import NamedTuple


class MenuConfig(NamedTuple):
    """A configuration for the Menu.

    Attributes:
        title: The title of the Menu.
        body: The body of the Menu.
        button_text: The text for the button label.
        cancellable: Can it be cancelled?
    """
    title: str
    body: str
    button_text: str
    cancellable: bool = False


def create_menu(config: MenuConfig):
    title, body, button_text, cancellable = config
    # ...


create_menu(
    MenuConfig(
        title="My delicious menu",
        body="A description of the various items on the menu",
        button_text="Order now!"
    )
)

Even fancier

from typing import Text
from dataclasses import astuple, dataclass


@dataclass
class MenuConfig:
    """A configuration for the Menu.

    Attributes:
        title: The title of the Menu.
        body: The body of the Menu.
        button_text: The text for the button label.
        cancellable: Can it be cancelled?
    """
    title: Text
    body: Text
    button_text: Text
    cancellable: bool = False

def create_menu(config: MenuConfig):
    title, body, button_text, cancellable = astuple(config)
    # ...


create_menu(
    MenuConfig(
        title="My delicious menu",
        body="A description of the various items on the menu",
        button_text="Order now!"
    )
)

Even fancier, Python3.8+ only

from typing import TypedDict, Text


class MenuConfig(TypedDict):
    """A configuration for the Menu.

    Attributes:
        title: The title of the Menu.
        body: The body of the Menu.
        button_text: The text for the button label.
        cancellable: Can it be cancelled?
    """
    title: Text
    body: Text
    button_text: Text
    cancellable: bool


def create_menu(config: MenuConfig):
    title = config["title"]
    # ...


create_menu(
    # You need to supply all the parameters
    MenuConfig(
        title="My delicious menu", 
        body="A description of the various items on the menu",
        button_text="Order now!",
        cancellable=True
    )
)

Functions should do one thing

This is by far the most important rule in software engineering. When functions do more
than one thing, they are harder to compose, test, and reason about. When you can isolate
a function to just one action, they can be refactored easily and your code will read much
cleaner. If you take nothing else away from this guide other than this, you”ll be ahead
of many developers.

Bad:

from typing import List


class Client:
    active: bool


def email(client: Client) -> None:
    pass


def email_clients(clients: List[Client]) -> None:
    """Filter active clients and send them an email.
    """
    for client in clients:
        if client.active:
            email(client)

Good:

from typing import List


class Client:
    active: bool


def email(client: Client) -> None:
    pass


def get_active_clients(clients: List[Client]) -> List[Client]:
    """Filter active clients.
    """
    return [client for client in clients if client.active]


def email_clients(clients: List[Client]) -> None:
    """Send an email to a given list of clients.
    """
    for client in get_active_clients(clients):
        email(client)

Do you see an opportunity for using generators now?

Even better

from typing import Generator, Iterator


class Client:
    active: bool


def email(client: Client):
    pass


def active_clients(clients: Iterator[Client]) -> Generator[Client, None, None]:
    """Only active clients"""
    return (client for client in clients if client.active)


def email_client(clients: Iterator[Client]) -> None:
    """Send an email to a given list of clients.
    """
    for client in active_clients(clients):
        email(client)

Function names should say what they do

Bad:

class Email:
    def handle(self) -> None:
        pass

message = Email()
# What is this supposed to do again?
message.handle()

Good:

class Email:
    def send(self) -> None:
        """Send this message"""

message = Email()
message.send()

Functions should only be one level of abstraction

When you have more than one level of abstraction, your function is usually doing too
much. Splitting up functions leads to reusability and easier testing.

Bad:

# type: ignore

def parse_better_js_alternative(code: str) -> None:
    regexes = [
        # ...
    ]

    statements = code.split('\n')
    tokens = []
    for regex in regexes:
        for statement in statements:
            pass

    ast = []
    for token in tokens:
        pass

    for node in ast:
        pass

Good:

from typing import Tuple, List, Text, Dict


REGEXES: Tuple = (
   # ...
)


def parse_better_js_alternative(code: Text) -> None:
    tokens: List = tokenize(code)
    syntax_tree: List = parse(tokens)

    for node in syntax_tree:
        pass


def tokenize(code: Text) -> List:
    statements = code.split()
    tokens: List[Dict] = []
    for regex in REGEXES:
        for statement in statements:
            pass

    return tokens


def parse(tokens: List) -> List:
    syntax_tree: List[Dict] = []
    for token in tokens:
        pass

    return syntax_tree

Don”t use flags as function parameters

Flags tell your user that this function does more than one thing. Functions
should do one thing. Split your functions if they are following different code
paths based on a boolean.

Bad:

from typing import Text
from tempfile import gettempdir
from pathlib import Path


def create_file(name: Text, temp: bool) -> None:
    if temp:
        (Path(gettempdir()) / name).touch()
    else:
        Path(name).touch()

Good:

from typing import Text
from tempfile import gettempdir
from pathlib import Path


def create_file(name: Text) -> None:
    Path(name).touch()


def create_temp_file(name: Text) -> None:
    (Path(gettempdir()) / name).touch()

Avoid side effects

A function produces a side effect if it does anything other than take a value in
and return another value or values. For example, a side effect could be writing
to a file, modifying some global variable, or accidentally wiring all your money
to a stranger.

Now, you do need to have side effects in a program on occasion - for example, like
in the previous example, you might need to write to a file. In these cases, you
should centralize and indicate where you are incorporating side effects. Don”t have
several functions and classes that write to a particular file - rather, have one
(and only one) service that does it.

The main point is to avoid common pitfalls like sharing state between objects
without any structure, using mutable data types that can be written to by anything,
or using an instance of a class, and not centralizing where your side effects occur.
If you can do this, you will be happier than the vast majority of other programmers.

Bad:

# type: ignore

# This is a module-level name.
# It"s good practice to define these as immutable values, such as a string.
# However...
fullname = "Ryan McDermott"

def split_into_first_and_last_name() -> None:
    # The use of the global keyword here is changing the meaning of the
    # the following line. This function is now mutating the module-level
    # state and introducing a side-effect!
    global fullname
    fullname = fullname.split()

split_into_first_and_last_name()

# MyPy will spot the problem, complaining about 'Incompatible types in 
# assignment: (expression has type "List[str]", variable has type "str")'
print(fullname)  # ["Ryan", "McDermott"]

# OK. It worked the first time, but what will happen if we call the
# function again?

Good:

from typing import List, AnyStr


def split_into_first_and_last_name(name: AnyStr) -> List[AnyStr]:
    return name.split()

fullname = "Ryan McDermott"
name, surname = split_into_first_and_last_name(fullname)

print(name, surname)  # => Ryan McDermott

Also good

from typing import Text
from dataclasses import dataclass


@dataclass
class Person:
    name: Text

    @property
    def name_as_first_and_last(self) -> list:
        return self.name.split() 


# The reason why we create instances of classes is to manage state!
person = Person("Ryan McDermott")
print(person.name)  # => "Ryan McDermott"
print(person.name_as_first_and_last)  # => ["Ryan", "McDermott"]

Objects and Data Structures

Coming soon

Classes

Single Responsibility Principle (SRP)

Open/Closed Principle (OCP)

Liskov Substitution Principle (LSP)

Interface Segregation Principle (ISP)

Dependency Inversion Principle (DIP)

Coming soon

Don”t repeat yourself (DRY)

Coming soon

Posted on

Python 调用 SOAP Web Serice 方法

最近公司有个项目需要对接泛微 OA 系统，需要发送 SOAP 请求调用 OA 系统提供的方法。
网上大多数推荐使用suds库，但是这个库比较老了，通过Slant查到zeep库的得票最多，支持 Python 3.6, 3.7, 3.8

安装

pip3 install zeep

测试 WSDL 连接

python3 -m zeep http://172.27.27.24//services/WorkflowService\?wsdl

使用zeep库