problem
stringlengths 4.96k
7.57k
| gold_standard_solution
stringclasses 57
values | verification_info
dict | metadata
dict |
|---|---|---|---|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规单元编号: cu_51_2
法律的合规单元内容: {"subject": "上市公司", "condition": "实施要约回购", "constraint": "要约价格不得低于回购股份方案公告日前30个交易日该种股票每日加权平均价的算术平均值", "contextual_info": NaN}
必要的额外信息: 方案公告日按照'决议通过日'计算, 只检查当日情况, 价格的计算也以该日为基准; 计算均价时采用收盘价代表该日价格, 不考虑日内价格变化. 不考虑取不到30个交易日的情况, 一定能取到.
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前30个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_51_2(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_51_2_subject'] = True # 所有公司均为上市公司
df['meu_51_2_condition'] = df['回购方式'] == '要约回购'
df['meu_51_2_constraint'] = None # 默认设为False
# 计算前30日交易均价逻辑（以成交量加权）
# 步骤1：提取有效决议记录
valid_resolutions = df[['公司简称', '决议通过日']].dropna().drop_duplicates()
# 步骤2：计算每个决议对应的30日成交量加权均价
avg_price_list = []
for _, row in valid_resolutions.iterrows():
company = row['公司简称']
resolution_date = row['决议通过日']
# 获取决议日前30个交易日数据
company_data = df[(df['公司简称'] == company) & (df['日期'] < resolution_date)]
sorted_dates = company_data.sort_values('日期', ascending=False)
last_30 = sorted_dates.head(30)
if len(last_30) == 30:
# 计算成交量加权平均收盘价
weighted_avg = (last_30['收盘价'] * last_30['成交量']).sum() / last_30['成交量'].sum()
avg_price_list.append({
'公司简称': company,
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 步骤4：执行价格比较（仅当要约价格和参考价均存在时）
price_mask = df['要约价格'].notna() & df['ref_price'].notna()
df.loc[price_mask, 'meu_51_2_constraint'] = df.loc[price_mask, '要约价格'] >= df.loc[price_mask, 'ref_price']
# 清理临时列
df.drop(columns=['ref_price'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_meu_51_2(df):
'''
验证MEU_51_2合规性：
- subject: 上市公司（所有行自动满足）
- condition: 实施要约回购（回购方式为要约回购）
- constraint: 要约价格不低于方案公告日前30个交易日平均价
'''
df = df.copy()
# 初始化标记列
df['meu_51_2_subject'] = True # 所有公司均为上市公司
df['meu_51_2_condition'] = df['回购方式'] == '要约回购'
df['meu_51_2_constraint'] = None # 默认设为False
# 计算前30日交易均价逻辑（以成交量加权）
# 步骤1：提取有效决议记录
valid_resolutions = df[['公司简称', '决议通过日']].dropna().drop_duplicates()
# 步骤2：计算每个决议对应的30日成交量加权均价
avg_price_list = []
for _, row in valid_resolutions.iterrows():
company = row['公司简称']
resolution_date = row['决议通过日']
# 获取决议日前30个交易日数据
company_data = df[(df['公司简称'] == company) & (df['日期'] < resolution_date)]
sorted_dates = company_data.sort_values('日期', ascending=False)
last_30 = sorted_dates.head(30)
if len(last_30) == 30:
# 计算成交量加权平均收盘价
weighted_avg = (last_30['收盘价'] * last_30['成交量']).sum() / last_30['成交量'].sum()
avg_price_list.append({
'公司简称': company,
'决议通过日': resolution_date,
'ref_price': weighted_avg
})
# 步骤3：合并参考价格到主表
if avg_price_list:
ref_df = pd.DataFrame(avg_price_list)
df = df.merge(ref_df, on=['公司简称', '决议通过日'], how='left')
# 步骤4：执行价格比较（仅当要约价格和参考价均存在时）
price_mask = df['要约价格'].notna() & df['ref_price'].notna()
df.loc[price_mask, 'meu_51_2_constraint'] = df.loc[price_mask, '要约价格'] >= df.loc[price_mask, 'ref_price']
# 清理临时列
df.drop(columns=['ref_price'], inplace=True)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_51_2",
"derived_derived_id": 4,
"derived_id": 0,
"id": "cu_51_2_0",
"law_article_id": 51,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一：（一）收盘价低于每股净资产；（二）20交易日累计跌幅20%
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 合并有效约束条件
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_4_1_1",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_4_1(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 合并有效约束条件
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一：（一）收盘价低于每股净资产；（二）20交易日累计跌幅20%
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 合并有效约束条件
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_4_1_1",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 合并有效约束条件
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一：（一）收盘价低于每股净资产；（二）20交易日累计跌幅20%
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 合并有效约束条件
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_4_1_1",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 合并有效约束条件
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一：（一）收盘价低于每股净资产；（二）20交易日累计跌幅20%
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 合并有效约束条件
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_4_1_1",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_4_1(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一：（一）收盘价低于每股净资产；（二）20交易日累计跌幅20%
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 合并有效约束条件
valid_constraint = condition1 | condition2
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_4_1_1",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）公司股票收盘价格低于最近一年股票最高收盘价格的50%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件
valid_constraint = condition1 | condition3
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_4_1_2",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）公司股票收盘价格低于最近一年股票最高收盘价格的50%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件
valid_constraint = condition1 | condition3
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件
valid_constraint = condition1 | condition3
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_4_1_2",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）公司股票收盘价格低于最近一年股票最高收盘价格的50%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件
valid_constraint = condition1 | condition3
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_4_1_2",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）公司股票收盘价格低于最近一年股票最高收盘价格的50%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件
valid_constraint = condition1 | condition3
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_4_1_2",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）公司股票收盘价格低于最近一年股票最高收盘价格的50%；","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_4_1(df):
'''
检查MEU_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 通过了维护公司价值及股东权益所必需的回购决议
- constraint: 需满足两个价格条件之一
'''
df = df.copy()
# 初始化合规标记列
df['meu_4_1_subject'] = True # 所有记录均为上市公司
df['meu_4_1_condition'] = False
df['meu_4_1_constraint'] = None
# 标记condition条件（存在特定目的的回购方案）
valid_condition = (df['存在回购方案'] & (df['回购用途'] == '维护公司价值及股东权益所必需') & (df['日期'] == df['决议通过日']))
df['meu_4_1_condition'] = valid_condition
# 计算constraint的两个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件
valid_constraint = condition1 | condition3
# 标记constraint列
df['meu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_4_1_2",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 实施竞价回购
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在竞价回购的回购方案）
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 0,
"derived_id": 3,
"id": "cu_4_1_3",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 实施竞价回购
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_4_1_constraint'] = None
# 标记condition条件（存在竞价回购的回购方案）
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 实施竞价回购
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在竞价回购的回购方案）
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 1,
"derived_id": 3,
"id": "cu_4_1_3",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 实施竞价回购
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在竞价回购的回购方案）
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 实施竞价回购
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在竞价回购的回购方案）
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 2,
"derived_id": 3,
"id": "cu_4_1_3",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_4_1(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 实施竞价回购
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在竞价回购的回购方案）
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 3,
"derived_id": 3,
"id": "cu_4_1_3",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 实施竞价回购
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在竞价回购的回购方案）
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 实施竞价回购
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在竞价回购的回购方案）
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购') &
(df['日期'] == df['决议通过日'])
)
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 4,
"derived_id": 3,
"id": "cu_4_1_3",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 存在回购方案
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在回购方案）
valid_condition = (df['存在回购方案'] & (df['日期'] == df['决议通过日']))
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 0,
"derived_id": 4,
"id": "cu_4_1_4",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 存在回购方案
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在回购方案）
valid_condition = (df['存在回购方案'] & (df['日期'] == df['决议通过日']))
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 存在回购方案
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在回购方案）
valid_condition = (df['存在回购方案'] & (df['日期'] == df['决议通过日']))
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 1,
"derived_id": 4,
"id": "cu_4_1_4",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 存在回购方案
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在回购方案）
valid_condition = (df['存在回购方案'] & (df['日期'] == df['决议通过日']))
df['cu_4_1_condition'] = valid_condition
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 存在回购方案
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在回购方案）
valid_condition = (df['存在回购方案'] & (df['日期'] == df['决议通过日']))
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 2,
"derived_id": 4,
"id": "cu_4_1_4",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 存在回购方案
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 存在回购方案
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在回购方案）
valid_condition = (df['存在回购方案'] & (df['日期'] == df['决议通过日']))
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 3,
"derived_id": 4,
"id": "cu_4_1_4",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_4_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。","contextual_info": null}
必要的额外信息: 1. 决议通过日当日检查. 简化假设; 股价以收盘价为准, 不考虑日内价格变化
2. 不考虑（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。3. 一年按照250个交易日计算. 4. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_4_1(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在回购方案）
valid_condition = (df['存在回购方案'] & (df['日期'] == df['决议通过日']))
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
- subject: 上市公司（所有记录自动满足）
- condition: 存在回购方案
- constraint: 需满足四个价格条件之一（仅验证前三项）
'''
df = df.copy()
# 初始化合规标记列
df['cu_4_1_subject'] = True # 所有记录均为上市公司
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 标记condition条件（存在回购方案）
valid_condition = (df['存在回购方案'] & (df['日期'] == df['决议通过日']))
df['cu_4_1_condition'] = valid_condition
# 计算constraint的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
price_drop = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = price_drop <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）
valid_constraint = condition1 | condition2 | condition3
# 标记constraint列
df['cu_4_1_constraint'] = valid_constraint.astype(bool)
# 清理中间计算列
df.drop(['20d_prior_close', '1y_high'], axis=1, inplace=True, errors='ignore')
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_4_1",
"derived_derived_id": 4,
"derived_id": 4,
"id": "cu_4_1_4",
"law_article_id": 4,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满7个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满7个月时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满7个月）
# 计算上市日期+7个月后的日期
seven_months_after = df['上市日期'] + pd.DateOffset(months=7)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= seven_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_13_1_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满7个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满7个月时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满7个月）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满7个月时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满7个月）
# 计算上市日期+7个月后的日期
seven_months_after = df['上市日期'] + pd.DateOffset(months=7)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= seven_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_13_1_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满7个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满7个月）
# 计算上市日期+7个月后的日期
seven_months_after = df['上市日期'] + pd.DateOffset(months=7)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= seven_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满7个月时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满7个月）
# 计算上市日期+7个月后的日期
seven_months_after = df['上市日期'] + pd.DateOffset(months=7)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= seven_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_13_1_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满7个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满7个月时满足constraint
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
valid_constraint = df['日期'] >= seven_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满7个月时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满7个月）
# 计算上市日期+7个月后的日期
seven_months_after = df['上市日期'] + pd.DateOffset(months=7)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= seven_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_13_1_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满7个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 标记constraint条件（上市满7个月）
# 计算上市日期+7个月后的日期
seven_months_after = df['上市日期'] + pd.DateOffset(months=7)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= seven_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满7个月
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满7个月时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满7个月）
# 计算上市日期+7个月后的日期
seven_months_after = df['上市日期'] + pd.DateOffset(months=7)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= seven_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_13_1_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满18个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满18个月（一个月按30自然日计算）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满18个月（按540自然日计算）时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满18个月，按30天/月计算）
# 计算上市日期+540自然日后的日期
eighteen_months_after = df['上市日期'] + pd.DateOffset(days=540)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_13_1_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满18个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满18个月（一个月按30自然日计算）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满18个月（按540自然日计算）时满足constraint
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满18个月，按30天/月计算）
# 计算上市日期+540自然日后的日期
eighteen_months_after = df['上市日期'] + pd.DateOffset(days=540)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满18个月（一个月按30自然日计算）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满18个月（按540自然日计算）时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满18个月，按30天/月计算）
# 计算上市日期+540自然日后的日期
eighteen_months_after = df['上市日期'] + pd.DateOffset(days=540)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_13_1_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满18个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满18个月（按540自然日计算）时满足constraint
'''
df = df.copy()
# 初始化标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满18个月，按30天/月计算）
# 计算上市日期+540自然日后的日期
eighteen_months_after = df['上市日期'] + pd.DateOffset(days=540)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满18个月（一个月按30自然日计算）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满18个月（按540自然日计算）时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满18个月，按30天/月计算）
# 计算上市日期+540自然日后的日期
eighteen_months_after = df['上市日期'] + pd.DateOffset(days=540)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_13_1_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满18个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满18个月（按540自然日计算）时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满18个月（一个月按30自然日计算）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满18个月（按540自然日计算）时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满18个月，按30天/月计算）
# 计算上市日期+540自然日后的日期
eighteen_months_after = df['上市日期'] + pd.DateOffset(days=540)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_13_1_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满18个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满18个月，按30天/月计算）
# 计算上市日期+540自然日后的日期
eighteen_months_after = df['上市日期'] + pd.DateOffset(days=540)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证cu_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满18个月（一个月按30自然日计算）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满18个月（按540自然日计算）时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满18个月，按30天/月计算）
# 计算上市日期+540自然日后的日期
eighteen_months_after = df['上市日期'] + pd.DateOffset(days=540)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= eighteen_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_13_1_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满6个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满6个月（按每月30天计算，共180天）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满180天时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
six_months_after = df['上市日期'] + pd.DateOffset(days=180)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= six_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 0,
"derived_id": 3,
"id": "cu_13_1_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满6个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满6个月（按每月30天计算，共180天）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满180天时满足constraint
'''
df = df.copy()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
six_months_after = df['上市日期'] + pd.DateOffset(days=180)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= six_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满6个月（按每月30天计算，共180天）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满180天时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
six_months_after = df['上市日期'] + pd.DateOffset(days=180)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= six_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 1,
"derived_id": 3,
"id": "cu_13_1_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满6个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满180天时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
six_months_after = df['上市日期'] + pd.DateOffset(days=180)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= six_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满6个月（按每月30天计算，共180天）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满180天时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
six_months_after = df['上市日期'] + pd.DateOffset(days=180)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= six_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 2,
"derived_id": 3,
"id": "cu_13_1_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满6个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
six_months_after = df['上市日期'] + pd.DateOffset(days=180)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= six_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满6个月（按每月30天计算，共180天）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满180天时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
six_months_after = df['上市日期'] + pd.DateOffset(days=180)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= six_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 3,
"derived_id": 3,
"id": "cu_13_1_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司股票上市已满6个月","contextual_info": null}
必要的额外信息: 6个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满6个月（按每月30天计算，共180天）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
3. 当当前日期距离上市日期满180天时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_cu_13_1(df):
'''
验证CU_13_1合规性:
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 上市已满6个月（按每月30天计算，共180天）
参数说明:
df: 包含公司每日状态的面板数据，必须包含['上市日期','日期','回购方式']列
验证逻辑:
1. 所有公司默认满足subject条件（均为上市公司）
2. 当回购方式为竞价交易时满足condition
3. 当当前日期距离上市日期满180天时满足constraint
'''
df = df.copy()
# 初始化标记列
df['cu_13_1_subject'] = True # 所有公司均为上市公司
df['cu_13_1_condition'] = False
df['cu_13_1_constraint'] = None
# 标记condition条件（实施竞价回购）
is_auction_repurchase = df['回购方式'] == '竞价回购'
df.loc[is_auction_repurchase, 'cu_13_1_condition'] = True
# 标记constraint条件（上市满180天）
# 计算上市日期+180天后的日期（每月按30天计算）
six_months_after = df['上市日期'] + pd.DateOffset(days=180)
# 比较当前日期是否满足时间要求（包含等于）
valid_constraint = df['日期'] >= six_months_after
df.loc[valid_constraint, 'cu_13_1_constraint'] = True
df.loc[~valid_constraint, 'cu_13_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_1",
"derived_derived_id": 4,
"derived_id": 3,
"id": "cu_13_1_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近2年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近2年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['cu_13_2_subject'] = True # 所有公司均为上市公司
df['cu_13_2_condition'] = False
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_13_2_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近2年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化标记列
df['cu_13_2_subject'] = True # 所有公司均为上市公司
df['cu_13_2_condition'] = False
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近2年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['cu_13_2_subject'] = True # 所有公司均为上市公司
df['cu_13_2_condition'] = False
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_13_2_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近2年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近2年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近2年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['cu_13_2_subject'] = True # 所有公司均为上市公司
df['cu_13_2_condition'] = False
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_13_2_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近2年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化标记列
df['cu_13_2_subject'] = True # 所有公司均为上市公司
df['cu_13_2_condition'] = False
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近2年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['cu_13_2_subject'] = True # 所有公司均为上市公司
df['cu_13_2_condition'] = False
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_13_2_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近2年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近2年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['cu_13_2_subject'] = True # 所有公司均为上市公司
df['cu_13_2_condition'] = False
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_13_2_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近2年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
返回：
添加合规性标记后的DataFrame
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_cu_13_2(df):
'''
合规性检查函数，针对cu_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近2年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['cu_13_2_subject'] = True # 所有公司均为上市公司
df['cu_13_2_condition'] = False
df['cu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'cu_13_2_condition'] = True
# constraint: 最近2年无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(years=2)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['cu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 5,
"derived_id": 1,
"id": "cu_13_2_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_13_2_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_13_2_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_13_2_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_13_2_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_13_2_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 实施竞价回购
- constraint: 最近365个自然日内无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 实施竞价回购
valid_condition = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日内无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365) # 改为自然日计算
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 5,
"derived_id": 2,
"id": "cu_13_2_2",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 存在回购方案
valid_condition = df['存在回购方案']
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 0,
"derived_id": 3,
"id": "cu_13_2_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 存在回购方案
valid_condition = df['存在回购方案']
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 存在回购方案
valid_condition = df['存在回购方案']
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 1,
"derived_id": 3,
"id": "cu_13_2_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 存在回购方案
valid_condition = df['存在回购方案']
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 存在回购方案
valid_condition = df['存在回购方案']
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 2,
"derived_id": 3,
"id": "cu_13_2_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 存在回购方案
valid_condition = df['存在回购方案']
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 3,
"derived_id": 3,
"id": "cu_13_2_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 存在回购方案
valid_condition = df['存在回购方案']
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 4,
"derived_id": 3,
"id": "cu_13_2_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "存在回购方案","constraint": "应当符合公司最近1年无重大违法行为","contextual_info": null}
必要的额外信息: 年按照自然年计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
from bisect import bisect_left, bisect_right
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
```python
import pandas as pd
from bisect import bisect_left, bisect_right
def check_meu_13_2(df):
'''
合规性检查函数，针对MEU_13_2条款：
- subject: 上市公司
- condition: 存在回购方案
- constraint: 最近1年无重大违法行为
参数说明：
df : 包含上市公司每日状态数据的DataFrame
返回：
添加合规性标记后的DataFrame
'''
df = df.copy()
# 初始化标记列
df['meu_13_2_subject'] = True # 所有公司均为上市公司
df['meu_13_2_condition'] = False
df['meu_13_2_constraint'] = None
# condition: 存在回购方案
valid_condition = df['存在回购方案']
df.loc[valid_condition, 'meu_13_2_condition'] = True
# constraint: 最近365个自然日无重大违法行为
# 预处理：获取每个公司的重大违法日期列表（已排序）
df_sorted = df.sort_values(['公司简称', '日期'])
violation_mask = df_sorted['公司法律情况'] == '重大违法行为'
violations = df_sorted[violation_mask][['公司简称', '日期']]
# 将日期转换为Timestamp并排序存储
violation_dict = violations.groupby('公司简称')['日期'].apply(
lambda x: sorted(pd.to_datetime(x).tolist())
).to_dict()
# 定义检查函数（使用二分查找优化）
def check_constraint(row):
company = row['公司简称']
current_date = pd.to_datetime(row['日期'])
start_date = current_date - pd.DateOffset(days=365)
# 获取该公司的违法日期列表
v_dates = violation_dict.get(company, [])
if not v_dates:
return True
# 执行二分查找
left = bisect_left(v_dates, start_date)
right = bisect_right(v_dates, current_date)
return not (left < right) # 存在违法时返回False
# 计算约束条件标记
df['meu_13_2_constraint'] = df.apply(check_constraint, axis=1)
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_2",
"derived_derived_id": 5,
"derived_id": 3,
"id": "cu_13_2_3",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需","constraint": "不适用股票上市已满6个月的要求","contextual_info": null}
必要的额外信息: constraint项保留为None不做处理; 不考虑减少注册资本的情况; 触及本指引第四条理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_4_1】
{"subject": "上市公司", "condition": "因维护公司价值及股东权益所必需回购股份的", "constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。", "contextual_info": NaN}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_meu_13_7(df):
'''
合规性检查函数，用于验证MEU_13_7条款的遵守情况
subject: 上市公司
condition: 因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需
constraint: 不适用股票上市已满6个月的要求
'''
df = df.copy()
# 初始化标记列
df['meu_13_7_subject'] = True # 所有公司均为上市公司
df['meu_13_7_condition'] = False
df['meu_13_7_constraint'] = None
# 计算第四条的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）并叠加回购条件
valid_condition = (
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需')
)
# 记录condition
df['meu_13_7_condition'] = valid_condition
# 约束验证：默认为None
df['meu_13_7_constraint'] = None
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_7",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_13_7_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需","constraint": "不适用股票上市已满6个月的要求","contextual_info": null}
必要的额外信息: constraint项保留为None不做处理; 不考虑减少注册资本的情况; 触及本指引第四条理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_4_1】
{"subject": "上市公司", "condition": "因维护公司价值及股东权益所必需回购股份的", "constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。", "contextual_info": NaN}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
condition: 因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需
constraint: 不适用股票上市已满6个月的要求
'''
df = df.copy()
# 初始化标记列
df['meu_13_7_subject'] = True # 所有公司均为上市公司
df['meu_13_7_condition'] = False
df['meu_13_7_constraint'] = None
# 计算第四条的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）并叠加回购条件
valid_condition = (
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需')
)
# 记录condition
df['meu_13_7_condition'] = valid_condition
# 约束验证：默认为None
df['meu_13_7_constraint'] = None
return df
```
|
```python
import pandas as pd
def check_meu_13_7(df):
'''
合规性检查函数，用于验证MEU_13_7条款的遵守情况
subject: 上市公司
condition: 因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需
constraint: 不适用股票上市已满6个月的要求
'''
df = df.copy()
# 初始化标记列
df['meu_13_7_subject'] = True # 所有公司均为上市公司
df['meu_13_7_condition'] = False
df['meu_13_7_constraint'] = None
# 计算第四条的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）并叠加回购条件
valid_condition = (
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需')
)
# 记录condition
df['meu_13_7_condition'] = valid_condition
# 约束验证：默认为None
df['meu_13_7_constraint'] = None
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_7",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_13_7_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需","constraint": "不适用股票上市已满6个月的要求","contextual_info": null}
必要的额外信息: constraint项保留为None不做处理; 不考虑减少注册资本的情况; 触及本指引第四条理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_4_1】
{"subject": "上市公司", "condition": "因维护公司价值及股东权益所必需回购股份的", "constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。", "contextual_info": NaN}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_13_7(df):
'''
合规性检查函数，用于验证MEU_13_7条款的遵守情况
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_13_7_subject'] = True # 所有公司均为上市公司
df['meu_13_7_condition'] = False
df['meu_13_7_constraint'] = None
# 计算第四条的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需')
)
# 记录condition
df['meu_13_7_condition'] = valid_condition
# 约束验证：默认为None
df['meu_13_7_constraint'] = None
return df
```
|
```python
import pandas as pd
def check_meu_13_7(df):
'''
合规性检查函数，用于验证MEU_13_7条款的遵守情况
subject: 上市公司
condition: 因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需
constraint: 不适用股票上市已满6个月的要求
'''
df = df.copy()
# 初始化标记列
df['meu_13_7_subject'] = True # 所有公司均为上市公司
df['meu_13_7_condition'] = False
df['meu_13_7_constraint'] = None
# 计算第四条的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）并叠加回购条件
valid_condition = (
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需')
)
# 记录condition
df['meu_13_7_condition'] = valid_condition
# 约束验证：默认为None
df['meu_13_7_constraint'] = None
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_7",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_13_7_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需","constraint": "不适用股票上市已满6个月的要求","contextual_info": null}
必要的额外信息: constraint项保留为None不做处理; 不考虑减少注册资本的情况; 触及本指引第四条理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_4_1】
{"subject": "上市公司", "condition": "因维护公司价值及股东权益所必需回购股份的", "constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。", "contextual_info": NaN}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_13_7(df):
'''
合规性检查函数，用于验证MEU_13_7条款的遵守情况
subject: 上市公司
condition: 因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需
constraint: 不适用股票上市已满6个月的要求
'''
df = df.copy()
# 初始化标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）并叠加回购条件
valid_condition = (
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_meu_13_7(df):
'''
合规性检查函数，用于验证MEU_13_7条款的遵守情况
subject: 上市公司
condition: 因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需
constraint: 不适用股票上市已满6个月的要求
'''
df = df.copy()
# 初始化标记列
df['meu_13_7_subject'] = True # 所有公司均为上市公司
df['meu_13_7_condition'] = False
df['meu_13_7_constraint'] = None
# 计算第四条的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）并叠加回购条件
valid_condition = (
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需')
)
# 记录condition
df['meu_13_7_condition'] = valid_condition
# 约束验证：默认为None
df['meu_13_7_constraint'] = None
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_7",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_13_7_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_13_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需","constraint": "不适用股票上市已满6个月的要求","contextual_info": null}
必要的额外信息: constraint项保留为None不做处理; 不考虑减少注册资本的情况; 触及本指引第四条理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_4_1】
{"subject": "上市公司", "condition": "因维护公司价值及股东权益所必需回购股份的", "constraint": "应当符合以下条件之一：（一）公司股票收盘价格低于最近一期每股净资产；（二）连续20个交易日内公司股票收盘价格跌幅累计达到20%；（三）公司股票收盘价格低于最近一年股票最高收盘价格的50%；（四）中国证券监督管理委员会（以下简称中国证监会）规定的其他条件。", "contextual_info": NaN}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_13_7(df):
'''
合规性检查函数，用于验证MEU_13_7条款的遵守情况
subject: 上市公司
condition: 因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需
constraint: 不适用股票上市已满6个月的要求
'''
df = df.copy()
# 初始化标记列
df['meu_13_7_subject'] = True # 所有公司均为上市公司
df['meu_13_7_condition'] = False
df['meu_13_7_constraint'] = None
# 计算第四条的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_meu_13_7(df):
'''
合规性检查函数，用于验证MEU_13_7条款的遵守情况
subject: 上市公司
condition: 因触及本指引第四条规定条件而启动回购且用途为维护公司价值及股东权益所必需
constraint: 不适用股票上市已满6个月的要求
'''
df = df.copy()
# 初始化标记列
df['meu_13_7_subject'] = True # 所有公司均为上市公司
df['meu_13_7_condition'] = False
df['meu_13_7_constraint'] = None
# 计算第四条的三个可验证条件
# 条件1：收盘价低于每股净资产
condition1 = df['收盘价'] < df['每股净资产']
# 条件2：20交易日累计跌幅20%（按公司分组计算）
df['20d_prior_close'] = df.groupby('公司简称')['收盘价'].shift(20)
return_20_day = (df['收盘价'] - df['20d_prior_close']) / df['20d_prior_close']
condition2 = return_20_day <= -0.2
# 条件3：低于一年最高价50%（滚动250交易日窗口）
df['1y_high'] = df.groupby('公司简称')['收盘价'].transform(
lambda x: x.rolling(250, min_periods=1).max()
)
condition3 = df['收盘价'] < (df['1y_high'] * 0.5)
# 合并有效约束条件（前三项）并叠加回购条件
valid_condition = (
(condition1 | condition2 | condition3) &
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需')
)
# 记录condition
df['meu_13_7_condition'] = valid_condition
# 约束验证：默认为None
df['meu_13_7_constraint'] = None
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_13_7",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_13_7_1",
"law_article_id": 13,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": null,"constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = True # 无条件要求，全部视为满足
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_15_2_1",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": null,"constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = True # 无条件要求，全部视为满足
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_15_2_1",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": null,"constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = True # 无条件要求，全部视为满足
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = True # 无条件要求，全部视为满足
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_15_2_1",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": null,"constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = True # 无条件要求，全部视为满足
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_15_2_1",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": null,"constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查CU_15_2合规性:
subject: 上市公司
condition: NaN(无条件触发)
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = True # 无条件要求，全部视为满足
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_15_2_1",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施竞价回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
(df['回购数量下限'] >= df['回购数量上限'] * 0.8) &
df['回购数量上限'].notna()
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
(df['资金总额下限'] >= df['资金总额上限'] * 0.8) &
df['资金总额上限'].notna()
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_15_2_2",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施竞价回购
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
(df['回购数量下限'] >= df['回购数量上限'] * 0.8) &
df['回购数量上限'].notna()
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
(df['资金总额下限'] >= df['资金总额上限'] * 0.8) &
df['资金总额上限'].notna()
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施竞价回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
(df['回购数量下限'] >= df['回购数量上限'] * 0.8) &
df['回购数量上限'].notna()
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
(df['资金总额下限'] >= df['资金总额上限'] * 0.8) &
df['资金总额上限'].notna()
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_15_2_2",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 计算数量合规性 (下限≥80%上限)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(df['资金总额下限'] >= df['资金总额上限'] * 0.8) &
df['资金总额上限'].notna()
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施竞价回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
(df['回购数量下限'] >= df['回购数量上限'] * 0.8) &
df['回购数量上限'].notna()
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
(df['资金总额下限'] >= df['资金总额上限'] * 0.8) &
df['资金总额上限'].notna()
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_15_2_2",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施竞价回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df['cu_15_2_constraint'] = None # 初始化为None
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
quantity_valid = (
(df['回购数量下限'] >= df['回购数量上限'] * 0.8) &
df['回购数量上限'].notna()
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施竞价回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
(df['回购数量下限'] >= df['回购数量上限'] * 0.8) &
df['回购数量上限'].notna()
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
(df['资金总额下限'] >= df['资金总额上限'] * 0.8) &
df['资金总额上限'].notna()
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_15_2_2",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施竞价回购
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
(df['回购数量下限'] >= df['回购数量上限'] * 0.8) &
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施竞价回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
(df['回购数量下限'] >= df['回购数量上限'] * 0.8) &
df['回购数量上限'].notna()
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
(df['资金总额下限'] >= df['资金总额上限'] * 0.8) &
df['资金总额上限'].notna()
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
# 处理非竞价回购但存在方案的情况
other_repo_mask = df['存在回购方案'] & ~(df['回购方式'] == '竞价回购')
df.loc[other_repo_mask, 'cu_15_2_constraint'] = True
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_15_2_2",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False
df['cu_15_2_constraint'] = None # 初始化为None
# 1. 验证触发条件
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 2. 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 0,
"derived_id": 3,
"id": "cu_15_2_3",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False
df['cu_15_2_constraint'] = None # 初始化为None
# 1. 验证触发条件
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 2. 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False
df['cu_15_2_constraint'] = None # 初始化为None
# 1. 验证触发条件
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 2. 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 1,
"derived_id": 3,
"id": "cu_15_2_3",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False
df['cu_15_2_constraint'] = None # 初始化为None
# 1. 验证触发条件
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 2. 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 2,
"derived_id": 3,
"id": "cu_15_2_3",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 2. 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False
df['cu_15_2_constraint'] = None # 初始化为None
# 1. 验证触发条件
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 2. 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 3,
"derived_id": 3,
"id": "cu_15_2_3",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得低于上限的80%","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 1. 验证触发条件
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 2. 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2的合规性：
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≥80%上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False
df['cu_15_2_constraint'] = None # 初始化为None
# 1. 验证触发条件
valid_condition = (
df['存在回购方案'] &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 2. 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 计算数量合规性 (下限≥80%上限)
quantity_valid = (
df['回购数量下限'] >= df['回购数量上限'] * 0.8
) & (
df['回购数量上限'].notna() # 确保已明确设置数量上限
)
# 计算资金合规性 (下限≥80%上限)
funds_valid = (
df['资金总额下限'] >= df['资金总额上限'] * 0.8
) & (
df['资金总额上限'].notna() # 确保已明确设置资金上限
)
# 合并合规条件
combined_valid = quantity_valid | funds_valid
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 4,
"derived_id": 3,
"id": "cu_15_2_3",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得高于上限","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False，根据条件设置
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 验证触发条件
valid_condition = (
mask &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 计算约束条件
quantity_valid = (
(df['回购数量上限'].isna()) |
(df['回购数量下限'] <= df['回购数量上限'])
)
funds_valid = (
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 0,
"derived_id": 4,
"id": "cu_15_2_4",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得高于上限","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
df = df.copy()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 验证触发条件
valid_condition = (
mask &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 计算约束条件
quantity_valid = (
(df['回购数量上限'].isna()) |
(df['回购数量下限'] <= df['回购数量上限'])
)
funds_valid = (
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False，根据条件设置
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 验证触发条件
valid_condition = (
mask &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 计算约束条件
quantity_valid = (
(df['回购数量上限'].isna()) |
(df['回购数量下限'] <= df['回购数量上限'])
)
funds_valid = (
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 1,
"derived_id": 4,
"id": "cu_15_2_4",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得高于上限","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 验证触发条件
valid_condition = (
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(df['回购数量上限'].isna()) |
(df['回购数量下限'] <= df['回购数量上限'])
)
funds_valid = (
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False，根据条件设置
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 验证触发条件
valid_condition = (
mask &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 计算约束条件
quantity_valid = (
(df['回购数量上限'].isna()) |
(df['回购数量下限'] <= df['回购数量上限'])
)
funds_valid = (
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 2,
"derived_id": 4,
"id": "cu_15_2_4",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得高于上限","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
mask = df['存在回购方案']
# 验证触发条件
valid_condition = (
mask &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False，根据条件设置
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 验证触发条件
valid_condition = (
mask &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 计算约束条件
quantity_valid = (
(df['回购数量上限'].isna()) |
(df['回购数量下限'] <= df['回购数量上限'])
)
funds_valid = (
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 3,
"derived_id": 4,
"id": "cu_15_2_4",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_15_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "在回购股份方案中明确拟回购股份数量或者资金总额的上下限，且下限不得高于上限","contextual_info": null}
必要的额外信息: constraint项检查所有存在回购方案的行
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False，根据条件设置
df['cu_15_2_constraint'] = None # 初始化为None
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
quantity_valid = (
(df['回购数量上限'].isna()) |
(df['回购数量下限'] <= df['回购数量上限'])
)
funds_valid = (
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
```python
import pandas as pd
def check_cu_15_2(df):
'''
检查cu_15_2合规性:
subject: 上市公司
condition: 实施要约回购
constraint: 回购方案需明确数量/资金上下限且下限≤上限
'''
df = df.copy()
# 初始化合规标记列
df['cu_15_2_subject'] = True # 所有公司均为上市公司
df['cu_15_2_condition'] = False # 初始化为False，根据条件设置
df['cu_15_2_constraint'] = None # 初始化为None
# 标记constraint合规性
# 不存在回购方案的行自动合规
df.loc[~df['存在回购方案'], 'cu_15_2_constraint'] = True
# 处理存在回购方案的行
mask = df['存在回购方案']
# 验证触发条件
valid_condition = (
mask &
(df['回购方式'] == '要约回购')
)
df.loc[valid_condition, 'cu_15_2_condition'] = True
# 计算约束条件
quantity_valid = (
(df['回购数量上限'].isna()) |
(df['回购数量下限'] <= df['回购数量上限'])
)
funds_valid = (
(df['资金总额上限'].isna()) |
(df['资金总额下限'] <= df['资金总额上限'])
)
has_any_limit = df['回购数量上限'].notna() | df['资金总额上限'].notna()
combined_valid = quantity_valid & funds_valid & has_any_limit
# 更新约束
df.loc[mask, 'cu_15_2_constraint'] = combined_valid[mask]
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_15_2",
"derived_derived_id": 4,
"derived_id": 4,
"id": "cu_15_2_4",
"law_article_id": 15,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_16_1_1",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_16_1_1",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_16_1_1",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_16_1_1",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_16_1_1",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 5,
"derived_id": 1,
"id": "cu_16_1_1",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_16_1_2",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_16_1_2",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_16_1_2",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_16_1_2",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_16_1_2",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_16_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行竞价回购","constraint": "价格上限原则上不应高于董事会审议通过回购股份决议前30个交易日（不含停牌日）交易均价的200%","contextual_info": null}
必要的额外信息: 不考虑"原则上"的松弛条件; 每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况; 对每个公司每个回购计划期间的['决议通过日', '实施截止日']之间的日期标记constraint, 不符合这些条件的行可保留为None; 价格是否突破上限按照['申报价格']计算
你被分配的ComplianceUnit coding任务存在refer_to关系, 你需要参考下面这个ComplianceUnit的必要内容来完成你被安排的任务, 但你不需要直接执行下面的ComplianceUnit:
【cu_75_1】
{"subject": NaN, "condition": NaN, "constraint": NaN, "contextual_info": "交易均价的计算方式为：董事会审议通过回购股份决议前N个交易日（不含停牌日）的股票交易总额除以股票交易总量，且不包含大宗交易"}
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
def check_cu_16_1(df):
'''
检查cu_16_1合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在竞价回购行为
- constraint: 申报价格不超过决议前30日交易均价200%
注：每日股价以收盘价为准, 不考虑日内价格变化; 不存在这30个交易日无法取到的情况
'''
df = df.copy()
# 1. 标记subject（所有公司均为上市公司）
df['cu_16_1_subject'] = True
# 2. 标记condition
df['cu_16_1_condition'] = df['存在回购方案'] & (df['回购方式'] == '竞价回购')
# 3. 初始化constraint
df['cu_16_1_constraint'] = None
# 处理constraint部分
for company_name, company_group in df.groupby('公司简称'):
# 筛选该公司的回购方案（存在回购方案且是竞价回购）
repo_mask = company_group['存在回购方案']
repo_cases = company_group[repo_mask]
d_list = repo_cases['决议通过日'].unique()
for d in d_list:
# 获取该决议通过日的实施开始日和截止日
case_rows = repo_cases[repo_cases['决议通过日'] == d]
if len(case_rows) == 0:
continue
case_row = case_rows.iloc[0]
s = case_row['决议通过日']
e = case_row['实施截止日']
# 计算前30日的收盘价均價
before_d_mask = company_group['日期'] < d
before_d = company_group[before_d_mask]
last_30 = before_d.tail(30)
avg_price = last_30['收盘价'].mean()
ref_price = avg_price * 2
# 找到实施期间内的行
mask_period = (company_group['日期'] >= s) & (company_group['日期'] <= e)
mask_to_check = mask_period & company_group['申报价格'].notna()
indices = company_group[mask_to_check].index
# 更新constraint列
if not indices.empty:
constraint_values = company_group.loc[indices, '申报价格'] <= ref_price
df.loc[indices, 'cu_16_1_constraint'] = constraint_values
df.loc[indices, '违规价格上限'] = ref_price
df.loc[indices, '前30日收盘价均值'] = avg_price
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_16_1",
"derived_derived_id": 5,
"derived_id": 2,
"id": "cu_16_1_2",
"law_article_id": 16,
"law_document_id": "BSE04",
"mask_count": 3,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_18_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行股份回购的申报","constraint": "申报价格不得为公司股票当日交易涨幅限制的价格","contextual_info": null}
必要的额外信息: 1. 假设当日涨跌幅限制为前日收盘价的正负10%; 2. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_meu_18_7(df):
'''
验证MEU_18_7合规性:
- subject: 上市公司
- condition: 进行股份回购的申报
- constraint: 申报价格不得为当日涨跌幅限制价格
'''
df = df.copy()
# 初始化合规性标记列
df['meu_18_7_subject'] = True # 所有公司均为上市公司
df['meu_18_7_condition'] = False
df['meu_18_7_constraint'] = None
# 1. 标记condition条件满足情况
# 条件成立需同时满足：存在回购方案且存在申报价格
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
lower_limit = prev_close * 0.8
# 获取申报价格并判断是否触及限制
declared_price = df['申报价格']
bigger_than_upper = declared_price >= upper_limit
smaller_than_lower = declared_price <= lower_limit
# 有效约束条件：存在申报价格且不触及涨跌停价
valid_constraint = has_declaration & ~(bigger_than_upper | smaller_than_lower)
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_18_7",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_18_7_1",
"law_article_id": 18,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_18_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行股份回购的申报","constraint": "申报价格不得为公司股票当日交易涨幅限制的价格","contextual_info": null}
必要的额外信息: 1. 假设当日涨跌幅限制为前日收盘价的正负10%; 2. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_18_7(df):
'''
验证MEU_18_7合规性:
- subject: 上市公司
- condition: 进行股份回购的申报
- constraint: 申报价格不得为当日涨跌幅限制价格
'''
df = df.copy()
# 初始化合规性标记列
df['meu_18_7_subject'] = True # 所有公司均为上市公司
df['meu_18_7_condition'] = False
df['meu_18_7_constraint'] = None
# 1. 标记condition条件满足情况
# 条件成立需同时满足：存在回购方案且存在申报价格
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
lower_limit = prev_close * 0.8
# 获取申报价格并判断是否触及限制
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
```python
import pandas as pd
def check_meu_18_7(df):
'''
验证MEU_18_7合规性:
- subject: 上市公司
- condition: 进行股份回购的申报
- constraint: 申报价格不得为当日涨跌幅限制价格
'''
df = df.copy()
# 初始化合规性标记列
df['meu_18_7_subject'] = True # 所有公司均为上市公司
df['meu_18_7_condition'] = False
df['meu_18_7_constraint'] = None
# 1. 标记condition条件满足情况
# 条件成立需同时满足：存在回购方案且存在申报价格
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
lower_limit = prev_close * 0.8
# 获取申报价格并判断是否触及限制
declared_price = df['申报价格']
bigger_than_upper = declared_price >= upper_limit
smaller_than_lower = declared_price <= lower_limit
# 有效约束条件：存在申报价格且不触及涨跌停价
valid_constraint = has_declaration & ~(bigger_than_upper | smaller_than_lower)
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_18_7",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_18_7_1",
"law_article_id": 18,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_18_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行股份回购的申报","constraint": "申报价格不得为公司股票当日交易涨幅限制的价格","contextual_info": null}
必要的额外信息: 1. 假设当日涨跌幅限制为前日收盘价的正负10%; 2. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_18_7(df):
'''
验证MEU_18_7合规性:
- subject: 上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_18_7_subject'] = True # 所有公司均为上市公司
df['meu_18_7_condition'] = False
df['meu_18_7_constraint'] = None
# 1. 标记condition条件满足情况
# 条件成立需同时满足：存在回购方案且存在申报价格
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
lower_limit = prev_close * 0.8
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
valid_constraint = has_declaration & ~(bigger_than_upper | smaller_than_lower)
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
```python
import pandas as pd
def check_meu_18_7(df):
'''
验证MEU_18_7合规性:
- subject: 上市公司
- condition: 进行股份回购的申报
- constraint: 申报价格不得为当日涨跌幅限制价格
'''
df = df.copy()
# 初始化合规性标记列
df['meu_18_7_subject'] = True # 所有公司均为上市公司
df['meu_18_7_condition'] = False
df['meu_18_7_constraint'] = None
# 1. 标记condition条件满足情况
# 条件成立需同时满足：存在回购方案且存在申报价格
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
lower_limit = prev_close * 0.8
# 获取申报价格并判断是否触及限制
declared_price = df['申报价格']
bigger_than_upper = declared_price >= upper_limit
smaller_than_lower = declared_price <= lower_limit
# 有效约束条件：存在申报价格且不触及涨跌停价
valid_constraint = has_declaration & ~(bigger_than_upper | smaller_than_lower)
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_18_7",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_18_7_1",
"law_article_id": 18,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_18_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行股份回购的申报","constraint": "申报价格不得为公司股票当日交易涨幅限制的价格","contextual_info": null}
必要的额外信息: 1. 假设当日涨跌幅限制为前日收盘价的正负10%; 2. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
- constraint: 申报价格不得为当日涨跌幅限制价格
'''
df = df.copy()
# 初始化合规性标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
lower_limit = prev_close * 0.8
# 获取申报价格并判断是否触及限制
declared_price = df['申报价格']
bigger_than_upper = declared_price >= upper_limit
smaller_than_lower = declared_price <= lower_limit
# 有效约束条件：存在申报价格且不触及涨跌停价
valid_constraint = has_declaration & ~(bigger_than_upper | smaller_than_lower)
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
```python
import pandas as pd
def check_meu_18_7(df):
'''
验证MEU_18_7合规性:
- subject: 上市公司
- condition: 进行股份回购的申报
- constraint: 申报价格不得为当日涨跌幅限制价格
'''
df = df.copy()
# 初始化合规性标记列
df['meu_18_7_subject'] = True # 所有公司均为上市公司
df['meu_18_7_condition'] = False
df['meu_18_7_constraint'] = None
# 1. 标记condition条件满足情况
# 条件成立需同时满足：存在回购方案且存在申报价格
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
lower_limit = prev_close * 0.8
# 获取申报价格并判断是否触及限制
declared_price = df['申报价格']
bigger_than_upper = declared_price >= upper_limit
smaller_than_lower = declared_price <= lower_limit
# 有效约束条件：存在申报价格且不触及涨跌停价
valid_constraint = has_declaration & ~(bigger_than_upper | smaller_than_lower)
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_18_7",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_18_7_1",
"law_article_id": 18,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_18_7
法律的合规检查单元内容: {"subject": "上市公司","condition": "进行股份回购的申报","constraint": "申报价格不得为公司股票当日交易涨幅限制的价格","contextual_info": null}
必要的额外信息: 1. 假设当日涨跌幅限制为前日收盘价的正负10%; 2. condition理解为检查'决议通过日'的情况, 计算各种指标也以该日为基准
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_18_7(df):
'''
验证MEU_18_7合规性:
- subject: 上市公司
- condition: 进行股份回购的申报
- constraint: 申报价格不得为当日涨跌幅限制价格
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_18_7_constraint'] = None
# 1. 标记condition条件满足情况
# 条件成立需同时满足：存在回购方案且存在申报价格
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 有效约束条件：存在申报价格且不触及涨跌停价
valid_constraint = has_declaration & ~(bigger_than_upper | smaller_than_lower)
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
```python
import pandas as pd
def check_meu_18_7(df):
'''
验证MEU_18_7合规性:
- subject: 上市公司
- condition: 进行股份回购的申报
- constraint: 申报价格不得为当日涨跌幅限制价格
'''
df = df.copy()
# 初始化合规性标记列
df['meu_18_7_subject'] = True # 所有公司均为上市公司
df['meu_18_7_condition'] = False
df['meu_18_7_constraint'] = None
# 1. 标记condition条件满足情况
# 条件成立需同时满足：存在回购方案且存在申报价格
has_repo_plan = df['存在回购方案']
has_declaration = df['申报价格'].notna()
valid_condition = has_repo_plan & has_declaration & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'meu_18_7_condition'] = True
# 2. 标记constraint约束满足情况
# 计算前收盘价的±20%涨跌幅限制
prev_close = df['前收盘价']
upper_limit = prev_close * 1.2
lower_limit = prev_close * 0.8
# 获取申报价格并判断是否触及限制
declared_price = df['申报价格']
bigger_than_upper = declared_price >= upper_limit
smaller_than_lower = declared_price <= lower_limit
# 有效约束条件：存在申报价格且不触及涨跌停价
valid_constraint = has_declaration & ~(bigger_than_upper | smaller_than_lower)
df['meu_18_7_constraint'] = valid_constraint
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_18_7",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_18_7_1",
"law_article_id": 18,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_19_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "实施期限不超过12个月","contextual_info": "自董事会或股东大会（如须）审议通过回购股份决议之日起算"}
必要的额外信息: 对存在回购方案的所有交易日进行检查; 12个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_19_1(df):
'''
合规性检查函数，用于验证CU_19_1条款的遵守情况：
- subject: 上市公司（所有行自动满足）
- condition: 实施竞价回购（需同时满足存在回购方案和回购方式为竞价）
- constraint: 实施期限不超过12个月（按30个自然日/月计算）
'''
df = df.copy()
# 初始化标记列
df['cu_19_1_subject'] = True # 所有公司均为上市公司
df['cu_19_1_condition'] = False
df['cu_19_1_constraint'] = None
# 标记条件：存在回购方案且回购方式为竞价
is_auction_repurchase = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购')
)
df.loc[is_auction_repurchase, 'cu_19_1_condition'] = True
# 标记约束：实施期限不超过12个月（按360自然日计算）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.DateOffset(days=360)
)
df.loc[date_mask, 'cu_19_1_constraint'] = True
df.loc[~date_mask, 'cu_19_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_19_1",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_19_1_1",
"law_article_id": 19,
"law_document_id": "BSE04",
"mask_count": 0,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_19_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "实施期限不超过12个月","contextual_info": "自董事会或股东大会（如须）审议通过回购股份决议之日起算"}
必要的额外信息: 对存在回购方案的所有交易日进行检查; 12个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_19_1(df):
'''
合规性检查函数，用于验证CU_19_1条款的遵守情况：
- subject: 上市公司（所有行自动满足）
- condition: 实施竞价回购（需同时满足存在回购方案和回购方式为竞价）
- constraint: 实施期限不超过12个月（按30个自然日/月计算）
'''
df = df.copy()
# 初始化标记列
df['cu_19_1_subject'] = True # 所有公司均为上市公司
df['cu_19_1_condition'] = False
df['cu_19_1_constraint'] = None
# 标记条件：存在回购方案且回购方式为竞价
is_auction_repurchase = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购')
)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['实施截止日'] <= df['决议通过日'] + pd.DateOffset(days=360)
)
df.loc[date_mask, 'cu_19_1_constraint'] = True
df.loc[~date_mask, 'cu_19_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_19_1(df):
'''
合规性检查函数，用于验证CU_19_1条款的遵守情况：
- subject: 上市公司（所有行自动满足）
- condition: 实施竞价回购（需同时满足存在回购方案和回购方式为竞价）
- constraint: 实施期限不超过12个月（按30个自然日/月计算）
'''
df = df.copy()
# 初始化标记列
df['cu_19_1_subject'] = True # 所有公司均为上市公司
df['cu_19_1_condition'] = False
df['cu_19_1_constraint'] = None
# 标记条件：存在回购方案且回购方式为竞价
is_auction_repurchase = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购')
)
df.loc[is_auction_repurchase, 'cu_19_1_condition'] = True
# 标记约束：实施期限不超过12个月（按360自然日计算）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.DateOffset(days=360)
)
df.loc[date_mask, 'cu_19_1_constraint'] = True
df.loc[~date_mask, 'cu_19_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_19_1",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_19_1_1",
"law_article_id": 19,
"law_document_id": "BSE04",
"mask_count": 1,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_19_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "实施期限不超过12个月","contextual_info": "自董事会或股东大会（如须）审议通过回购股份决议之日起算"}
必要的额外信息: 对存在回购方案的所有交易日进行检查; 12个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_19_1(df):
'''
合规性检查函数，用于验证CU_19_1条款的遵守情况：
- subject: 上市公司（所有行自动满足）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_19_1_subject'] = True # 所有公司均为上市公司
df['cu_19_1_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
)
df.loc[is_auction_repurchase, 'cu_19_1_condition'] = True
# 标记约束：实施期限不超过12个月（按360自然日计算）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.DateOffset(days=360)
)
df.loc[date_mask, 'cu_19_1_constraint'] = True
df.loc[~date_mask, 'cu_19_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_19_1(df):
'''
合规性检查函数，用于验证CU_19_1条款的遵守情况：
- subject: 上市公司（所有行自动满足）
- condition: 实施竞价回购（需同时满足存在回购方案和回购方式为竞价）
- constraint: 实施期限不超过12个月（按30个自然日/月计算）
'''
df = df.copy()
# 初始化标记列
df['cu_19_1_subject'] = True # 所有公司均为上市公司
df['cu_19_1_condition'] = False
df['cu_19_1_constraint'] = None
# 标记条件：存在回购方案且回购方式为竞价
is_auction_repurchase = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购')
)
df.loc[is_auction_repurchase, 'cu_19_1_condition'] = True
# 标记约束：实施期限不超过12个月（按360自然日计算）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.DateOffset(days=360)
)
df.loc[date_mask, 'cu_19_1_constraint'] = True
df.loc[~date_mask, 'cu_19_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_19_1",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_19_1_1",
"law_article_id": 19,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
# 身份
你是一个精通法律的程序员. 擅长编写代码以检验特定案例对于特定法律要求的合规性.
## ComplianceUnit概念简述
ComplianceUnit是法律条文拆解出的合规检查单元，包含：
- cu_id: ComplianceUnit的编号, 通常为"cu_n_k", 其中n是其所属的法条的编号, k是其在法条内部的编号
- subject: 责任主体（如"控股股东")
- condition: 触发条件（如"减持股份")
- constraint: 约束内容（如"提前15日公告")
- contextual_info: 补充说明（如价格计算方式）
# 任务
你现在面临一个编写代码以检验某法律事件的合规性的任务, 你需要编写一个函数, 这个函数的输入是一个日频的pandas dataframe, 每一行是在某个交易日内公司的情况和股东的情况, 这个函数会检验该dataframe的每一行在某一个给定的法律合规单元上的合规性, 标注在特定的列上, 并返回标注后的dataframe.
# 更多要求
- 你可以进行任意长度的思考, 然后用<CODE></CODE>包裹你的代码.
- 你需要按照下面这个框架编写代码:
- 1. 标记valid的subject(cu_n_k_subject); (复合subject的行标记为True, 不符合的为False)
- 2. 标记valid的condition(cu_n_k_condition); (符合condition的行标记为True, 不符合的为False)
- 3. 标记valid的constraint(cu_n_k_constraint); (符合constraint的行标记为True, 不符合的为False)
- 4. 在dataframe中记录subject, condition和constraint的valid情况;
- 注意: 对于简单操作dataframe就可以处理的项目, 对三元组<subject, conditon, constraint>的检查是各自独立的, 你需要分别标记三元组的True和False. 并不是只对符合subject和condition进行检查. 对于需要调用llm_content_check()函数的项目, 只对符合<subject, conditon>的constraint进行检查.
# example
下面是一个例子:
## 输入
法律的合规单元编号: cu_4_1
法律的合规单元内容: {"subject": "上市公司大股东 | 董监高", "condition": "计划通过本所集中竞价或大宗交易减持股份", "constraint": "应当及时通知公司，并在首次卖出的15个交易日前向本所报告并预先披露减持计划", "contextual_info": NaN}
必要的额外信息: NaN
## 输出
<CODE>
import pandas a pd
def check_cu_4_1(df):
'''
检查cu_4_1的合规性：
主体：上市公司大股东 | 董监高
条件：存在通过竞价/大宗交易的减持计划
约束：首次卖出前至少15个交易日披露
'''
df = df.copy()
# 初始化标记列
df['cu_4_1_subject'] = False
df['cu_4_1_condition'] = False
df['cu_4_1_constraint'] = None
# 1. 验证责任主体
is_major = (
df['股东身份'].isin(['控股股东', '实际控制人', '持股5%以上股东']) |
(df['持股比例'] >= 0.05)
)
is_director = df['股东身份'] == '董监高'
df.loc[is_major | is_director, 'cu_4_1_subject'] = True
# 2. 验证触发条件
valid_condition = (
df['减持方式'].isin(['竞价交易', '大宗交易']) &
df['存在减持计划']
)
df.loc[valid_condition, 'cu_4_1_condition'] = True
# 3. 核心改进：准确识别首次卖出日
def process_group(group):
group = group.sort_values('日期')
plans = []
current_plan = None
# 识别减持计划区间
for _, row in group.iterrows():
if row['存在减持计划']:
if current_plan is None:
current_plan = {
'披露日': row['计划披露日'],
'开始日': row['计划开始日'],
'减持记录': []
}
if row['当日减持比例'] > 0:
current_plan['减持记录'].append(row['日期'])
else:
if current_plan:
plans.append(current_plan)
current_plan = None
if current_plan:
plans.append(current_plan)
# 提取首次卖出日
return pd.DataFrame([{
'公司简称': group['公司简称'].iloc[0],
'股东': group['股东'].iloc[0],
'计划披露日': p['披露日'],
'首次卖出日': min(p['减持记录']) if p['减持记录'] else pd.NaT
} for p in plans])
# 按分组处理并合并
plan_info = df.groupby(['公司简称', '股东'], group_keys=False).apply(process_group)
df = df.merge(
plan_info,
on=['公司简称', '股东', '计划披露日'],
how='left'
) if not plan_info.empty else df.assign(首次卖出日=pd.NaT)
# 4. 交易日差计算（改进点：使用首次卖出日而非计划开始日）
trading_dates = pd.Series(df['日期'].unique()).sort_values().reset_index(drop=True)
date_map = {date: idx for idx, date in enumerate(trading_dates)}
df['交易日差'] = df.apply(
lambda x: date_map.get(x['首次卖出日'], np.nan) - date_map.get(x['计划披露日'], np.nan),
axis=1
)
# 5. 验证约束条件
# 至少提前15个交易日披露
df['cu_4_1_constraint'] = (df['交易日差'] >= 15)
return df
</CODE>
# 下面轮到你来完成这个任务
法律的合规检查单元编号: cu_19_1
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施竞价回购","constraint": "实施期限不超过12个月","contextual_info": "自董事会或股东大会（如须）审议通过回购股份决议之日起算"}
必要的额外信息: 对存在回购方案的所有交易日进行检查; 12个月按照自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_19_1(df):
'''
合规性检查函数，用于验证CU_19_1条款的遵守情况：
- subject: 上市公司（所有行自动满足）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_19_1_subject'] = True # 所有公司均为上市公司
df['cu_19_1_condition'] = False
df['cu_19_1_constraint'] = None
# 标记条件：存在回购方案且回购方式为竞价
is_auction_repurchase = (
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.DateOffset(days=360)
)
df.loc[date_mask, 'cu_19_1_constraint'] = True
df.loc[~date_mask, 'cu_19_1_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_19_1(df):
'''
合规性检查函数，用于验证CU_19_1条款的遵守情况：
- subject: 上市公司（所有行自动满足）
- condition: 实施竞价回购（需同时满足存在回购方案和回购方式为竞价）
- constraint: 实施期限不超过12个月（按30个自然日/月计算）
'''
df = df.copy()
# 初始化标记列
df['cu_19_1_subject'] = True # 所有公司均为上市公司
df['cu_19_1_condition'] = False
df['cu_19_1_constraint'] = None
# 标记条件：存在回购方案且回购方式为竞价
is_auction_repurchase = (
df['存在回购方案'] &
(df['回购方式'] == '竞价回购')
)
df.loc[is_auction_repurchase, 'cu_19_1_condition'] = True
# 标记约束：实施期限不超过12个月（按360自然日计算）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.DateOffset(days=360)
)
df.loc[date_mask, 'cu_19_1_constraint'] = True
df.loc[~date_mask, 'cu_19_1_constraint'] = False
return df
```
|
{
"language": "python",
"test_code": "```python\n# 读取模拟数据\nimport pandas as pd\ndf = pd.read_csv('data_simulation/data_generated/data_simulate_04.csv')\ndate_columns = ['日期', '决议通过日', '实施开始日', '实施截止日', '上市日期', '公告日期', '出售开始日', '出售截止日']\nfor col in date_columns:\n df[col] = pd.to_datetime(df[col])\n```"
}
|
{
"compliance_unit_id": "cu_19_1",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_19_1_1",
"law_article_id": 19,
"law_document_id": "BSE04",
"mask_count": 2,
"variant": "1"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.