def day_rate(rowNum: int, colNum: int, sheet: xlrd.sheet.Sheet) -> list:
"""
日收益率函数
:param rowNum:
:param colNum:
:param sheet:
:return:
"""
# 账户日收益率
day_rate_list = []
# 股票数
stock_num = colNum - 3
for i in range(2, rowNum):
cnt = 0
sum_x = 0.0
avg_x = 0.0
# colNum - 2 股票数读取控制
for j in range(1, colNum - 2):
var_type = sheet.cell(i, j).ctype
var = sheet.cell(i, j).value
if var_type and var:
sum_x = sum_x + sheet.cell(i, j).value
avg_x = sum_x / stock_num
day_rate_list.append(avg_x)
return day_rate_list
def __LoadSheet(
self, sheet: xlrd.sheet.Sheet
) -> Tuple[PaymentsData, PaymentsDataErrors]:
payments_data = PaymentsData(self.config)
payments_data_err = PaymentsDataErrors()
# Get column indexes
email_col_idx = self._ColumnToIndex(
self.config.GetValue(BotConfigTypes.PAYMENT_EMAIL_COL))
user_col_idx = self._ColumnToIndex(
self.config.GetValue(BotConfigTypes.PAYMENT_USER_COL))
expiration_col_idx = self._ColumnToIndex(
self.config.GetValue(BotConfigTypes.PAYMENT_EXPIRATION_COL))
# Read each row
for i in range(sheet.nrows):
# Skip header (first row)
if i > 0:
# Get cell values
email = str(sheet.cell_value(i, email_col_idx)).strip()
user = User.FromString(
self.config,
str(sheet.cell_value(i, user_col_idx)).strip())
expiration = sheet.cell_value(i, expiration_col_idx)
# Skip invalid users
if user.IsValid():
self.__AddPayment(i + 1, payments_data, payments_data_err,
email, user, expiration)
return payments_data, payments_data_err
def _get_sheet_data(sh: xlrd.sheet.Sheet, datemode: int) -> pd.DataFrame:
"""Process a Microsoft Excel sheet, returning a Pandas DataFrame
Args:
sh: the sheet to be processed
datemode: integer to pass as argument to _get_row_data()
Returns:
pd.DataFrame: all data in the given sheet with normalized names and
types
"""
maturity = sh.cell_value(0, 1)
if isinstance(maturity, float):
maturity = datetime.datetime(*xlrd.xldate_as_tuple(maturity, datemode))
else:
maturity = datetime.datetime.strptime(maturity, "%d/%m/%Y")
bond, series = sh.name.rsplit(" ", maxsplit=1)
bond = BONDS["aliases"][bond.replace("-", "").lower()] # Fix bonds names
header = tuple(c.value for c in sh.row(1) if c.value != "")
rows = (r for r in itertools.islice(sh.get_rows(), 2, None)
if r[1].ctype != 0 and r[1].value != "")
data = (_get_row_data(row, datemode) for row in rows)
df = pd.DataFrame.from_records(data, columns=header)
df = df.assign(
MaturityDate=maturity,
BondCode=sh.name,
BondName=bond,
BondSeries=series,
)
return df
def _read_sheet(sheet: xlrd.sheet.Sheet, exercise_name: str) -> List[Record]:
"""
Return all candidate records in given sheet
"""
records = []
# 5 is the candidate count
for candidate_index in range(5):
row = 5 + candidate_index * 2
evaluator_name = sheet.cell_value(5, 1)
candidate_name = sheet.cell_value(row, 4).strip()
team_name = _sanitize_team(sheet.cell_value(5, 2))
if not candidate_name:
continue
if candidate_name and not team_name:
raise Exception("Error: No team name")
if team_name and not evaluator_name:
raise Exception("Error: No evaluator name")
evaluation = Evaluation(evaluator_name=evaluator_name,
exercise_name=exercise_name,
learning_ability=_read_attribute(
sheet, row, 5),
personal=_read_attribute(sheet, row, 10),
interpersonal=_read_attribute(sheet, row, 15),
leader=_read_attribute(sheet, row, 20),
summary=_read_attribute(sheet, row, 25))
records.append(Record(candidate_name, team_name, evaluation))
return records
def _parse_oakland_sheet(sheet: xlrd.sheet.Sheet, datemode: int):
"""Parse a single sheet of the Oakland excel file into a dataframe.
Parameters
----------
sheet
The Sheet object from the Book of the Oakland container moves.
datemode
The Book's datemode value (usually 0 or 1).
Returns
-------
pandas.DataFrame
The DataFrame containing all the sheets concatenated together.
"""
# Assume the first 6 rows are just header, and verify that the columns are in order
# date, full imports, full exports, total full, empty imports, empty expots, total empty
# grand total
keys = _verify_oakland_sheet(sheet)
nrow = len(sheet.col(0))
dates = []
data = {k: [] for k in keys}
for irow in range(3, nrow):
year = sheet.cell_value(irow, 0)
month = sheet.cell_value(irow, 1)
if isinstance(month, str) and month == 'Annual Total':
continue
this_date = pd.to_datetime('{} {:.0f}'.format(month, year))
if this_date < pd.Timestamp(1990, 1,
1) or this_date > pd.Timestamp.now():
# This may catch some bad date parsing. I haven't had a problem with this, but want to check (in case they
# change the format unexpectedly).
raise ExcelParsingError('Unexpected date parsed (pre-1990)')
dates.append(this_date)
for k, icol in keys.items():
val = sheet.cell_value(irow, icol)
if isinstance(val, str) and len(val) == 0:
data[k].append(np.nan)
else:
data[k].append(val)
dates = pd.DatetimeIndex(dates)
colname_mapping = {
'Import Full': 'Full Imports',
'Export Full': 'Full Exports',
'Import Empty': 'Empty Imports',
'Export Empty': 'Empty Exports',
'Grand Total': 'Total TEUs'
}
return pd.DataFrame(data, index=dates).drop(
columns=['Total Full', 'Total Empty']).rename(columns=colname_mapping)
def _get_sheet_data(self, sheet: xlrd.sheet.Sheet,
col: int) -> (str, str, str, str):
proto_type = sheet.cell_value(0, col)
define_type = sheet.cell_value(1, col) # 定义的类型
name = sheet.cell_value(2, col) # 字段名
comment = str(sheet.cell_value(4, col)).replace('\n',
'').replace('\r',
'') # 注释
if comment != '':
comment = f' @{comment}'
return proto_type, define_type, name, comment
def read_firm(firm_sheet: xlrd.sheet.Sheet):
"""
Note row & column is 0-index based
:param firm_sheet:
:return:
"""
# get firm name
firm_name = firm_sheet.cell(7, 1).value
# selected data column, 0 based index
if firm_sheet.ncols == 10:
# [存货编号, 存货全名, 采购数量, 价税合计]
selected_columns = [1, 2, 3, 6]
elif firm_sheet.ncols == 11:
selected_columns = [1, 2, 3, 4, 7]
else:
print(firm_sheet.ncols, firm_sheet.name)
raise Exception("Unsupported data sheet format")
rows = []
for i in range(20, firm_sheet.nrows):
row = [firm_name]
for j in selected_columns:
entry = firm_sheet.cell(i, j).value
try:
entry = float(entry)
except Exception:
pass
row.append(entry)
has_empty_data = False
# check empty entry in data
for k in [-2, -1]:
if row[k] == '':
has_empty_data = True
break
if has_empty_data:
continue
# print(row)
row.append(round(row[-1] / row[-2], 2)) # 含税单价 = 价税合计 / 采购数量
rows.append(row)
data_frame = pd.DataFrame(rows, columns=["公司名称"] + [firm_sheet.cell(19, i).value for i in selected_columns] + ["含税单价"])
print(data_frame)
if "基本单位" not in data_frame.columns:
data_frame.insert(3, "基本单位", np.nan, True)
return data_frame
def get_head_line(sheet_data: xlrd.sheet.Sheet):
"""
获取第一行cell数据列表
:param sheet_data:
:return:
"""
return sheet_data.row_values(0, 0, sheet_data.ncols)
def _parse_target(self, sheet: xlrd.sheet.Sheet, key_col: dict,
start_row: int, end_row: int, name: str):
'''
:param sheet: sheet to be parsed
:param key_col: map key_name to column order ex: {"ip": 1, "username": 2}
:param start_row: set to 1 for single thread
:param end_row: set to sheet.nrows for single thread
:return: Flag: Bool, columns_processes: int or error msg
'''
print(
"thread parse target started. start_row: {}, end_row: {}, name: {}"
.format(start_row, end_row, name))
try:
thread_result = []
for row_no in range(start_row, end_row):
row_dict = {}
for key in key_col:
row_dict[key] = sheet.cell_value(row_no, key_col[key])
thread_result.append(row_dict)
self.result_lock.acquire()
self.result += thread_result
print("thread {} result:\n{}\n\n".format(name, thread_result))
self.result_lock.release()
self.thread_state[name] = True
return True, end_row - start_row
except Exception as e:
self.result_lock.acquire()
self.thread_state[name] = True
self.result_lock.release()
return False, e
def build_choices(self, sheet: xlrd.sheet.Sheet, datemode: int) -> None:
"""Parse the tab of ODK choices.
This function modifies the instance attributes `header` and
`choices` if there is something stored in the tab of ODK
chocies.
Args:
sheet: The xlrd sheet object for this sheet
datemode: The xlrd datemode for the workbook
"""
_choices_dict = defaultdict(list)
if sheet is not None:
try:
self.header = self.get_header(sheet, datemode)
for i, row in enumerate(sheet.get_rows()):
if i == 0:
continue
row_values = [
self.cell_to_value(cell, datemode) for cell in row
]
row_dict = {k: v for k, v in zip(self.header, row_values)}
row_list_name = row_dict['list_name']
row_name = row_dict['name']
if str(row_list_name) and str(row_name):
choice_row = XlsFormRow(i, row_name, self.header,
row_values, row_dict)
_choices_dict[row_list_name].append(choice_row)
except IndexError:
# No header row found. Then no choices.
pass
for name, choices in _choices_dict.items():
choice_list = ChoiceList(name, choices, sheet.name)
self.choices[name] = choice_list
def _init_data(self, sheet: xlrd.sheet.Sheet):
flg_first_row = True
for row in sheet.get_rows():
# skip the first row
if flg_first_row:
flg_first_row = False
continue
new_row = {}
for i in range(len(self.fields)):
# to prevent bug when there is an empty cell
if i < len(row):
if row[i].ctype == 3:
c = Cell(datetime.datetime(*xlrd.xldate_as_tuple(row[i].value, sheet.book.datemode)))
c.style.num_format = 'yyyy/mm/dd'
new_row[self.fields[i]] = c
else:
if isinstance(row[i].value, str):
if row[i].value.isnumeric():
print('Warning: Found a number stored in string format, converting...')
new_row[self.fields[i]] = Cell(float(row[i].value))
new_row[self.fields[i]] = Cell(row[i].value)
else:
new_row[self.fields[i]] = ''
self.data_rows.append(new_row)
def _verify_oakland_sheet(sheet: xlrd.sheet.Sheet):
"""Check that a sheet in the Oakland container workbook is laid out as expected.
Raises `ExcelParsingError` if not.
"""
keys = dict()
reasons = []
_cols = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')
# row index, column index, expected contents, whether this column is a column name for the dataframe
checks = [(2, 0, 'Year', False), (2, 1, 'Month', False),
(2, 2, 'Import Full', True), (2, 3, 'Export Full', True),
(2, 4, 'Total Full', True), (2, 5, 'Import Empty', True),
(2, 6, 'Export Empty', True), (2, 7, 'Total Empty', True),
(2, 8, 'Grand Total', True)]
for r, c, val, is_key in checks:
# Replace any whitespace with a single space (e.g. newlines)
sheet_val = re.sub(r'\s+', ' ', sheet.cell_value(r, c))
if sheet_val != val:
msg = '{}{} != {}'.format(_cols[c], r + 1, val)
reasons.append(msg)
elif is_key:
keys[sheet_val] = c
if len(reasons) > 0:
msg = 'Unexpected sheet format ({})'.format(', '.join(reasons))
raise ExcelParsingError(msg)
else:
return keys
def find_in_sheet(val, sheet: xlrd.sheet.Sheet) -> Tuple[int, int]:
"""Return a tuple containing the (row, col) of first match searching row 0, then row 1, etc."""
for row in range(sheet.nrows):
for col in range(sheet.ncols):
if sheet.cell_value(row, col) == val:
return row, col
raise LookupError(f'Value {val} not found in sheet {sheet}')
def get_table_name(sheet_data: xlrd.sheet.Sheet):
"""
直接获取table_name。表格的第一行第一列
:param sheet_data:
:return:
"""
cell_content = sheet_data.cell_value(0, 0)
return cell_content.splitlines()[0]
def _get_current_date_by_field(self, field: dict, sheet: xlrd.sheet.Sheet,
row: int) -> str:
date = sheet.name
if re.search(NIGHT_PATTERN, date):
date = date.split('-')
time = sheet.cell(rowx=row, colx=field['column_number']).value
if time == '':
return ''
time = self._get_correct_time(time)
if datetime.datetime.strptime(time,
TIME_PATTERN).time() >= NIGHT_SHIFT:
if date[1].split(
'.')[0] == '01' and date[1].split('.')[1] != '01':
# TODO: make its better in the future
date = date[0] + '.' + '.'.join(
date[1].split('.')[1:]) + ' ' + time
date = date[:3] + str(int(date[3:5]) - 1) + date[5:]
else:
date = date[0] + '.' + '.'.join(
date[1].split('.')[1:]) + ' ' + time
try:
return datetime.datetime.strptime(date, '%d.%m.%y %H:%M')
except ValueError:
# in this case we resolve problem with mismatch of number of month and number of days
self._logger.warning(
'There are conformity of month and days, check corrects of value'
)
date = date[:3] + str(int(date[3:5]) - 1) + date[5:]
return datetime.datetime.strptime(date, '%d.%m.%y %H:%M')
else:
date = date[1] + ' ' + time
return datetime.datetime.strptime(date, '%d.%m.%y %H:%M')
if re.search(DAY_PATTERN, date):
time = sheet.cell(rowx=row, colx=field['column_number']).value
if not time:
return ''
time = self._get_correct_time(time)
date = date + ' ' + time
return datetime.datetime.strptime(date, '%d.%m.%y %H:%M')
raise TimePatternError(
'There is no such time pattern: {}'.format(date))
def _extract_data(sheet: xlrd.sheet.Sheet) -> DataTable:
"""
Helper function that extracts cell values from an xlrd sheet into a plain array
"""
cols = sheet.ncols
rows = sheet.nrows
return [[sheet.cell_value(row, col) for col in range(0, cols)]
for row in range(0, rows)]
def get_tid_list(sheet_data: xlrd.sheet.Sheet):
"""
获取tid列表
:param sheet_data:
:return:
"""
value_list = sheet_data.col_values(0, 2, sheet_data.nrows)
for i in range(0, len(value_list)):
value_list[i] = int(value_list[i])
return value_list
def load_two_first_columns_preincrement(sheet: xlrd.sheet.Sheet):
"""Reads dataset with X from two first columns, skips first row
:param sheet: xlrd.sheet.Sheet
:return: X, y: [], []
"""
line_number = 0
line = sheet.row(line_number)
number_of_columns = len(line)
X, y = np.zeros((sheet.nrows, 2)), np.zeros(sheet.nrows, dtype=np.int)
while line_number < sheet.nrows - 1:
line_number += 1
line = sheet.row(line_number)
row = []
for i in range(2): # range(number_of_columns - 1):
row.append(float(line[i].value))
X[line_number - 1, :] = row
y[line_number - 1] = int(line[number_of_columns - 1].value)
return X, y
def get_document_title(workbook: xlrd.book.Book,
orderform_sheet: xlrd.sheet.Sheet) -> str:
"""Get the document title for the order form."""
if "information" in workbook.sheet_names():
information_sheet = workbook.sheet_by_name("information")
document_title = information_sheet.row(0)[2].value
return document_title
document_title = orderform_sheet.row(0)[1].value
return document_title
def get_row_values(sheet: xlrd.sheet.Sheet,
rowx: int,
datemode: int = DEFAULT_DATEMODE) -> tuple:
"""Get the values from a row in a sheet.
Returns:
A tuple of cell values. The cell values can be any of str,
bool, int, or float.
"""
row = sheet.row(rowx)
values = (Worksheet.cell_to_value(cell, datemode) for cell in row)
return tuple(values)
def dataCheck(sheet1: xlrd.sheet.Sheet):
checkCmd = True
# 行数检查
if sheet1.nrows < 2:
print("没数据啊哥")
checkCmd = False
# 每行数据检查
i = 1
while i < sheet1.nrows:
# 第1列 操作类型检查
cmdType = sheet1.row(i)[0]
if cmdType.ctype != 2 or int(cmdType.value) not in range(1, 8):
# cmdType.value != 1.0 and cmdType.value != 2.0 and cmdType.value != 3.0
# and cmdType.value != 4.0 and cmdType.value != 5.0 and cmdType.value != 6.0):
print('第', i + 1, "行,第1列数据有毛病")
checkCmd = False
# 第2列 内容检查
cmdValue = sheet1.row(i)[1]
# 读图点击类型指令，内容必须为字符串类型
if cmdType.value == 1.0 or cmdType.value == 2.0 or cmdType.value == 3.0:
if cmdValue.ctype != 1:
print('第', i + 1, "行,第2列数据有毛病")
checkCmd = False
# 输入类型，内容不能为空
if cmdType.value == 4.0:
if cmdValue.ctype == 0:
print('第', i + 1, "行,第2列数据有毛病")
checkCmd = False
# 等待类型，内容必须为数字
if cmdType.value == 5.0:
if cmdValue.ctype != 2:
print('第', i + 1, "行,第2列数据有毛病")
checkCmd = False
# 滚轮事件，内容必须为数字
if cmdType.value == 6.0:
if cmdValue.ctype != 2:
print('第', i + 1, "行,第2列数据有毛病")
checkCmd = False
i += 1
return checkCmd
def transform_data(xlrd_sheet: xlrd.sheet.Sheet) -> io.StringIO:
"""
Function to transform the data into json and stores the json
in a string buffer. The data is written as a list of rows from the
excel sheet with the first row as headers. Returns the string buffer.
Parameters
----------
data_frame: pd.DataFrame
Dataframe object of the excel file. Outputted from the
extract_data_from_excel function.
Returns
-------
string_buffer: StringIO
Dataframe is converted into json string, writtern into a string
buffer and returned.
"""
headers, col_idx = [], 0
while True:
try:
headers.append(xlrd_sheet.cell_value(0, col_idx))
col_idx += 1
except IndexError:
break
data, row_idx = [], 0
while True:
try:
data.append({
col: xlrd_sheet.cell_value(col_idx, row_idx) for col_idx, col in enumerate(headers)
})
row_idx += 1
except IndexError:
break
return io.StringIO(json.dumps(data))
def _parse_sheet(self, sheet: xlrd.sheet.Sheet):
result = []
index_key_map = {}
for col in range(sheet.ncols):
key = sheet.cell_value(0, col)
if key in self.keys:
index_key_map[key] = col
if index_key_map:
for row_no in range(1, sheet.nrows):
row_dict = {}
for key in index_key_map:
if index_key_map.get(key, None) != None:
row_dict[key] = sheet.cell_value(
row_no, index_key_map[key])
else:
row_dict[key] = None
if row_dict:
result.append(row_dict)
return result
else:
return []
def parse_head(self, sheet: xlrd.sheet.Sheet):
field_name = sheet.row(0)
field_type = sheet.row(1)
for i in range(0, len(field_name)):
fname = field_name[i].value
tname = i < len(field_type) and field_type[i].value or ''
if tname == 'null' or fname == '':
continue
ftype = FieldTypeMgr.parse_type_by_name(tname)
if ftype == FieldType.E_None:
continue
cell_head = SheetCellHead()
cell_head.set_data(i, fname, ftype)
self.sheet_heads.append(cell_head)
def _get_next(self,
sheet: xlrd.sheet.Sheet,
col: int,
max: int = -1) -> int:
col = col + 1
if max == -1:
max = sheet.ncols
if col >= max:
return max
proto_type = sheet.cell_value(0, col)
while self._is_skip_col(proto_type):
col = col + 1
if col >= max:
break
proto_type = sheet.cell_value(0, col)
if col >= max:
return max
else:
return col
def get_billing_lines(sheet: xlrd.sheet.Sheet) -> int:
"""Take an xl sheet with a Hydro One bill as input and return the number of billing lines (accounts)"""
lines = 0
try:
row, col = find_in_sheet("Line #", sheet) # this cell should be unique
except LookupError:
raise ValueError(
f'{sheet} does not appear to be a Hydro One bill (no "Line #" cell)'
)
# find number of lines in bill by walking down
row += 1
while sheet.cell_type(row, col) == XLS_FLOAT_TYPE:
row += 1
lines += 1
return lines
def get_name_to_tid_dic(sheet_data: xlrd.sheet.Sheet):
"""
获取名称到tid的映射，如果没有名称则返回空字典
:param sheet_data:
:return:
"""
head_values = get_head_line(sheet_data)
ret_dic = {}
tid_list = get_tid_list(sheet_data)
for cell_value in head_values:
type = get_prop_type(cell_value)
if type is Enum_CellType.NAME:
col = head_values.index(cell_value)
name_list = sheet_data.col_values(col, 2, sheet_data.nrows)
for i in range(0, len(name_list)):
ret_dic[name_list[i]] = tid_list[i]
return ret_dic
def _parse_sheet(self, sheet: xlrd.sheet.Sheet):
index_key_map = {}
for col in range(sheet.ncols):
key = sheet.cell_value(0, col)
if key in self.keys:
index_key_map[key] = col
if self.no_threads == 1:
self._parse_target(sheet=sheet,
key_col=index_key_map,
start_row=1,
end_row=sheet.nrows,
name="main")
return
add_rows = (sheet.nrows - 1) % self.no_threads
no_rows = sheet.nrows - 1 - add_rows
step = int(no_rows / self.no_threads)
for i in range(1, no_rows + 1, step):
end_row = i + step
t = Thread(target=self._parse_target,
kwargs={
"sheet": sheet,
"key_col": index_key_map,
"start_row": i,
"end_row": end_row,
"name": str(i)
},
daemon=True)
t.start()
self.threads[str(i)] = t
if add_rows:
print("---------------------add_rows-----------------")
t_add = Thread(target=self._parse_target,
kwargs={
"sheet": sheet,
"key_col": index_key_map,
"start_row": no_rows + 1,
"end_row": sheet.nrows,
"name": "add_rows"
},
daemon=True)
t_add.start()
self.threads[str(sheet.nrows + 1)] = t_add
def get_data_from_worksheet(worksheet: xlrd.sheet.Sheet):
"""берем матрицу данных из листа таблицы"""
num_rows = worksheet.nrows - 1
num_cells = worksheet.ncols - 1
curr_row = -1
data = []
while curr_row < num_rows:
row = []
curr_row += 1
curr_cell = -1
while curr_cell < num_cells:
curr_cell += 1
cell_value = worksheet.cell_value(curr_row, curr_cell)
row.append(cell_value)
data.append(row)
# если в таблице нет этих элементов значит пользователь пытается использовать другую таблицу
if data[0] != ['с', 'по', 'название', 'описание']:
return []
return data[1:]
def write_cs(self, sheet: xlrd.sheet.Sheet, sheetname):
"""
"""
output_filename = os.path.normpath('{0}/{1}.cs'.format(self.output_path, sheetname))
with open(output_filename, 'w', encoding='utf-8') as targetf:
targetf.write('using System.Collections;\n')
targetf.write('using System.Collections.Generic;\n\n')
if len(self.namespace) > 0:
targetf.write('namespace {0}{1}\n\n'.format(self.namespace, "{"))
targetf.write(' public class {0}{1} \n'.format(sheetname, "{"))
for r in range(0, sheet.nrows): # write class name
for c in range(0, sheet.ncols):
# print ("Cell:", sheet.cell_value(rowx=r, colx=c) )
data = sheet.cell_value(rowx=r, colx=c)
parts = data.partition('.')
data_type = parts[0]
data_real = parts[2]
# if c == sheet.ncols-1:
# sep='\n'
if data_type == Excel2Class.TYPE_IARRAY:
data_type = 'List<int>'
if data_type == Excel2Class.TYPE_FARRAY:
data_type = 'List<float>'
if data_type == Excel2Class.TYPE_DARRAY:
data_type = 'List<double>'
if data_type == Excel2Class.TYPE_SARRAY:
data_type = 'List<string>'
elif data_type == Excel2Class.TYPE_IDIC:
data_type = 'Dictionary<int,int>'
elif data_type == Excel2Class.TYPE_FDIC:
data_type = 'Dictionary<int,float>'
elif data_type == Excel2Class.TYPE_DDIC:
data_type = 'Dictionary<int,double>'
elif data_type == Excel2Class.TYPE_SDIC:
data_type = 'Dictionary<int,string>'
targetf.write(' public {0} {1};\n'.format(data_type, data_real))
break
if len(self.namespace) > 0:
targetf.write(' }')
targetf.write('\n}')
def write_cs(self, sheet: xlrd.sheet.Sheet, sheetname: str):
"""
"""
output_filename = os.path.normpath('{0}/{1}.cs'.format(self.output_path, sheetname))
with open(output_filename, 'w', encoding='utf-8') as targetf:
targetf.write('using System.Collections;\n')
targetf.write('using System.Collections.Generic;\n\n')
if len(self.namespace) > 0:
targetf.write('namespace {0}{1}\n\n'.format(self.namespace, "{"))
targetf.write(' public class {0}{1} \n'.format(sheetname, "{"))
for r in range(0, sheet.nrows): # write class name
for c in range(0, sheet.ncols):
# print ("Cell:", sheet.cell_value(rowx=r, colx=c) )
data = sheet.cell_value(rowx=r, colx=c)
data.strip()
data_type = '' # field type
data_real = '' # field name
if '.' in data:
parts = data.partition('.') # old stype int.id
data_type = parts[0]
data_real = parts[2]
elif ':' in data:
parts = data.partition(':') # new stype id:int
data_type = parts[2]
data_real = parts[0]
# print(data_type, data_real)
# if c == sheet.ncols-1:
# sep='\n'
if data_type == Excel2Class.TYPE_INT32:
data_type = 'int'
if data_type == Excel2Class.TYPE_INT64:
data_type = 'System.Int64'
if data_type == Excel2Class.TYPE_FLOAT:
data_type = 'float'
if data_type == Excel2Class.TYPE_DOUBLE:
data_type = 'double'
if data_type == Excel2Class.TYPE_Bool:
data_type = 'bool'
if data_type == Excel2Class.TYPE_STRING:
data_type = 'string'
if data_type == Excel2Class.TYPE_IARRAY or data_type == 'arr':
data_type = 'List<int>'
if data_type == Excel2Class.TYPE_FARRAY or data_type == 'farr':
data_type = 'List<float>'
if data_type == Excel2Class.TYPE_DARRAY or data_type == 'darr':
data_type = 'List<double>'
if data_type == Excel2Class.TYPE_SARRAY or data_type == 'sarr':
data_type = 'List<string>'
elif data_type == Excel2Class.TYPE_IDIC:
data_type = 'Dictionary<int,int>'
elif data_type == Excel2Class.TYPE_FDIC:
data_type = 'Dictionary<int,float>'
elif data_type == Excel2Class.TYPE_DDIC:
data_type = 'Dictionary<int,double>'
elif data_type == Excel2Class.TYPE_SDIC:
data_type = 'Dictionary<int,string>'
targetf.write(' public {0} {1};\n'.format(data_type, data_real))
break # only scan the first row
if len(self.namespace) > 0:
targetf.write(' }')
targetf.write('\n}')
print('output game info:', output_filename)
def parse_rows(self, sheet: xlrd.sheet.Sheet):
for i in range(3, sheet.nrows):
row_data = SheetRowData(self.sheet_heads)
row_data.parse_row(sheet.row(i))
self.sheet_rows.append(row_data)
