self.checkPos(len(msg)) self.stream.write(msg) except (UnicodeDecodeError, UnicodeEncodeError): msg = msg.encode("UTF-8") self.checkPos(len(msg)) self.stream.write(msg) StreamHandler.lastwrite = StatusHandler self.flush() except: self.handleError(record) setLoggerClass(Logger) root = Logger() _loggers = {None: root} def getLogger(name=None): """ Return a logger with the specified name, creating it if necessary. If no name is specified, return the root logger. """ if name: logger = Logger.manager.getLogger(name) _loggers[name] = logger return logger else:
class XxlsearchPipeline: logger = Logger(__name__) def __init__(self): self.mailer = MailSender( smtphost='smtp.163.com', smtpport=25, smtpuser='******', mailfrom='*****@*****.**', smtppass='******' ) def send_email(self, content): self.mailer.send( to=["*****@*****.**"], subject="【爬虫】今天查找结果", body=content ) self.logger.log(DEBUG, '发送成功') def process_item(self, item, spider): content = f""" 主人好, 下面是我爬取到的结果,希望对你有所帮助,你可以点击链接确认一下结果。O(∩_∩)O哈哈~ <br/> <style type="text/css"> table.gridtable {{ font-family: verdana,arial,sans-serif; font-size:11px; color:#333333; border-width: 1px; border-color: #666666; border-collapse: collapse; }} table.gridtable th {{ border-width: 1px; padding: 8px; border-style: solid; border-color: #666666; background-color: #dedede; }} table.gridtable td {{ border-width: 1px; padding: 8px; border-style: solid; border-color: #666666; background-color: #ffffff; }} </style> <table class="gridtable"> <tr> <th>标题</th><th>链接</th> </tr> <tr> <td>{item.title}</td><td><a href='{item.url}'>{item.url}</a></td> </tr> </table> """ body = MIMEText(content, _subtype='html', _charset='utf8') self.send_email(body.as_string()) self.logger.log(DEBUG, body.as_string()) self.logger.log(DEBUG, f"item found: {item.title}") return item
}, { 'id': 'internet_connectivity_type_wizard', 'url': 'networks:internet-connection-type-first-boot', 'order': 4, }, ] _description = [ _('Configure network devices. Connect to the Internet via Ethernet, Wi-Fi ' 'or PPPoE. Share that connection with other devices on the network.'), _('Devices administered through other methods may not be available for ' 'configuration here.'), ] logger = Logger(__name__) app = None NETWORK_TOPOLOGY_TYPE_KEY = 'networks_topology_type' ROUTER_CONFIGURATION_TYPE_KEY = 'networks_router_configuration_type' INTERNET_CONNECTION_TYPE_KEY = 'networks_internet_type' class NetworksApp(app_module.App): """FreedomBox app for Networks.""" app_id = 'networks' def __init__(self): """Create components for the app."""
__all__ = ( 'generate_discourse_login_url', 'InvalidSOOPayload', 'MissingDiscourseAPICredentials', ) class InvalidSOOPayload(Exception): pass class MissingDiscourseAPICredentials(Exception): pass logger = Logger(__file__) def generate_discourse_login_url(user, payload, signature): """ Generate Discourse login url if payload matches signature It will raise InvalidSOOPayload otherwise :param user: Django's User :param payload: payload to be validated :param signature: payload signature :return: url to login user """ decoded = _decode_payload(payload, signature) _check_nonce_is_present(decoded) nonce = parse.parse_qs(decoded)['nonce'][0] return _generate_discourse_login_url(nonce, user)
import os import re import select import subprocess import sys import time import uuid from threading import Thread import serial from serial.tools import list_ports from acts import tracelogger from logging import Logger logging = tracelogger.TakoTraceLogger(Logger(__file__)) RETRIES = 0 class LogSerialException(Exception): """LogSerial Exception.""" class PortCheck(object): def get_serial_ports(self): """Gets the computer available serial ports. Returns: Dictionary object with all the serial port names. """
# -*- coding:utf-8 -*- from __future__ import unicode_literals from baidu_lbs import * from logging import Logger, INFO, StreamHandler baidu_lbs_logger = Logger('baidu_lbs', level=INFO) baidu_lbs_logger.addHandler(StreamHandler())
from __future__ import annotations import sys from typing import Literal, Union from logging import Logger, StreamHandler, Formatter from .utils import wrap_for_asyncio from .constants import NAME, LOG_MESSAGE_FORMAT Level = Union[Literal['DISABLE'], Literal['DEBUG'], Literal['INFO'], Literal['WARNING'], Literal['ERROR'], Literal['CRITICAL']] _logger = Logger(name=NAME) def configure(level: Level) -> None: handler = StreamHandler(stream=sys.stdout) handler.setLevel(level) handler.setFormatter(Formatter(fmt=LOG_MESSAGE_FORMAT)) _logger.setLevel(level) _logger.addHandler(handler) debug = wrap_for_asyncio(_logger.debug) info = wrap_for_asyncio(_logger.info) warning = wrap_for_asyncio(_logger.warning) error = wrap_for_asyncio(_logger.error) exception = wrap_for_asyncio(_logger.exception)
import re import os import requests import wget import tarfile from logging import Logger LOG = Logger(__name__) def download_file(url): LOG.warning(f'Downloading file from {url}...') file_name = wget.download(url) LOG.warning(f'{file_name} downloaded successfuly!') return file_name def unpack_file(file_name, destiny): """ Function to unpack and delete a tar.gz file. """ geo_file_path = file_name.split('.')[0] geo_file_name = file_name.split('_')[0] LOG.warning(f'Unpacking {file_name}...') tar = tarfile.open(file_name, 'r:gz') file = tar.getmember(f'{geo_file_path}/{geo_file_name}.mmdb') file.name = os.path.basename(file.name) tar.extract(file, destiny) LOG.warning(f'{file_name} Unpacked successfuly!')
import re import requests import json from bs4 import BeautifulSoup from .utils import formata_numero_processo, cria_hash_do_processo from .parser import (parse_metadados, area_dos_metadados, parse_itens, prepara_soup, cria_url_movimentos) from logging import Logger URL_PROCESSO_TJRJ = ('http://www4.tjrj.jus.br/numeracaoUnica/faces/index.jsp?' 'numProcesso={doc_number}') _LOGGER = Logger('processostjrj.processo') def processo(processo, headers=None, timeout=10): """Efetua o download e parsing de um processo TJRJ a partir do seu número. """ _LOGGER.info(processo) dados_processo = {} numero_processo = formata_numero_processo(re.sub(r'\D', "", processo)) try: resp = requests.post( URL_PROCESSO_TJRJ.format(doc_number=numero_processo), headers=headers, timeout=10, allow_redirects=True) soup = prepara_soup(BeautifulSoup(resp.content, 'lxml')) link_movimentos = cria_url_movimentos(soup, resp.url) resp = requests.get(link_movimentos, headers=headers) soup = prepara_soup(BeautifulSoup(resp.content, 'lxml'))
1, {Ingredient(0, 0, 50), Ingredient(1, 0, 50)}, Glass(400)) bot = CockBot() controller = L298N(0, enable_pin_1=Pin(3), enable_pin_2=Pin(14)) controller.enable_all() strength = 100 pump1 = Pump(pin_number=4, place=Place(1), strength=strength, ingredient_id=gin_ingredient_id) pump2 = Pump(pin_number=15, place=Place(2), strength=strength, ingredient_id=tonic_ingredient_id) controller.add_pump(pump1) controller.add_pump(pump2) bot.add_motor_controller(controller) pump1.is_forward = False pump2.is_forward = False # bot.pour(recipe=recipe) bot.pumps() if __name__ == "__main__": try: main() except Exception as e: Logger("main").exception(f"{e}")
def __init__(self, motor_controllers: Set[L298N] = None): self.log = Logger("CockBot") if not motor_controllers: self.motor_controllers = set()
from codeschool.utils import LazyManager from logging import Logger friendships = LazyManager('friends', 'friendshipstatus') users = LazyManager('auth', 'user') log = Logger('social.friends') def get_all_friends(user): """ Return a queryset with all user's friends. """ relations = friendships.filter(owner=user, status='friend') user_ids = relations.values_list('other__id', flat=True) return users.filter(id__in=user_ids) def get_possible_friends(user): """ Return a queryset of all users that can be friend with the given user. """ friends = get_all_friends(user) \ | users.filter(id=user.id) \ | users.filter(username='******') friends_ids = friends.values_list('id', flat=True) return users.exclude(id__in=friends_ids) def request_friendship(user, other):
from logging import Logger logger = Logger("karma-log") def log(*txt): print(*txt, flush=True)
log_colors={ 'DEBUG': 'cyan', 'INFO': 'green', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'red,bg_white', }, secondary_log_colors={}, style='%' ) def disable_logs(): disable(CRITICAL) def init_logger(logger): streamH = StreamHandler() streamH.setFormatter(formatter) logger.addHandler(streamH) def set_global_level(level): LOGGER.setLevel(level) getLogger().setLevel(level) LOGGER = Logger("artefact", INFO) init_logger(LOGGER) init_logger(getLogger())
from lib.image_prep import ImagePrep import requests import boto3 from os import environ, path from typing import Any, Mapping from json import dumps, loads from logging import Logger # Initialize the environment logger = Logger(name='LambdaFunction') def process_notification(event: Mapping[str, Any], _=None): print(event) object_get_context = event["getObjectContext"] request_route = object_get_context["outputRoute"] request_token = object_get_context["outputToken"] s3_url = object_get_context["inputS3Url"] # Get object from S3 response = requests.get(s3_url) # Transform object normalizer = ImagePrep(response.content) # Write object back to S3 Object Lambda s3 = boto3.client('s3') s3.write_get_object_response(Body=normalizer.response_body, RequestRoute=request_route, RequestToken=request_token)
# -*- coding:utf-8 -*- """ 日志模块 """ from __future__ import unicode_literals from logging import Logger, WARNING, StreamHandler, Formatter __all__ = ['logger', 'unfinished', 'unstable'] logger = Logger('hfut_stu_lib', level=WARNING) sh = StreamHandler() fmt = Formatter('[%(levelname)s]%(filename)s[%(lineno)d]: %(message)s') sh.setFormatter(fmt) logger.addHandler(sh) def unfinished(func): msg = '{:s} 尚未完成, 请勿尝试使用'.format(func.__name__) logger.error(msg) return func def unstable(func): logger.warning('%s 功能尚不稳定, 建议使用时验证结果的正确性', func.__name__) return func
from dataclasses import dataclass from logging import Logger from typing import List log = Logger("domino_cdk.config") def from_loader(name: str, cfg, c: dict): if c: log.warning( f"Warning: Unused/unsupported config entries in {name}: {c}") return cfg def check_leavins(thing, section, obj): if leavins := [x for x in obj if x]: log.warning( f"Warning: Unused/unsupported {thing} in {section}: {leavins}") @dataclass class MachineImage: ami_id: str user_data: str @dataclass class IngressRule: name: str from_port: int to_port: int
from bookmarks_parser import parse from logging import Logger LOGGER = Logger(__name__) # create_logger(__name__) class NetscapeFileUrl: def __init__(self, bookmarks_path): self.last_urls = None self.__bookmarks_json = None self.bookmarks_path = bookmarks_path self.url_title_name = "title" @property def bookmarks(self): """ Bookmarks data :return: """ if not self.__bookmarks_json: LOGGER.debug(self.bookmarks_path) self.__bookmarks_json = parse(self.bookmarks_path) return self.__bookmarks_json def get_folder(self, folder_name): """ Get bookmarks from given folder name :param folder_name: Name of searched folder
#!/usr/bin/env python3 from decimal import Decimal from math import ceil import re from lib.interfaces import QueuedCollector from typing import Any, List from td.client import TDClient from logging import Logger from lib.StateStore import StateStore logger = Logger('OptionCollection') class OptionsCollection(QueuedCollector): def __init__(self, tdclient: TDClient, state_store: StateStore) -> None: super().__init__(tdclient, state_store) @property def batch_size(self) -> int: return 5 def fetch_known_symbols(self) -> List[dict]: """ Discover equities that are Normal or Halted """ instruments = self.state_store.retrieve_optionable() filtered = [ inst for inst in instruments if not inst['exchange'] == 'Pink Sheet'
def __init__(self): self.default_timeout = 60 self.logger = tako_trace_logger.TakoTraceLogger(Logger(__file__))
from logging import Logger if __name__ == '__main__': a = Logger('a') b = Logger('a') pass
def __init__(self): self.logger = Logger() self.logger.writeToLog('starting rogue checking...') pass
b20 except it has additional features that allow sending commands to b10 via one-wire and to pull logs from b10 via one-wire. Please see https://docs.google.com/document/d/17yJeJRNWxv5E9 fBvw0sXkgwCBkshU_l4SxWkKgAxVmk/edit for details about available operations. """ import os import re import time from logging import Logger from acts import utils from acts.controllers.buds_lib import tako_trace_logger logging = tako_trace_logger.TakoTraceLogger(Logger(__file__)) DEVICE_REGEX = ( r'_(?P<device_serial>[A-Z0-9]+)-(?P<interface>\w+)\s->\s' r'(\.\./){2}(?P<port>\w+)' ) # TODO: automate getting the latest version from x20 DEBUG_BRIDGE = ('/google/data/ro/teams/wearables/apollo/ota/jenkins-presubmit/' 'ovyalov/master/apollo-sw/CL14060_v2-build13686/v13686/' 'automation/apollo_debug_bridge/linux2/apollo_debug_bridge') B29_CHIP = 'Cypress_Semiconductor_USBUART' # TODO: # as the need arises, additional functionalities of debug_bridge should be # integrated # TODO:
def __init__(self, ipL=[]): self.ipL = ipL self.logger = Logger() self.hostI = {}
def build_tensorboard(self): from logging import Logger self.logger = Logger(self.log_path)
def test_save(self, _mock_write, _mock_open): config = ArchiveConfig(Logger("test"), "test", "working_dir") self.assertEqual( "test", config.config["Archive"]["code_name"], "code_name config should be set to the provided short code for the archive" )
class Creon: __codes__ = None __db__ = None __utils__ = None __trades__ = None __trade_actions__ = {'sell': '1', 'buy': '2'} __markets__ = None __wallets__ = None __stock_code__ = None __chart__ = None __logger__ = Logger(__name__) def __init__(self, username: str = '', password: str = '', cert_password: str = '', creon_path: str = '', db_path: str = ''): if not windll.shell32.IsUserAnAdmin(): raise PermissionError("Run as administrator") is_64bit = sys.maxsize > 2**32 if is_64bit: raise RuntimeError('Run with 32-bit Python.') if 'CpStart.exe' not in [p.name() for p in process_iter()]: run_creon_plus( username or environ.get('CREON_USERNAME', ''), password or environ.get('CREON_PASSWORD', ''), cert_password or environ.get('CREON_CERTIFICATION_PASSWORD', ''), creon_path or environ.get('CREON_PATH', '')) self.__db__ = MarketTimeDB(db_path) @property def codes(self) -> COMWrapper: if self.__codes__ is None: self.__codes__ = COMWrapper("CpUtil.CpCodeMgr") return self.__codes__ @property def utils(self) -> COMWrapper: if self.__utils__ is None: self.__utils__ = COMWrapper('CpTrade.CpTdUtil') self.__utils__.TradeInit() return self.__utils__ @property def trades(self) -> COMWrapper: if self.__trades__ is None: self.__trades__ = COMWrapper('CpTrade.CpTd0311') return self.__trades__ @property def markets(self) -> COMWrapper: if self.__markets__ is None: self.__markets__ = COMWrapper('DsCbo1.StockMst') return self.__markets__ @property def wallets(self) -> COMWrapper: if self.__wallets__ is None: self.__wallets__ = COMWrapper('CpTrade.CpTd6033') return self.__wallets__ @property def stock_code(self): if self.__stock_code__ is None: self.__stock_code__ = COMWrapper("CpUtil.CpStockCode") return self.__stock_code__ @property def chart(self): if self.__chart__ is None: self.__chart__ = COMWrapper("CpSysDib.StockChart") return self.__chart__ @property def accounts(self) -> tuple: return self.utils.account_number def get_account_flags(self, account: str, account_filter: AccountFilter) -> tuple: # https://money2.creontrade.com/e5/mboard/ptype_basic/HTS_Plus_Helper/DW_Basic_Read_Page.aspx?boardseq=284&seq=154&page=1&searchString=GoodsList&p=8841&v=8643&m=9505 return self.utils.goods_list(account, account_filter) def get_all_codes(self, category: str, with_name: bool = False) -> tuple: # https://money2.creontrade.com/e5/mboard/ptype_basic/HTS_Plus_Helper/DW_Basic_Read_Page.aspx?boardseq=284&seq=11&page=1&searchString=GetStock&p=&v=&m= # example: https://money2.creontrade.com/e5/mboard/ptype_basic/plusPDS/DW_Basic_Read.aspx?boardseq=299&seq=39&page=1&searchString=GetStockListByMarket&prd=&lang=&p=8833&v=8639&m=9505 category = category.lower() if category == 'kospi': section = 1 elif category == 'kosdaq': section = 2 else: raise ValueError codes = self.codes.get_stock_list_by_market(section) if with_name: results = [] for code in codes: results.append((code, self.codes.code_to_name(code))) return tuple(results) return codes def get_price_data(self, code: str) -> dict: # https://money2.creontrade.com/e5/mboard/ptype_basic/HTS_Plus_Helper/DW_Basic_Read_Page.aspx?boardseq=285&seq=3&page=4&searchString=%ed%98%84%ec%9e%ac%ea%b0%80&p=&v=&m= self.markets.set_input_value(0, code) self.markets.block_request() if self.markets.get_dib_status() != 0: self.__logger__.warning(self.markets.get_dib_msg1()) return {} return { 'code': self.markets.get_header_value(0), 'name': self.markets.get_header_value(1), 'time': self.markets.get_header_value(4), 'diff': self.markets.get_header_value(12), # 전일대비 'price': self.markets.get_header_value(13), 'close_price': self.markets.get_header_value(11), 'high_price': self.markets.get_header_value(14), 'low_price': self.markets.get_header_value(15), 'offer': self.markets.get_header_value(16), # 매도 호가 'bid': self.markets.get_header_value(17), # 매수 호과 'volume': self.markets.get_header_value(18), 'volume_price': self.markets.get_header_value(19), 'expect_flag': self.markets.get_header_value(58), # 예상체결가구분플래그 'expect_price': self.markets.get_header_value(55), 'expect_diff': self.markets.get_header_value(56), 'expect_volume': self.markets.get_header_value(57) } def fetch_ohlcv(self, code: str, timeframe: tuple, since: datetime, limit: int, fill_gap=False, use_adjusted_price=True) -> List[Candle]: """ https://money2.creontrade.com/e5/mboard/ptype_basic/HTS_Plus_Helper/DW_Basic_Read_Page.aspx?boardseq=288&seq=102&page=2&searchString=&p=&v=&m= :param code: 종목 코드 :param timeframe: :param since: :param limit: :param fill_gap: 갭보정 여부 :param use_adjusted_price: 수정주가 사용여부 :return: """ if limit > 2856: raise ValueError( "Too big request, increase period_unit or reduce date range") timeframe_timedelta = timeframe_to_timedelta(timeframe) if timeframe[1] == TimeFrameUnit.DAY: to = since + (timeframe_timedelta * limit) - timedelta(minutes=1) # 23시 59분으로 만들기 위해 else: to = since + (timeframe_timedelta * limit) if timeframe[1] in [TimeFrameUnit.MINUTE, TimeFrameUnit.TICK]: market_end = datetime(since.year, since.month, since.day, 15, 21, 0) diff: timedelta = market_end - since count = int(diff.total_seconds()) // timeframe_timedelta.seconds count += 1 else: count = limit count += 1 # 장시작/마감시간 고려하면 하나 더 얻어와야함 request_items = ( "date", "time", "open_price", "high_price", "low_price", "close_price", "volume", ) item_pair = { "date": 0, "time": 1, "open_price": 2, "high_price": 3, "low_price": 4, "close_price": 5, "volume": 8, "volume_price": 9, } interval, unit = timeframe fill_gap = '1' if fill_gap else '0' use_adjusted_price = '1' if use_adjusted_price else '0' self.chart.set_input_value(0, code) self.chart.set_input_value(1, ord('2')) # 갯수로 받아오는 것. '1'(기간)은 일봉만 지원 self.chart.set_input_value(2, int(to.strftime("%Y%m%d"))) # 요청종료일 (가장 최근) self.chart.set_input_value(3, int(since.strftime("%Y%m%d"))) # 요청시작일 self.chart.set_input_value(4, count) # 요청갯수, 최대 2856 건 self.chart.set_input_value( 5, [item_pair.get(key) for key in request_items]) self.chart.set_input_value(6, ord( unit.value)) # '차트 주기 ('D': 일, 'W': 주, 'M': 월, 'm': 분, 'T': 틱) self.chart.set_input_value(7, interval) # 분/틱차트 주기 self.chart.set_input_value(8, ord(fill_gap)) # 갭보정여부, 0: 무보정 self.chart.set_input_value(9, use_adjusted_price) # 수정주가여부, 1: 수정주가 사용 self.chart.set_input_value(10, '1') # 거래량 구분 # '1': 시간외거래량모두포함, '2': 장종료시간외거래량만포함, '3': 시간외거래량모두제외, '4': 장전시간외거래량만포함 self.chart.block_request() if self.chart.get_dib_status() != 0: self.__logger__.warning(self.chart.get_dib_msg1()) return [] chart_data = [] row_cnt = self.chart.get_header_value(3) for i in range(row_cnt): resp = { "date": self.chart.get_data_value(0, i), "time": self.chart.get_data_value(1, i), "open": self.chart.get_data_value(2, i), "high": self.chart.get_data_value(3, i), "low": self.chart.get_data_value(4, i), "close": self.chart.get_data_value(5, i), "volume": self.chart.get_data_value(6, i), } candle: Candle = Candle( start_time=datetime(1970, 1, 1), end_time=datetime(1970, 1, 1), open_price=resp["open"], high_price=resp["high"], low_price=resp["low"], close_price=resp["close"], volume=resp["volume"], ) if unit == TimeFrameUnit.MONTH: raise NotImplementedError() # TODO elif unit == TimeFrameUnit.WEEK: date = str(resp["date"]) year = int(date[:4]) month = int(date[4:6]) nth_week = int(date[6]) nth_friday = Calendar(0).monthdatescalendar(year, month)[nth_week][4] candle["start_time"] = datetime.strptime( str(nth_friday), "%Y-%m-%d") candle["end_time"] = candle["start_time"] + timedelta( weeks=1, hours=23, minutes=59) elif unit == TimeFrameUnit.DAY: candle["start_time"] = datetime.strptime( str(resp["date"]), "%Y%m%d") candle["end_time"] = candle["start_time"] + timedelta( hours=23, minutes=59) else: candle["end_time"] = datetime.strptime( f'{resp["date"]}-{resp["time"]}', "%Y%m%d-%H%M") if candle["end_time"].hour == 15 and candle[ "end_time"].minute == 30: if len(chart_data) > 0: candle["start_time"] = chart_data[0]["end_time"] else: next_date = self.chart.get_data_value(0, i + 1) next_time = self.chart.get_data_value(1, i + 1) candle["start_time"] = datetime.strptime( f'{next_date}-{next_time}', "%Y%m%d-%H%M") else: candle["start_time"] = candle[ "end_time"] - timeframe_timedelta chart_data.insert(0, candle) for ohlcv in chart_data: if ((ohlcv["start_time"] - timeframe_timedelta) < since) or ohlcv["end_time"] > to: chart_data.remove(ohlcv) return chart_data def get_holding_stocks(self, account_number: str, flag: str, count: int = 50) -> dict: # TODO: 평가금액과 잔고까지 리턴하므로 함수명 바꿀 것 # http://money2.daishin.com/e5/mboard/ptype_basic/HTS_Plus_Helper/DW_Basic_Read_Page.aspx?boardseq=284&seq=176&page=1&searchString=CpTrade.CpTd6033&p=8839&v=8642&m=9508 self.wallets.set_input_value(0, account_number) self.wallets.set_input_value(1, flag) self.wallets.set_input_value(2, count) self.wallets.block_request() status = self.wallets.get_dib_status() if status != 0: self.__logger__.warning(self.wallets.get_dib_msg1()) return {} expect_valuation = self.wallets.get_header_value(3) remain_deposit = self.wallets.get_header_value(9) stocks = [] for index in range(self.wallets.get_header_value(7)): stocks.append({ 'code': self.wallets.get_data_value(12, index), 'name': self.wallets.get_data_value(0, index), 'quantity': self.wallets.get_data_value(7, index), 'bought_price': self.wallets.get_data_value(17, index), 'expect_price': self.wallets.get_data_value(9, index), 'expect_profit': self.wallets.get_data_value(11, index) }) result = { "total_expect_valuation": expect_valuation, # 총 평가 금액 "remain_deposit": remain_deposit, # 예수금 "stocks": stocks, # 보유 주식 } return result def _order(self, account: str, code: str, quantity: int, price: int, flag: str, action: str) -> bool: self.trades.set_input_value(0, self.__trade_actions__[action.lower()]) self.trades.set_input_value(1, account) self.trades.set_input_value(2, flag) self.trades.set_input_value(3, code) self.trades.set_input_value(4, quantity) self.trades.set_input_value(5, price) self.trades.set_input_value(7, "0") self.trades.set_input_value(8, "01") self.trades.block_request() if self.trades.get_dib_status() != 0: self.__logger__.warning(self.trades.get_dib_msg1()) return False return True def buy(self, account: str, code: str, quantity: int, price: int, flag: str) -> bool: return self._order(account, code, quantity, price, flag, 'buy') def sell(self, account: str, code: str, quantity: int, price: int, flag: str) -> bool: return self._order(account, code, quantity, price, flag, 'sell') def code_to_name(self, code: str): return self.stock_code.code_to_name(code) def name_to_code(self, name: str): return self.stock_code.name_to_code(name)
"""Based on Consumer Producer pattern""" import datetime import threading import time from logging import Handler, Logger from threading import Thread, Condition from wrapt import synchronized QUEUE = [] condition = Condition() lock = threading.Lock() DISPLAY = False logger = Logger("internal_logger") MAX_SEND_ATTEMPT = 1 class Singleton(type): """ From https://stackoverflow.com/questions/50566934 We need only one ConsumerThread and ServerSender """ _instances = {} def __call__(cls, *args, **kwargs): if cls not in cls._instances: cls._locked_call(*args, **kwargs) return cls._instances[cls]
from csv import reader, writer from docopt import docopt from glob import glob from logging import Logger, StreamHandler from os.path import join, splitext, basename from pkgutil import get_data from shutil import rmtree from subprocess import check_call from sys import stdout, stderr from tempfile import mkdtemp from time import strptime, strftime ### logging ### log = Logger('tecan-extract-table') log.addHandler(StreamHandler(stderr)) ### parse each type of tecan reading ### def parse_readings_single(rows): cols = [] readings = [] for row in rows: if len(cols) > 0: if len(row[0]) == 0 or row[0] == 'End Time:': # reached end of table return readings else: for n in range(len(cols)): well = row[0] + cols[n]
from logging import Logger , FileHandler import logging from django.conf import settings import os logging_settings = settings.DASHBOARD_LOGGING if logging_settings is None: logging_settings = { 'handler':'file', 'filename':'genetherapy.log', 'settings':{ 'path':os.path.join(settings.LOGS_DIR,'logs'), 'encoding':'UTF-8' } } # Define the general logger for screening web application log = Logger('Genetherapy Logger', level=logging.INFO) logging_settings_dir = os.path.join(logging_settings['settings']['path'],logging_settings['filename']) file_handler = FileHandler(logging_settings_dir,mode='wb',encoding=logging_settings['settings']['encoding']) log.addHandler(file_handler)