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)
