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_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):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 标记条件：存在回购方案且回购方式为竞价
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
```
|
```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": 4,
"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": "实施期限不超过5个月","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: 实施期限不超过5个月（基于决议通过日与实施截止日的时间差，每月按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
# 标记约束：实施期限不超过5个月（150天）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.Timedelta(days=150)
)
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": 2,
"id": "cu_19_1_2",
"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": "实施期限不超过5个月","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):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
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
# 标记约束：实施期限不超过5个月（150天）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.Timedelta(days=150)
)
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: 实施期限不超过5个月（基于决议通过日与实施截止日的时间差，每月按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
# 标记约束：实施期限不超过5个月（150天）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.Timedelta(days=150)
)
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": 2,
"id": "cu_19_1_2",
"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": "实施期限不超过5个月","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
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[is_auction_repurchase, 'cu_19_1_condition'] = True
# 标记约束：实施期限不超过5个月（150天）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.Timedelta(days=150)
)
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: 实施期限不超过5个月（基于决议通过日与实施截止日的时间差，每月按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
# 标记约束：实施期限不超过5个月（150天）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.Timedelta(days=150)
)
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": 2,
"id": "cu_19_1_2",
"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": "实施期限不超过5个月","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: 实施期限不超过5个月（基于决议通过日与实施截止日的时间差，每月按30天计算）
'''
df = df.copy()
# 初始化标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['存在回购方案'] &
(df['回购方式'] == '竞价回购')
)
df.loc[is_auction_repurchase, 'cu_19_1_condition'] = True
# 标记约束：实施期限不超过5个月（150天）
# 仅当日期字段有效时进行计算
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
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: 实施期限不超过5个月（基于决议通过日与实施截止日的时间差，每月按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
# 标记约束：实施期限不超过5个月（150天）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.Timedelta(days=150)
)
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": 2,
"id": "cu_19_1_2",
"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": "实施期限不超过5个月","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: 实施期限不超过5个月（基于决议通过日与实施截止日的时间差，每月按30天计算）
'''
df = df.copy()
# 初始化标记列
df['cu_19_1_subject'] = True # 所有公司均为上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.Timedelta(days=150)
)
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: 实施期限不超过5个月（基于决议通过日与实施截止日的时间差，每月按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
# 标记约束：实施期限不超过5个月（150天）
# 仅当日期字段有效时进行计算
valid_dates = df['决议通过日'].notna() & df['实施截止日'].notna()
date_mask = valid_dates & (
df['实施截止日'] <= df['决议通过日'] + pd.Timedelta(days=150)
)
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": 4,
"derived_id": 2,
"id": "cu_19_1_2",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日90个自然日内
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（一个月按30天计算，共90天）
deadline = df['决议通过日'] + pd.Timedelta(days=90)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_19_2_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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日90个自然日内
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（一个月按30天计算，共90天）
deadline = df['决议通过日'] + pd.Timedelta(days=90)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日90个自然日内
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（一个月按30天计算，共90天）
deadline = df['决议通过日'] + pd.Timedelta(days=90)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_19_2_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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_19_2(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日90个自然日内
constraint_mask = df['存在回购方案'].copy()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[~constraint_mask, 'meu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日90个自然日内
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（一个月按30天计算，共90天）
deadline = df['决议通过日'] + pd.Timedelta(days=90)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_19_2_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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
deadline = df['决议通过日'] + pd.Timedelta(days=90)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日90个自然日内
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（一个月按30天计算，共90天）
deadline = df['决议通过日'] + pd.Timedelta(days=90)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_19_2_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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月",
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日90个自然日内
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过3个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日90个自然日内
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（一个月按30天计算，共90天）
deadline = df['决议通过日'] + pd.Timedelta(days=90)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_19_2_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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150个自然日计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_19_2_2",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150个自然日计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150个自然日计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_19_2_2",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[~constraint_mask, 'meu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150个自然日计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_19_2_2",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150个自然日计算）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150个自然日计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_19_2_2",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_meu_19_2(df):
'''
检查MEU_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施竞价回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['meu_19_2_subject'] = True # 所有公司都是上市公司
df['meu_19_2_condition'] = False
df['meu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、竞价回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '竞价回购')
)
df.loc[condition_mask, 'meu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150个自然日计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'meu_19_2_constraint'] = True
df.loc[~constraint_mask, 'meu_19_2_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_2",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_19_2_2",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_19_2(df):
'''
检查cu_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_19_2_subject'] = True # 所有公司都是上市公司
df['cu_19_2_condition'] = False
df['cu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、要约回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '要约回购')
)
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150天计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'cu_19_2_constraint'] = True
df.loc[~constraint_mask, 'cu_19_2_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_2",
"derived_derived_id": 0,
"derived_id": 3,
"id": "cu_19_2_3",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的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_2(df):
'''
检查cu_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_19_2_subject'] = True # 所有公司都是上市公司
df['cu_19_2_condition'] = False
df['cu_19_2_constraint'] = None
# 1. 标记condition合规性
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
)
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150天计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'cu_19_2_constraint'] = True
df.loc[~constraint_mask, 'cu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_19_2(df):
'''
检查cu_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_19_2_subject'] = True # 所有公司都是上市公司
df['cu_19_2_condition'] = False
df['cu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、要约回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '要约回购')
)
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150天计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'cu_19_2_constraint'] = True
df.loc[~constraint_mask, 'cu_19_2_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_2",
"derived_derived_id": 1,
"derived_id": 3,
"id": "cu_19_2_3",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的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_2(df):
'''
检查cu_19_2合规性：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['cu_19_2_subject'] = True # 所有公司都是上市公司
df['cu_19_2_condition'] = False
df['cu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、要约回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '要约回购')
)
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[constraint_mask, 'cu_19_2_constraint'] = True
df.loc[~constraint_mask, 'cu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_19_2(df):
'''
检查cu_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_19_2_subject'] = True # 所有公司都是上市公司
df['cu_19_2_condition'] = False
df['cu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、要约回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '要约回购')
)
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150天计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'cu_19_2_constraint'] = True
df.loc[~constraint_mask, 'cu_19_2_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_2",
"derived_derived_id": 2,
"derived_id": 3,
"id": "cu_19_2_3",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的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_2(df):
'''
检查cu_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150天计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'cu_19_2_constraint'] = True
df.loc[~constraint_mask, 'cu_19_2_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_19_2(df):
'''
检查cu_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_19_2_subject'] = True # 所有公司都是上市公司
df['cu_19_2_condition'] = False
df['cu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、要约回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '要约回购')
)
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150天计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'cu_19_2_constraint'] = True
df.loc[~constraint_mask, 'cu_19_2_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_2",
"derived_derived_id": 3,
"derived_id": 3,
"id": "cu_19_2_3",
"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_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购","constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月","contextual_info": null}
必要的额外信息: 采用数据中的'审议通过日'即可, 不用考虑是股东大会还是董事会审议; 3个月按自然月计算
# 附加信息
## 你可以操作的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_2(df):
'''
检查cu_19_2合规性：
"subject": "上市公司",
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化合规标记列
df['cu_19_2_subject'] = True # 所有公司都是上市公司
df['cu_19_2_condition'] = False
df['cu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、要约回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '要约回购')
)
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150天计算）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_cu_19_2(df):
'''
检查cu_19_2合规性：
"subject": "上市公司",
"condition": "因维护公司价值及股东权益所必需回购股份的，实施要约回购",
"constraint": "回购实施期限自股东大会或者董事会审议通过最终回购股份方案之日起不超过5个月",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_19_2_subject'] = True # 所有公司都是上市公司
df['cu_19_2_condition'] = False
df['cu_19_2_constraint'] = None
# 1. 标记condition合规性
# 条件需同时满足：存在回购方案、维护公司价值用途、要约回购方式
condition_mask = (
df['存在回购方案'] &
(df['回购用途'] == '维护公司价值及股东权益所必需') &
(df['回购方式'] == '要约回购')
)
df.loc[condition_mask, 'cu_19_2_condition'] = True
# 2. 标记constraint合规性
# 约束需同时满足：存在回购方案、实施截止日在决议通过日5个月内（按每月30天计算）
constraint_mask = df['存在回购方案'].copy()
# 计算自然日边界（5个月按150天计算）
deadline = df['决议通过日'] + pd.DateOffset(days=150)
# 处理NaT避免类型错误（当存在回购方案为False时自动返回False）
constraint_mask = constraint_mask & (df['实施截止日'] <= deadline)
df.loc[constraint_mask, 'cu_19_2_constraint'] = True
df.loc[~constraint_mask, 'cu_19_2_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_2",
"derived_derived_id": 4,
"derived_id": 3,
"id": "cu_19_2_3",
"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_21_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的","constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%","contextual_info": null}
必要的额外信息: 合计持有'理解为累计回购比例
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_21_2(df):
'''
验证CU_21_2合规性:
"subject": "上市公司",
"condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的",
"constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%",
"contextual_info": NaN
'''
df = df.copy()
# 初始化标记列
df['cu_21_2_subject'] = True # 所有记录主体均为上市公司
df['cu_21_2_condition'] = False
df['cu_21_2_constraint'] = None
# 1. 标记condition有效性
valid_uses = [
'股权激励或者员工持股计划',
'转换上市公司发行的可转换为股票的公司债券',
'维护公司价值及股东权益所必需'
]
df['cu_21_2_condition'] = df['回购用途'].isin(valid_uses)
# 2. 标记constraint有效性
# 处理空值并计算回购比例
total_shares = df['总股本'].replace(0, pd.NA) # 防止除零错误
cumulative_repo = df['累计回购数量'].fillna(0)
repo_ratio = cumulative_repo / total_shares
# 约束条件判断
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
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_21_2",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_21_2_1",
"law_article_id": 21,
"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_21_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的","constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%","contextual_info": null}
必要的额外信息: 合计持有'理解为累计回购比例
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_21_2(df):
'''
验证CU_21_2合规性:
"subject": "上市公司",
"condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的",
"constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%",
"contextual_info": NaN
'''
df = df.copy()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
valid_uses = [
'股权激励或者员工持股计划',
'转换上市公司发行的可转换为股票的公司债券',
'维护公司价值及股东权益所必需'
]
df['cu_21_2_condition'] = df['回购用途'].isin(valid_uses)
# 2. 标记constraint有效性
# 处理空值并计算回购比例
total_shares = df['总股本'].replace(0, pd.NA) # 防止除零错误
cumulative_repo = df['累计回购数量'].fillna(0)
repo_ratio = cumulative_repo / total_shares
# 约束条件判断
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
return df
```
|
```python
import pandas as pd
def check_cu_21_2(df):
'''
验证CU_21_2合规性:
"subject": "上市公司",
"condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的",
"constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%",
"contextual_info": NaN
'''
df = df.copy()
# 初始化标记列
df['cu_21_2_subject'] = True # 所有记录主体均为上市公司
df['cu_21_2_condition'] = False
df['cu_21_2_constraint'] = None
# 1. 标记condition有效性
valid_uses = [
'股权激励或者员工持股计划',
'转换上市公司发行的可转换为股票的公司债券',
'维护公司价值及股东权益所必需'
]
df['cu_21_2_condition'] = df['回购用途'].isin(valid_uses)
# 2. 标记constraint有效性
# 处理空值并计算回购比例
total_shares = df['总股本'].replace(0, pd.NA) # 防止除零错误
cumulative_repo = df['累计回购数量'].fillna(0)
repo_ratio = cumulative_repo / total_shares
# 约束条件判断
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
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_21_2",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_21_2_1",
"law_article_id": 21,
"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_21_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的","constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%","contextual_info": null}
必要的额外信息: 合计持有'理解为累计回购比例
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_21_2(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化标记列
df['cu_21_2_subject'] = True # 所有记录主体均为上市公司
df['cu_21_2_condition'] = False
df['cu_21_2_constraint'] = None
# 1. 标记condition有效性
valid_uses = [
'股权激励或者员工持股计划',
'转换上市公司发行的可转换为股票的公司债券',
'维护公司价值及股东权益所必需'
]
df['cu_21_2_condition'] = df['回购用途'].isin(valid_uses)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 约束条件判断
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
return df
```
|
```python
import pandas as pd
def check_cu_21_2(df):
'''
验证CU_21_2合规性:
"subject": "上市公司",
"condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的",
"constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%",
"contextual_info": NaN
'''
df = df.copy()
# 初始化标记列
df['cu_21_2_subject'] = True # 所有记录主体均为上市公司
df['cu_21_2_condition'] = False
df['cu_21_2_constraint'] = None
# 1. 标记condition有效性
valid_uses = [
'股权激励或者员工持股计划',
'转换上市公司发行的可转换为股票的公司债券',
'维护公司价值及股东权益所必需'
]
df['cu_21_2_condition'] = df['回购用途'].isin(valid_uses)
# 2. 标记constraint有效性
# 处理空值并计算回购比例
total_shares = df['总股本'].replace(0, pd.NA) # 防止除零错误
cumulative_repo = df['累计回购数量'].fillna(0)
repo_ratio = cumulative_repo / total_shares
# 约束条件判断
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
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_21_2",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_21_2_1",
"law_article_id": 21,
"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_21_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的","constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%","contextual_info": null}
必要的额外信息: 合计持有'理解为累计回购比例
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_21_2(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化标记列
df['cu_21_2_subject'] = True # 所有记录主体均为上市公司
df['cu_21_2_condition'] = False
df['cu_21_2_constraint'] = None
# 1. 标记condition有效性
valid_uses = [
'股权激励或者员工持股计划',
'转换上市公司发行的可转换为股票的公司债券',
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
total_shares = df['总股本'].replace(0, pd.NA) # 防止除零错误
cumulative_repo = df['累计回购数量'].fillna(0)
repo_ratio = cumulative_repo / total_shares
# 约束条件判断
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
return df
```
|
```python
import pandas as pd
def check_cu_21_2(df):
'''
验证CU_21_2合规性:
"subject": "上市公司",
"condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的",
"constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%",
"contextual_info": NaN
'''
df = df.copy()
# 初始化标记列
df['cu_21_2_subject'] = True # 所有记录主体均为上市公司
df['cu_21_2_condition'] = False
df['cu_21_2_constraint'] = None
# 1. 标记condition有效性
valid_uses = [
'股权激励或者员工持股计划',
'转换上市公司发行的可转换为股票的公司债券',
'维护公司价值及股东权益所必需'
]
df['cu_21_2_condition'] = df['回购用途'].isin(valid_uses)
# 2. 标记constraint有效性
# 处理空值并计算回购比例
total_shares = df['总股本'].replace(0, pd.NA) # 防止除零错误
cumulative_repo = df['累计回购数量'].fillna(0)
repo_ratio = cumulative_repo / total_shares
# 约束条件判断
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
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_21_2",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_21_2_1",
"law_article_id": 21,
"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_21_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的","constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%","contextual_info": null}
必要的额外信息: 合计持有'理解为累计回购比例
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_21_2(df):
'''
验证CU_21_2合规性:
"subject": "上市公司",
"condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的",
"constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%",
"contextual_info": NaN
'''
df = df.copy()
# 初始化标记列
df['cu_21_2_subject'] = True # 所有记录主体均为上市公司
df['cu_21_2_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'维护公司价值及股东权益所必需'
]
df['cu_21_2_condition'] = df['回购用途'].isin(valid_uses)
# 2. 标记constraint有效性
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
return df
```
|
```python
import pandas as pd
def check_cu_21_2(df):
'''
验证CU_21_2合规性:
"subject": "上市公司",
"condition": "回购股份用于股权激励或者员工持股计划、转换上市公司发行的可转换为股票的公司债券、维护公司价值及股东权益所必需的",
"constraint": "合计持有的本公司股份数不得超过本公司已发行股份总额的20%",
"contextual_info": NaN
'''
df = df.copy()
# 初始化标记列
df['cu_21_2_subject'] = True # 所有记录主体均为上市公司
df['cu_21_2_condition'] = False
df['cu_21_2_constraint'] = None
# 1. 标记condition有效性
valid_uses = [
'股权激励或者员工持股计划',
'转换上市公司发行的可转换为股票的公司债券',
'维护公司价值及股东权益所必需'
]
df['cu_21_2_condition'] = df['回购用途'].isin(valid_uses)
# 2. 标记constraint有效性
# 处理空值并计算回购比例
total_shares = df['总股本'].replace(0, pd.NA) # 防止除零错误
cumulative_repo = df['累计回购数量'].fillna(0)
repo_ratio = cumulative_repo / total_shares
# 约束条件判断
valid_constraint = (repo_ratio <= 0.2) & (~total_shares.isna())
df['cu_21_2_constraint'] = valid_constraint.astype(bool)
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_21_2",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_21_2_1",
"law_article_id": 21,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_42_2_1",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_42_2(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_42_2_1",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_42_2_1",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_42_2_1",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_42_2_1",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因维护公司价值及股东权益所必需而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算时间窗口标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_cu_42_2(df):
'''
合规性检查函数，对应CU_42_2条款：
- subject: 上市公司
- condition: 因维护公司价值及股东权益回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['cu_42_2_subject'] = True # 所有公司均为上市公司
df['cu_42_2_condition'] = False
df['cu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '维护公司价值及股东权益所必需'
df['cu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['cu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 5,
"derived_id": 1,
"id": "cu_42_2_1",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因转换上市公司发行的可转换为股票的公司债券而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_42_2_2",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因转换上市公司发行的可转换为股票的公司债券而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_42_2_2",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因转换上市公司发行的可转换为股票的公司债券而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_42_2_2",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因转换上市公司发行的可转换为股票的公司债券而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的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______
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_42_2_2",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因转换上市公司发行的可转换为股票的公司债券而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的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______
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_42_2_2",
"law_article_id": 42,
"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_42_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "因转换上市公司发行的可转换为股票的公司债券而回购股份的，处于上市公司定期报告、业绩预告或者业绩快报披露前15个交易日内（因特殊原因推迟定期报告披露日期的，自原预约公告日前15个交易日起算，至披露前1个交易日）","constraint": "不得采用集中竞价交易方式出售股份","contextual_info": null}
必要的额外信息: 不考虑报告推迟情况; 只考虑同时进行的回购计划的回购方式, 不考虑前后对应关系
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_meu_42_2(df):
'''
合规性检查函数，对应MEU_42_2条款：
- subject: 上市公司
- condition: 因转换上市公司发行的可转换为股票的公司债券回购股份且处于定期报告披露前15个交易日内
- constraint: 不得采用集中竞价交易方式出售股份
'''
df = df.copy()
# 初始化标记列
df['meu_42_2_subject'] = True # 所有公司均为上市公司
df['meu_42_2_condition'] = False
df['meu_42_2_constraint'] = None
# 1. 计算时间窗口条件（condition的时间部分）
# 获取所有定期报告类公告日期
report_mask = df['公告类型'].isin(['季报', '年报', '半年报'])
valid_announcements = df[report_mask][['公司简称', '公告日期']].drop_duplicates()
# 计算时间窗口标记列
df['_temp_in_window'] = False
# 为每个公司生成交易日历
for company in valid_announcements['公司简称'].unique():
# 获取该公司的所有交易日
company_trading_days = df[df['公司简称'] == company]['日期'].unique()
company_trading_days = pd.Series(company_trading_days).sort_values().reset_index(drop=True)
# 获取该公司的所有公告日期
company_announcements = valid_announcements[valid_announcements['公司简称'] == company]['公告日期']
for ann_date in company_announcements:
# 找到公告日期在交易日序列中的位置（或最接近的交易日前的位置）
# 如果公告日期不是交易日，找到它之后的第一个交易日
if ann_date in company_trading_days.values:
ann_idx = company_trading_days[company_trading_days == ann_date].index[0]
else:
# 找到第一个大于公告日期的交易日
later_days = company_trading_days[company_trading_days > ann_date]
if len(later_days) > 0:
ann_idx = company_trading_days[company_trading_days == later_days.iloc[0]].index[0]
else:
# 如果没有之后的交易日，跳过这个公告
continue
# 计算前15个交易日的起始位置
start_idx = max(0, ann_idx - 15)
start_date = company_trading_days[start_idx]
# 标记窗口期内的日期
window_mask = (df['公司简称'] == company) & \
(df['日期'] >= start_date) & \
(df['日期'] < ann_date)
df.loc[window_mask, '_temp_in_window'] = True
# 2. 标记condition条件
usage_condition = df['回购用途'] == '转换上市公司发行的可转换为股票的公司债券'
df['meu_42_2_condition'] = usage_condition & df['_temp_in_window']
# 3. 标记constraint条件（独立检查）
# 集中竞价出售包含计划申报和实际成交两种情形
sell_condition = df['存在出售计划'] | (df['当日出售数量'] > 0)
df['meu_42_2_constraint'] = ~sell_condition
# 清理临时列
df.drop(columns=['_temp_in_window'], 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_42_2",
"derived_derived_id": 5,
"derived_id": 2,
"id": "cu_42_2_2",
"law_article_id": 42,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查CU_45_2的合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
合规：价格不等于跌停价（False）
违规：价格等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±10%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
violation = (df['申报价格'] == df['_temp_lower_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = violation # 等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_45_2_1",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查CU_45_2的合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±10%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
violation = (df['申报价格'] == df['_temp_lower_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = violation # 等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查CU_45_2的合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
合规：价格不等于跌停价（False）
违规：价格等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±10%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
violation = (df['申报价格'] == df['_temp_lower_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = violation # 等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_45_2_1",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_2(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±10%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
violation = (df['申报价格'] == df['_temp_lower_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = violation # 等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查CU_45_2的合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
合规：价格不等于跌停价（False）
违规：价格等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±10%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
violation = (df['申报价格'] == df['_temp_lower_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = violation # 等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_45_2_1",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_2(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
合规：价格不等于跌停价（False）
违规：价格等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
violation = (df['申报价格'] == df['_temp_lower_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = violation # 等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查CU_45_2的合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
合规：价格不等于跌停价（False）
违规：价格等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±10%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
violation = (df['申报价格'] == df['_temp_lower_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = violation # 等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_45_2_1",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查CU_45_2的合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±10%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查CU_45_2的合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份
constraint: 申报价格不得为公司股票当日交易跌幅限制的价格（前日收盘价的90%）
合规：价格不等于跌停价（False）
违规：价格等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±10%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.9 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.1 # 涨停价
# 判断申报价格是否为跌停价
violation = (df['申报价格'] == df['_temp_lower_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = violation # 等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_45_2_1",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查cu_45_2的合规性：
subject: 上市公司（所有行均为上市公司）
condition: 采用集中竞价交易方式出售已回购股份（存在出售计划即视为满足）
constraint: 申报价格不得为当日跌幅限制价格（前收盘价的80%），且需在涨跌幅限制范围内（前收盘价的80%~120%之间）
合规：价格在区间内且不等于跌停价（False）
违规：价格超出区间或等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
# 判断申报价格是否在有效区间（大于跌停价且不超过涨停价）
within_limit = (df['申报价格'] > df['_temp_lower_limit']) & (df['申报价格'] <= df['_temp_upper_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = ~within_limit # 超出区间或等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_45_2_2",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查cu_45_2的合规性：
subject: 上市公司（所有行均为上市公司）
condition: 采用集中竞价交易方式出售已回购股份（存在出售计划即视为满足）
constraint: 申报价格不得为当日跌幅限制价格（前收盘价的80%），且需在涨跌幅限制范围内（前收盘价的80%~120%之间）
合规：价格在区间内且不等于跌停价（False）
违规：价格超出区间或等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
# 判断申报价格是否在有效区间（大于跌停价且不超过涨停价）
within_limit = (df['申报价格'] > df['_temp_lower_limit']) & (df['申报价格'] <= df['_temp_upper_limit'])
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查cu_45_2的合规性：
subject: 上市公司（所有行均为上市公司）
condition: 采用集中竞价交易方式出售已回购股份（存在出售计划即视为满足）
constraint: 申报价格不得为当日跌幅限制价格（前收盘价的80%），且需在涨跌幅限制范围内（前收盘价的80%~120%之间）
合规：价格在区间内且不等于跌停价（False）
违规：价格超出区间或等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
# 判断申报价格是否在有效区间（大于跌停价且不超过涨停价）
within_limit = (df['申报价格'] > df['_temp_lower_limit']) & (df['申报价格'] <= df['_temp_upper_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = ~within_limit # 超出区间或等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_45_2_2",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查cu_45_2的合规性：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
违规：价格超出区间或等于跌停价（True）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
# 判断申报价格是否在有效区间（大于跌停价且不超过涨停价）
within_limit = (df['申报价格'] > df['_temp_lower_limit']) & (df['申报价格'] <= df['_temp_upper_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = ~within_limit # 超出区间或等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查cu_45_2的合规性：
subject: 上市公司（所有行均为上市公司）
condition: 采用集中竞价交易方式出售已回购股份（存在出售计划即视为满足）
constraint: 申报价格不得为当日跌幅限制价格（前收盘价的80%），且需在涨跌幅限制范围内（前收盘价的80%~120%之间）
合规：价格在区间内且不等于跌停价（False）
违规：价格超出区间或等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
# 判断申报价格是否在有效区间（大于跌停价且不超过涨停价）
within_limit = (df['申报价格'] > df['_temp_lower_limit']) & (df['申报价格'] <= df['_temp_upper_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = ~within_limit # 超出区间或等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_45_2_2",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_2(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
constraint: 申报价格不得为当日跌幅限制价格（前收盘价的80%），且需在涨跌幅限制范围内（前收盘价的80%~120%之间）
合规：价格在区间内且不等于跌停价（False）
违规：价格超出区间或等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
# 判断申报价格是否在有效区间（大于跌停价且不超过涨停价）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查cu_45_2的合规性：
subject: 上市公司（所有行均为上市公司）
condition: 采用集中竞价交易方式出售已回购股份（存在出售计划即视为满足）
constraint: 申报价格不得为当日跌幅限制价格（前收盘价的80%），且需在涨跌幅限制范围内（前收盘价的80%~120%之间）
合规：价格在区间内且不等于跌停价（False）
违规：价格超出区间或等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
# 判断申报价格是否在有效区间（大于跌停价且不超过涨停价）
within_limit = (df['申报价格'] > df['_temp_lower_limit']) & (df['申报价格'] <= df['_temp_upper_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = ~within_limit # 超出区间或等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_45_2_2",
"law_article_id": 45,
"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_45_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "申报价格不得为公司股票当日交易跌幅限制的价格","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查cu_45_2的合规性：
subject: 上市公司（所有行均为上市公司）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_2(df):
'''
检查cu_45_2的合规性：
subject: 上市公司（所有行均为上市公司）
condition: 采用集中竞价交易方式出售已回购股份（存在出售计划即视为满足）
constraint: 申报价格不得为当日跌幅限制价格（前收盘价的80%），且需在涨跌幅限制范围内（前收盘价的80%~120%之间）
合规：价格在区间内且不等于跌停价（False）
违规：价格超出区间或等于跌停价（True）
'''
df = df.copy()
# 初始化标记列
df['cu_45_2_subject'] = True # 所有公司均为上市公司
df['cu_45_2_condition'] = df['存在出售计划'] # 本案例中'出售'均为集中竞价方式
df['cu_45_2_constraint'] = None
# 计算涨跌停价（前收盘价的±20%）
df['_temp_lower_limit'] = df['前收盘价'] * 0.8 # 跌停价
df['_temp_upper_limit'] = df['前收盘价'] * 1.2 # 涨停价
# 判断申报价格是否在有效区间（大于跌停价且不超过涨停价）
within_limit = (df['申报价格'] > df['_temp_lower_limit']) & (df['申报价格'] <= df['_temp_upper_limit'])
# 标记约束有效性（True=违规，False=合规）
df['cu_45_2_constraint'] = ~within_limit # 超出区间或等于跌停价则违规（True）
# 清理临时列
df.drop(columns=['_temp_lower_limit', '_temp_upper_limit'], 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_45_2",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_45_2_2",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%
'''
df = df.copy()
# 初始化标记列
df['meu_45_3_subject'] = True # 所有记录均为上市公司
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.25
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_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_45_3",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_45_3_1",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%
'''
df = df.copy()
# 初始化标记列
df['meu_45_3_subject'] = True # 所有记录均为上市公司
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.25
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_constraint'] = False
return df
```
|
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%
'''
df = df.copy()
# 初始化标记列
df['meu_45_3_subject'] = True # 所有记录均为上市公司
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.25
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_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_45_3",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_45_3_1",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%
'''
df = df.copy()
# 初始化标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.25
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_constraint'] = False
return df
```
|
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%
'''
df = df.copy()
# 初始化标记列
df['meu_45_3_subject'] = True # 所有记录均为上市公司
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.25
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_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_45_3",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_45_3_1",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_constraint'] = False
return df
```
|
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%
'''
df = df.copy()
# 初始化标记列
df['meu_45_3_subject'] = True # 所有记录均为上市公司
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.25
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_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_45_3",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_45_3_1",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%
'''
df = df.copy()
# 初始化标记列
df['meu_45_3_subject'] = True # 所有记录均为上市公司
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.25
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_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_45_3",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_45_3_1",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_45_3(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化标记列
df['meu_45_3_subject'] = True # 所有记录均为上市公司
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_constraint'] = False
return df
```
|
```python
def check_meu_45_3(df):
'''
检查MEU_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过1万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的25%
'''
df = df.copy()
# 初始化标记列
df['meu_45_3_subject'] = True # 所有记录均为上市公司
df['meu_45_3_condition'] = False
df['meu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>1万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 10000)
df.loc[valid_condition, 'meu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.25
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'meu_45_3_constraint'] = True
else:
df.loc[idx, 'meu_45_3_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_45_3",
"derived_derived_id": 5,
"derived_id": 1,
"id": "cu_45_3_1",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%
'''
df = df.copy()
# 初始化标记列
df['cu_45_3_subject'] = True # 所有记录均为上市公司
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_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_45_3",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_45_3_2",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%
'''
df = df.copy()
# 初始化标记列
df['cu_45_3_subject'] = True # 所有记录均为上市公司
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
else:
df.loc[idx, 'cu_45_3_constraint'] = False
return df
```
|
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%
'''
df = df.copy()
# 初始化标记列
df['cu_45_3_subject'] = True # 所有记录均为上市公司
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_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_45_3",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_45_3_2",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_constraint'] = False
return df
```
|
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%
'''
df = df.copy()
# 初始化标记列
df['cu_45_3_subject'] = True # 所有记录均为上市公司
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_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_45_3",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_45_3_2",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_constraint'] = False
return df
```
|
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%
'''
df = df.copy()
# 初始化标记列
df['cu_45_3_subject'] = True # 所有记录均为上市公司
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_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_45_3",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_45_3_2",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_constraint'] = False
return df
```
|
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%
'''
df = df.copy()
# 初始化标记列
df['cu_45_3_subject'] = True # 所有记录均为上市公司
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_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_45_3",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_45_3_2",
"law_article_id": 45,
"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_45_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股","constraint": "每日出售的数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%","contextual_info": null}
必要的额外信息: nan
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%
'''
df = df.copy()
# 初始化标记列
df['cu_45_3_subject'] = True # 所有记录均为上市公司
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[idx, 'cu_45_3_constraint'] = False
return df
```
|
```python
def check_cu_45_3(df):
'''
检查cu_45_3合规性：
subject: 上市公司
condition: 采用集中竞价交易方式出售已回购股份且每日出售数量超过5万股
constraint: 每日出售数量不得超过出售计划披露日前20个交易日日均盘中成交量的15%
'''
df = df.copy()
# 初始化标记列
df['cu_45_3_subject'] = True # 所有记录均为上市公司
df['cu_45_3_condition'] = False
df['cu_45_3_constraint'] = None
# 1. 标记condition条件
# 条件需同时满足：存在出售计划、采用集中竞价方式（隐含在存在出售计划中）、当日出售数量>5万
valid_condition = df['存在出售计划'] & (df['当日出售数量'] > 50000)
df.loc[valid_condition, 'cu_45_3_condition'] = True
# 2. 标记constraint约束（独立检查所有记录）
# 预处理：计算每个公司每个披露日前20日成交量均值
# 假设存在'成交量'列且'公告日期'为计划披露日
# 按公司分组处理
for company in df['公司简称'].unique():
company_df = df[df['公司简称'] == company].sort_values('日期')
# 创建日期索引
company_dates = company_df.set_index('日期')
# 遍历该公司的所有记录
for idx, row in company_df.iterrows():
disclosure_date = row['出售计划披露日']
if pd.isnull(disclosure_date):
continue
# 获取披露日前20个交易日的成交量
# 筛选披露日前的交易日
prior_dates = company_dates[company_dates.index < disclosure_date].index
# 获取最近的20个交易日
last_20_trading_days = prior_dates[-20:]
prior_sessions = company_dates.loc[last_20_trading_days]
avg_volume = prior_sessions['成交量'].mean()
threshold = avg_volume * 0.15
current_sell = row['当日出售数量']
# 标记约束满足情况
if current_sell <= threshold:
df.loc[idx, 'cu_45_3_constraint'] = True
else:
df.loc[idx, 'cu_45_3_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_45_3",
"derived_derived_id": 5,
"derived_id": 2,
"id": "cu_45_3_2",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续60日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 60交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['60交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(60, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['60交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['60交易日累计出售'], 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_45_4",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_45_4_1",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续60日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 60交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['60交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_45_4_constraint'] = df['60交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['60交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 60交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['60交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(60, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['60交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['60交易日累计出售'], 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_45_4",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_45_4_1",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续60日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 60交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['60交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(60, min_periods=1).sum()
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 清理中间列
df.drop(columns=['60交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 60交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['60交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(60, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['60交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['60交易日累计出售'], 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_45_4",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_45_4_1",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续60日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
______MASKED______
______MASKED______
______MASKED______
______MASKED______
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['60交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['60交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 60交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['60交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(60, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['60交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['60交易日累计出售'], 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_45_4",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_45_4_1",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续60日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['60交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['60交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 60交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['60交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(60, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['60交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['60交易日累计出售'], 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_45_4",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_45_4_1",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续30日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查cu_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 30交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['30交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(30, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], 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_45_4",
"derived_derived_id": 0,
"derived_id": 2,
"id": "cu_45_4_2",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续30日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
- constraint: 30交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['30交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(30, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查cu_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 30交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['30交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(30, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], 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_45_4",
"derived_derived_id": 1,
"derived_id": 2,
"id": "cu_45_4_2",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续30日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查cu_45_4合规性：
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
______MASKED______
______MASKED______
______MASKED______
______MASKED______
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查cu_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 30交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['30交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(30, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], 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_45_4",
"derived_derived_id": 2,
"derived_id": 2,
"id": "cu_45_4_2",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续30日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查cu_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 30交易日累计出售量≤总股本1%
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查cu_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 30交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['30交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(30, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], 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_45_4",
"derived_derived_id": 3,
"derived_id": 2,
"id": "cu_45_4_2",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续30日内，出售股份的总数不得超过公司股份总数的1%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查cu_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 30交易日累计出售量≤总股本1%
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
lambda x: x.rolling(30, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查cu_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 30交易日累计出售量≤总股本1%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['30交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(30, min_periods=1).sum()
)
# 计算总股本1%阈值并验证约束
threshold = df['总股本'] * 0.01
df['cu_45_4_constraint'] = df['30交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['30交易日累计出售'], 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_45_4",
"derived_derived_id": 4,
"derived_id": 2,
"id": "cu_45_4_2",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续90日内，出售股份的总数不得超过公司股份总数的2%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 在任意连续90交易日内，出售股份的总数不得超过公司股份总数的2%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['90交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(90, min_periods=1).sum()
)
# 计算总股本2%阈值并验证约束
threshold = df['总股本'] * 0.02
df['cu_45_4_constraint'] = df['90交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['90交易日累计出售'], 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_45_4",
"derived_derived_id": 0,
"derived_id": 3,
"id": "cu_45_4_3",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续90日内，出售股份的总数不得超过公司股份总数的2%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['90交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(90, min_periods=1).sum()
)
# 计算总股本2%阈值并验证约束
threshold = df['总股本'] * 0.02
df['cu_45_4_constraint'] = df['90交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['90交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 在任意连续90交易日内，出售股份的总数不得超过公司股份总数的2%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['90交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(90, min_periods=1).sum()
)
# 计算总股本2%阈值并验证约束
threshold = df['总股本'] * 0.02
df['cu_45_4_constraint'] = df['90交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['90交易日累计出售'], 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_45_4",
"derived_derived_id": 1,
"derived_id": 3,
"id": "cu_45_4_3",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续90日内，出售股份的总数不得超过公司股份总数的2%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['90交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(90, min_periods=1).sum()
)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.drop(columns=['90交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 在任意连续90交易日内，出售股份的总数不得超过公司股份总数的2%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['90交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(90, min_periods=1).sum()
)
# 计算总股本2%阈值并验证约束
threshold = df['总股本'] * 0.02
df['cu_45_4_constraint'] = df['90交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['90交易日累计出售'], 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_45_4",
"derived_derived_id": 2,
"derived_id": 3,
"id": "cu_45_4_3",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续90日内，出售股份的总数不得超过公司股份总数的2%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
______MASKED______
______MASKED______
______MASKED______
______MASKED______
- constraint: 在任意连续90交易日内，出售股份的总数不得超过公司股份总数的2%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算总股本2%阈值并验证约束
threshold = df['总股本'] * 0.02
df['cu_45_4_constraint'] = df['90交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['90交易日累计出售'], inplace=True)
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 在任意连续90交易日内，出售股份的总数不得超过公司股份总数的2%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['90交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(90, min_periods=1).sum()
)
# 计算总股本2%阈值并验证约束
threshold = df['总股本'] * 0.02
df['cu_45_4_constraint'] = df['90交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['90交易日累计出售'], 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_45_4",
"derived_derived_id": 3,
"derived_id": 3,
"id": "cu_45_4_3",
"law_article_id": 45,
"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_45_4
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份","constraint": "在任意连续90日内，出售股份的总数不得超过公司股份总数的2%","contextual_info": null}
必要的额外信息: 90日以自然日计算
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 在任意连续90交易日内，出售股份的总数不得超过公司股份总数的2%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 计算总股本2%阈值并验证约束
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_cu_45_4(df):
'''
检查CU_45_4合规性：
- subject: 上市公司（所有行自动满足）
- condition: 存在集中竞价出售已回购股份计划
- constraint: 在任意连续90交易日内，出售股份的总数不得超过公司股份总数的2%
'''
df = df.copy()
# 初始化合规标记列
df['cu_45_4_subject'] = True # 所有公司均为上市公司
df['cu_45_4_condition'] = df['存在出售计划'].astype(bool) # 存在出售计划即满足条件
df['cu_45_4_constraint'] = None # 初始化为空值
# 按公司分组计算滚动累计出售量
df.sort_values(['公司简称', '日期'], inplace=True)
df['90交易日累计出售'] = df.groupby('公司简称')['当日出售数量'].transform(
lambda x: x.rolling(90, min_periods=1).sum()
)
# 计算总股本2%阈值并验证约束
threshold = df['总股本'] * 0.02
df['cu_45_4_constraint'] = df['90交易日累计出售'] <= threshold
# 清理中间列
df.drop(columns=['90交易日累计出售'], 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_45_4",
"derived_derived_id": 4,
"derived_id": 3,
"id": "cu_45_4_3",
"law_article_id": 45,
"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_46_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 对每一个需要披露的日期标记constraint情况, 对不需要的日期保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
# 步骤1：获取每个首次出售的次2交易日
df_sorted = df.sort_values(['公司简称', '日期'])
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
first_sales = (
df[valid_condition]
.groupby(group_cols)[['首次出售日期']] # 仅按分组键聚合
.first()
.reset_index()
)
first_sales = first_sales.merge(
df_sorted[['公司简称', '日期', '次交易日']],
left_on=['公司简称', '首次出售日期'],
right_on=['公司简称', '日期'],
how='left'
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
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_46_2",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_46_2_1",
"law_article_id": 46,
"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_46_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 对每一个需要披露的日期标记constraint情况, 对不需要的日期保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df_sorted[['公司简称', '日期', '次交易日']],
left_on=['公司简称', '首次出售日期'],
right_on=['公司简称', '日期'],
how='left'
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
return df
```
|
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
# 步骤1：获取每个首次出售的次2交易日
df_sorted = df.sort_values(['公司简称', '日期'])
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
first_sales = (
df[valid_condition]
.groupby(group_cols)[['首次出售日期']] # 仅按分组键聚合
.first()
.reset_index()
)
first_sales = first_sales.merge(
df_sorted[['公司简称', '日期', '次交易日']],
left_on=['公司简称', '首次出售日期'],
right_on=['公司简称', '日期'],
how='left'
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
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_46_2",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_46_2_1",
"law_article_id": 46,
"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_46_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 对每一个需要披露的日期标记constraint情况, 对不需要的日期保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
first_sales = first_sales.merge(
df_sorted[['公司简称', '日期', '次交易日']],
left_on=['公司简称', '首次出售日期'],
right_on=['公司简称', '日期'],
how='left'
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
return df
```
|
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
# 步骤1：获取每个首次出售的次2交易日
df_sorted = df.sort_values(['公司简称', '日期'])
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
first_sales = (
df[valid_condition]
.groupby(group_cols)[['首次出售日期']] # 仅按分组键聚合
.first()
.reset_index()
)
first_sales = first_sales.merge(
df_sorted[['公司简称', '日期', '次交易日']],
left_on=['公司简称', '首次出售日期'],
right_on=['公司简称', '日期'],
how='left'
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
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_46_2",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_46_2_1",
"law_article_id": 46,
"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_46_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 对每一个需要披露的日期标记constraint情况, 对不需要的日期保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
# 步骤1：获取每个首次出售的次2交易日
df_sorted = df.sort_values(['公司简称', '日期'])
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
return df
```
|
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
# 步骤1：获取每个首次出售的次2交易日
df_sorted = df.sort_values(['公司简称', '日期'])
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
first_sales = (
df[valid_condition]
.groupby(group_cols)[['首次出售日期']] # 仅按分组键聚合
.first()
.reset_index()
)
first_sales = first_sales.merge(
df_sorted[['公司简称', '日期', '次交易日']],
left_on=['公司简称', '首次出售日期'],
right_on=['公司简称', '日期'],
how='left'
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
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_46_2",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_46_2_1",
"law_article_id": 46,
"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_46_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 对每一个需要披露的日期标记constraint情况, 对不需要的日期保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
return df
```
|
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
# 步骤1：获取每个首次出售的次2交易日
df_sorted = df.sort_values(['公司简称', '日期'])
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
first_sales = (
df[valid_condition]
.groupby(group_cols)[['首次出售日期']] # 仅按分组键聚合
.first()
.reset_index()
)
first_sales = first_sales.merge(
df_sorted[['公司简称', '日期', '次交易日']],
left_on=['公司简称', '首次出售日期'],
right_on=['公司简称', '日期'],
how='left'
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
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_46_2",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_46_2_1",
"law_article_id": 46,
"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_46_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 对每一个需要披露的日期标记constraint情况, 对不需要的日期保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
# 步骤1：获取每个首次出售的次2交易日
df_sorted = df.sort_values(['公司简称', '日期'])
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
first_sales = (
df[valid_condition]
.groupby(group_cols)[['首次出售日期']] # 仅按分组键聚合
.first()
.reset_index()
)
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
return df
```
|
```python
def check_meu_46_2(df):
'''
检查MEU_46_2合规性：
"subject": "上市公司",
"condition": "采用集中竞价交易方式出售已回购股份期间",
"constraint": "首次出售已回购股份事实发生后应当在次2个交易日内披露出售进展情况公告"
'''
df = df.copy()
# 1. 初始化标记列
df['meu_46_2_subject'] = True # 所有公司都是上市公司
df['meu_46_2_condition'] = False
df['meu_46_2_constraint'] = None
# 2. 标记condition
# 筛选存在集中竞价出售计划的行
has_plan = df['存在出售计划'] == True
df['meu_46_2_condition'] = has_plan
# 3 判断constraint
# 3.1 判断是否在出售期间内
mask_date_range = (df['日期'] >= df['出售开始日']) & (df['日期'] <= df['出售截止日'])
# 3.2 准确计算首次出售日期（修复分组索引问题）
group_cols = ['公司简称', '出售开始日', '出售截止日']
# 生成分组首次出售日期（保持分组键结构）
first_sale_df = (
df.groupby(group_cols)
.apply(
lambda g: g.loc[
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0), '日期'
].min()
if any(
(g['日期'] >= g.name[1]) &
(g['日期'] <= g.name[2]) &
(g['当日出售数量'] > 0)
)
else pd.NaT
)
.reset_index(name='首次出售日期')
)
# 合并回原始数据（避免索引错位）
df = df.merge(first_sale_df, on=group_cols, how='left')
# 3.3 判断当前日期是否在首次出售之后
mask_first_sale = (df['日期'] >= df['首次出售日期']) & (~df['首次出售日期'].isna())
# 需要检查的条件
valid_condition = has_plan & mask_date_range & mask_first_sale
# 条件3：标记constraint（修复次交易日合并问题）
# 步骤1：获取每个首次出售的次2交易日
df_sorted = df.sort_values(['公司简称', '日期'])
df_sorted['次交易日'] = df_sorted.groupby('公司简称')['日期'].shift(-2)
# 步骤2：建立精确映射关系（包含首次出售日期）
first_sales = (
df[valid_condition]
.groupby(group_cols)[['首次出售日期']] # 仅按分组键聚合
.first()
.reset_index()
)
first_sales = first_sales.merge(
df_sorted[['公司简称', '日期', '次交易日']],
left_on=['公司简称', '首次出售日期'],
right_on=['公司简称', '日期'],
how='left'
).drop(columns=['日期']).rename(columns={'次交易日': '要求披露日'}) # 清理冗余列
# 步骤3：多键合并避免数据污染
df = df.merge(
first_sales,
on=group_cols + ['首次出售日期'],
how='left'
)
# 步骤4：验证次2日披露情况
valid_constraint = (
(df['首次出售日期'].notna()) &
(df['存在出售计划'] == True)
)
df.loc[valid_constraint, 'meu_46_2_constraint'] = df[df['日期'] == df['要求披露日']]['披露出售进展']
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_46_2",
"derived_derived_id": 5,
"derived_id": 1,
"id": "cu_46_2_1",
"law_article_id": 46,
"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_46_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "出售已回购股份占上市公司总股本的比例增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 理解为"每增加1%"需要披露; 划分披露的窗口期, 对整个窗口期标记constraint是否符合, 不在窗口期内的可标记为True或者保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
df['cu_46_3_subject'] = True
df['cu_46_3_condition'] = False
df['cu_46_3_constraint'] = None
# 标记存在出售计划的期间
in_selling_period = df['存在出售计划']
df.loc[in_selling_period, 'cu_46_3_condition'] = True
violations = set()
# 按公司分组处理
grouped = df.groupby('公司简称')
for company, group in grouped:
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
if pd.isna(prev):
continue
# 计算跨过的整数百分点（每2%触发）
prev_pct = prev * 100
curr_pct = curr * 100
min_k = int(np.floor(prev_pct / 2)) + 1
max_k = int(np.floor(curr_pct / 2))
if min_k > max_k:
continue
# 生成所有触发k值
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], 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_46_3",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_46_3_1",
"law_article_id": 46,
"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_46_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "出售已回购股份占上市公司总股本的比例增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 理解为"每增加1%"需要披露; 划分披露的窗口期, 对整个窗口期标记constraint是否符合, 不在窗口期内的可标记为True或者保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
grouped = df.groupby('公司简称')
for company, group in grouped:
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
if pd.isna(prev):
continue
# 计算跨过的整数百分点（每2%触发）
prev_pct = prev * 100
curr_pct = curr * 100
min_k = int(np.floor(prev_pct / 2)) + 1
max_k = int(np.floor(curr_pct / 2))
if min_k > max_k:
continue
# 生成所有触发k值
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
df['cu_46_3_subject'] = True
df['cu_46_3_condition'] = False
df['cu_46_3_constraint'] = None
# 标记存在出售计划的期间
in_selling_period = df['存在出售计划']
df.loc[in_selling_period, 'cu_46_3_condition'] = True
violations = set()
# 按公司分组处理
grouped = df.groupby('公司简称')
for company, group in grouped:
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
if pd.isna(prev):
continue
# 计算跨过的整数百分点（每2%触发）
prev_pct = prev * 100
curr_pct = curr * 100
min_k = int(np.floor(prev_pct / 2)) + 1
max_k = int(np.floor(curr_pct / 2))
if min_k > max_k:
continue
# 生成所有触发k值
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], 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_46_3",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_46_3_1",
"law_article_id": 46,
"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_46_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "出售已回购股份占上市公司总股本的比例增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 理解为"每增加1%"需要披露; 划分披露的窗口期, 对整个窗口期标记constraint是否符合, 不在窗口期内的可标记为True或者保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
grouped = df.groupby('公司简称')
for company, group in grouped:
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
df['cu_46_3_subject'] = True
df['cu_46_3_condition'] = False
df['cu_46_3_constraint'] = None
# 标记存在出售计划的期间
in_selling_period = df['存在出售计划']
df.loc[in_selling_period, 'cu_46_3_condition'] = True
violations = set()
# 按公司分组处理
grouped = df.groupby('公司简称')
for company, group in grouped:
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
if pd.isna(prev):
continue
# 计算跨过的整数百分点（每2%触发）
prev_pct = prev * 100
curr_pct = curr * 100
min_k = int(np.floor(prev_pct / 2)) + 1
max_k = int(np.floor(curr_pct / 2))
if min_k > max_k:
continue
# 生成所有触发k值
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], 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_46_3",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_46_3_1",
"law_article_id": 46,
"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_46_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "出售已回购股份占上市公司总股本的比例增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 理解为"每增加1%"需要披露; 划分披露的窗口期, 对整个窗口期标记constraint是否符合, 不在窗口期内的可标记为True或者保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
df['cu_46_3_subject'] = True
df['cu_46_3_condition'] = False
df['cu_46_3_constraint'] = None
# 标记存在出售计划的期间
in_selling_period = df['存在出售计划']
df.loc[in_selling_period, 'cu_46_3_condition'] = True
violations = set()
# 按公司分组处理
grouped = df.groupby('公司简称')
for company, group in grouped:
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
if pd.isna(prev):
continue
# 计算跨过的整数百分点（每2%触发）
prev_pct = prev * 100
curr_pct = curr * 100
min_k = int(np.floor(prev_pct / 2)) + 1
max_k = int(np.floor(curr_pct / 2))
if min_k > max_k:
continue
# 生成所有触发k值
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], 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_46_3",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_46_3_1",
"law_article_id": 46,
"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_46_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "出售已回购股份占上市公司总股本的比例增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 理解为"每增加1%"需要披露; 划分披露的窗口期, 对整个窗口期标记constraint是否符合, 不在窗口期内的可标记为True或者保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
df['cu_46_3_subject'] = True
df['cu_46_3_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 生成所有触发k值
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
df['cu_46_3_subject'] = True
df['cu_46_3_condition'] = False
df['cu_46_3_constraint'] = None
# 标记存在出售计划的期间
in_selling_period = df['存在出售计划']
df.loc[in_selling_period, 'cu_46_3_condition'] = True
violations = set()
# 按公司分组处理
grouped = df.groupby('公司简称')
for company, group in grouped:
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
if pd.isna(prev):
continue
# 计算跨过的整数百分点（每2%触发）
prev_pct = prev * 100
curr_pct = curr * 100
min_k = int(np.floor(prev_pct / 2)) + 1
max_k = int(np.floor(curr_pct / 2))
if min_k > max_k:
continue
# 生成所有触发k值
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], 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_46_3",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_46_3_1",
"law_article_id": 46,
"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_46_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "采用集中竞价交易方式出售已回购股份期间","constraint": "出售已回购股份占上市公司总股本的比例增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告","contextual_info": null}
必要的额外信息: 理解为"每增加1%"需要披露; 划分披露的窗口期, 对整个窗口期标记constraint是否符合, 不在窗口期内的可标记为True或者保留为None
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
df['cu_46_3_subject'] = True
df['cu_46_3_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
if pd.isna(prev):
continue
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], inplace=True, errors='ignore')
return df
```
|
```python
import pandas as pd
import numpy as np
def check_cu_46_3(df):
'''
检查cu_46_3合规性：
subject: 上市公司（所有行自动满足）
condition: 采用集中竞价交易方式出售已回购股份期间
constraint: 出售已回购股份占上市公司总股本的比例每增加2%, 应当在事实发生之日起3个交易日内披露出售进展情况公告
'''
df = df.copy()
# 初始化标记列
df['cu_46_3_subject'] = True
df['cu_46_3_condition'] = False
df['cu_46_3_constraint'] = None
# 标记存在出售计划的期间
in_selling_period = df['存在出售计划']
df.loc[in_selling_period, 'cu_46_3_condition'] = True
violations = set()
# 按公司分组处理
grouped = df.groupby('公司简称')
for company, group in grouped:
# 筛选存在出售计划的期间
selling_group = group[group['存在出售计划']]
if selling_group.empty:
continue
sell_dates = set(selling_group['日期'])
company_dates = group['日期'].tolist()
# 计算前一日累计比例
selling_group = selling_group.copy()
selling_group['累计出售比例_prev'] = selling_group['累计出售比例'].shift(1)
for idx, row in selling_group.iterrows():
curr = row['累计出售比例']
prev = row['累计出售比例_prev']
if pd.isna(prev):
continue
# 计算跨过的整数百分点（每2%触发）
prev_pct = prev * 100
curr_pct = curr * 100
min_k = int(np.floor(prev_pct / 2)) + 1
max_k = int(np.floor(curr_pct / 2))
if min_k > max_k:
continue
# 生成所有触发k值
for k in range(min_k, max_k + 1):
trigger_date = row['日期']
# 获取窗口期
try:
trigger_idx = company_dates.index(trigger_date)
except ValueError:
continue
window_dates = company_dates[trigger_idx+1 : trigger_idx+4]
# 检查窗口期披露情况
window_mask = group['日期'].isin(window_dates)
has_disclosure = group.loc[window_mask, '披露出售进展'].any()
# 记录未披露的出售期间日期
if not has_disclosure:
for date in window_dates:
if date in sell_dates:
violations.add((company, date))
# 应用违规标记
df.loc[in_selling_period, 'cu_46_3_constraint'] = True
violation_mask = df.apply(lambda r: (r['公司简称'], r['日期']) in violations, axis=1)
df.loc[violation_mask & in_selling_period, 'cu_46_3_constraint'] = False
# 清理中间列
df.drop(columns=['累计出售比例_prev'], 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_46_3",
"derived_derived_id": 5,
"derived_id": 1,
"id": "cu_46_3_1",
"law_article_id": 46,
"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_50_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得少于50个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_50_2(df):
'''
检查cu_50_2合规性：
"subject": "上市公司",
"condition": "实施要约回购",
"constraint": "要约期限不得少于50个自然日",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
df['cu_50_2_constraint'] = None
# 标记valid的condition（存在回购方案且为要约回购）
is_passed = df['存在回购方案'] & (df['日期'] == df['决议通过日'])
is_tender_offer = df['回购方式'] == '要约回购'
df.loc[is_passed & is_tender_offer, 'cu_50_2_condition'] = True
# 标记valid的constraint（自然日计算要约期限）
# 处理NaN并转换为布尔值
valid_constraint = (df['要约期限'] >= 50).fillna(False)
df['cu_50_2_constraint'] = valid_constraint.astype(bool)
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_50_2",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_50_2_1",
"law_article_id": 50,
"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_50_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得少于50个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_50_2(df):
'''
检查cu_50_2合规性：
"subject": "上市公司",
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
df['cu_50_2_constraint'] = None
# 标记valid的condition（存在回购方案且为要约回购）
is_passed = df['存在回购方案'] & (df['日期'] == df['决议通过日'])
is_tender_offer = df['回购方式'] == '要约回购'
df.loc[is_passed & is_tender_offer, 'cu_50_2_condition'] = True
# 标记valid的constraint（自然日计算要约期限）
# 处理NaN并转换为布尔值
valid_constraint = (df['要约期限'] >= 50).fillna(False)
df['cu_50_2_constraint'] = valid_constraint.astype(bool)
return df
```
|
```python
import pandas as pd
def check_cu_50_2(df):
'''
检查cu_50_2合规性：
"subject": "上市公司",
"condition": "实施要约回购",
"constraint": "要约期限不得少于50个自然日",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
df['cu_50_2_constraint'] = None
# 标记valid的condition（存在回购方案且为要约回购）
is_passed = df['存在回购方案'] & (df['日期'] == df['决议通过日'])
is_tender_offer = df['回购方式'] == '要约回购'
df.loc[is_passed & is_tender_offer, 'cu_50_2_condition'] = True
# 标记valid的constraint（自然日计算要约期限）
# 处理NaN并转换为布尔值
valid_constraint = (df['要约期限'] >= 50).fillna(False)
df['cu_50_2_constraint'] = valid_constraint.astype(bool)
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_50_2",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_50_2_1",
"law_article_id": 50,
"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_50_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得少于50个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_50_2(df):
'''
检查cu_50_2合规性：
"subject": "上市公司",
"condition": "实施要约回购",
"constraint": "要约期限不得少于50个自然日",
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
df['cu_50_2_constraint'] = None
# 标记valid的condition（存在回购方案且为要约回购）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 处理NaN并转换为布尔值
valid_constraint = (df['要约期限'] >= 50).fillna(False)
df['cu_50_2_constraint'] = valid_constraint.astype(bool)
return df
```
|
```python
import pandas as pd
def check_cu_50_2(df):
'''
检查cu_50_2合规性：
"subject": "上市公司",
"condition": "实施要约回购",
"constraint": "要约期限不得少于50个自然日",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
df['cu_50_2_constraint'] = None
# 标记valid的condition（存在回购方案且为要约回购）
is_passed = df['存在回购方案'] & (df['日期'] == df['决议通过日'])
is_tender_offer = df['回购方式'] == '要约回购'
df.loc[is_passed & is_tender_offer, 'cu_50_2_condition'] = True
# 标记valid的constraint（自然日计算要约期限）
# 处理NaN并转换为布尔值
valid_constraint = (df['要约期限'] >= 50).fillna(False)
df['cu_50_2_constraint'] = valid_constraint.astype(bool)
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_50_2",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_50_2_1",
"law_article_id": 50,
"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_50_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得少于50个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_50_2(df):
'''
检查cu_50_2合规性：
"subject": "上市公司",
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df = df.copy()
# 初始化合规标记列
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
df['cu_50_2_constraint'] = None
# 标记valid的condition（存在回购方案且为要约回购）
is_passed = df['存在回购方案'] & (df['日期'] == df['决议通过日'])
is_tender_offer = df['回购方式'] == '要约回购'
df.loc[is_passed & is_tender_offer, 'cu_50_2_condition'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
return df
```
|
```python
import pandas as pd
def check_cu_50_2(df):
'''
检查cu_50_2合规性：
"subject": "上市公司",
"condition": "实施要约回购",
"constraint": "要约期限不得少于50个自然日",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
df['cu_50_2_constraint'] = None
# 标记valid的condition（存在回购方案且为要约回购）
is_passed = df['存在回购方案'] & (df['日期'] == df['决议通过日'])
is_tender_offer = df['回购方式'] == '要约回购'
df.loc[is_passed & is_tender_offer, 'cu_50_2_condition'] = True
# 标记valid的constraint（自然日计算要约期限）
# 处理NaN并转换为布尔值
valid_constraint = (df['要约期限'] >= 50).fillna(False)
df['cu_50_2_constraint'] = valid_constraint.astype(bool)
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_50_2",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_50_2_1",
"law_article_id": 50,
"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_50_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得少于50个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_50_2(df):
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[is_passed & is_tender_offer, 'cu_50_2_condition'] = True
# 标记valid的constraint（自然日计算要约期限）
# 处理NaN并转换为布尔值
valid_constraint = (df['要约期限'] >= 50).fillna(False)
df['cu_50_2_constraint'] = valid_constraint.astype(bool)
return df
```
|
```python
import pandas as pd
def check_cu_50_2(df):
'''
检查cu_50_2合规性：
"subject": "上市公司",
"condition": "实施要约回购",
"constraint": "要约期限不得少于50个自然日",
"contextual_info": NaN
'''
df = df.copy()
# 初始化合规标记列
df['cu_50_2_subject'] = True # 所有公司均为上市公司
df['cu_50_2_condition'] = False
df['cu_50_2_constraint'] = None
# 标记valid的condition（存在回购方案且为要约回购）
is_passed = df['存在回购方案'] & (df['日期'] == df['决议通过日'])
is_tender_offer = df['回购方式'] == '要约回购'
df.loc[is_passed & is_tender_offer, 'cu_50_2_condition'] = True
# 标记valid的constraint（自然日计算要约期限）
# 处理NaN并转换为布尔值
valid_constraint = (df['要约期限'] >= 50).fillna(False)
df['cu_50_2_constraint'] = valid_constraint.astype(bool)
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_50_2",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_50_2_1",
"law_article_id": 50,
"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_50_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得超过90个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
|
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
- condition: 实施要约回购
- constraint: 要约期限不得超过90个自然日
'''
df = df.copy()
# 初始化标记列
df['cu_50_3_subject'] = True # 所有公司均为上市公司
df['cu_50_3_condition'] = False
df['cu_50_3_constraint'] = None
# 标记条件：实施要约回购（存在有效回购方案且回购方式为要约回购）
valid_condition = (df['存在回购方案']) & (df['回购方式'] == '要约回购') & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'cu_50_3_condition'] = True
# 标记约束：计算自然日差（需处理空值）
has_valid_dates = df['实施开始日'].notna() & df['实施截止日'].notna()
duration = (df['实施截止日'] - df['实施开始日']).dt.days
valid_constraint = (duration <= 90) & has_valid_dates
# 更新约束标记（独立检查，不依赖subject和condition）
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_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_50_3",
"derived_derived_id": 0,
"derived_id": 1,
"id": "cu_50_3_1",
"law_article_id": 50,
"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_50_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得超过90个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化标记列
df['cu_50_3_subject'] = True # 所有公司均为上市公司
df['cu_50_3_condition'] = False
df['cu_50_3_constraint'] = None
# 标记条件：实施要约回购（存在有效回购方案且回购方式为要约回购）
valid_condition = (df['存在回购方案']) & (df['回购方式'] == '要约回购') & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'cu_50_3_condition'] = True
# 标记约束：计算自然日差（需处理空值）
has_valid_dates = df['实施开始日'].notna() & df['实施截止日'].notna()
duration = (df['实施截止日'] - df['实施开始日']).dt.days
valid_constraint = (duration <= 90) & has_valid_dates
# 更新约束标记（独立检查，不依赖subject和condition）
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
- condition: 实施要约回购
- constraint: 要约期限不得超过90个自然日
'''
df = df.copy()
# 初始化标记列
df['cu_50_3_subject'] = True # 所有公司均为上市公司
df['cu_50_3_condition'] = False
df['cu_50_3_constraint'] = None
# 标记条件：实施要约回购（存在有效回购方案且回购方式为要约回购）
valid_condition = (df['存在回购方案']) & (df['回购方式'] == '要约回购') & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'cu_50_3_condition'] = True
# 标记约束：计算自然日差（需处理空值）
has_valid_dates = df['实施开始日'].notna() & df['实施截止日'].notna()
duration = (df['实施截止日'] - df['实施开始日']).dt.days
valid_constraint = (duration <= 90) & has_valid_dates
# 更新约束标记（独立检查，不依赖subject和condition）
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_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_50_3",
"derived_derived_id": 1,
"derived_id": 1,
"id": "cu_50_3_1",
"law_article_id": 50,
"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_50_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得超过90个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
- condition: 实施要约回购
- constraint: 要约期限不得超过90个自然日
'''
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df['cu_50_3_constraint'] = None
# 标记条件：实施要约回购（存在有效回购方案且回购方式为要约回购）
valid_condition = (df['存在回购方案']) & (df['回购方式'] == '要约回购') & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'cu_50_3_condition'] = True
# 标记约束：计算自然日差（需处理空值）
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
- condition: 实施要约回购
- constraint: 要约期限不得超过90个自然日
'''
df = df.copy()
# 初始化标记列
df['cu_50_3_subject'] = True # 所有公司均为上市公司
df['cu_50_3_condition'] = False
df['cu_50_3_constraint'] = None
# 标记条件：实施要约回购（存在有效回购方案且回购方式为要约回购）
valid_condition = (df['存在回购方案']) & (df['回购方式'] == '要约回购') & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'cu_50_3_condition'] = True
# 标记约束：计算自然日差（需处理空值）
has_valid_dates = df['实施开始日'].notna() & df['实施截止日'].notna()
duration = (df['实施截止日'] - df['实施开始日']).dt.days
valid_constraint = (duration <= 90) & has_valid_dates
# 更新约束标记（独立检查，不依赖subject和condition）
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_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_50_3",
"derived_derived_id": 2,
"derived_id": 1,
"id": "cu_50_3_1",
"law_article_id": 50,
"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_50_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得超过90个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 初始化标记列
df['cu_50_3_subject'] = True # 所有公司均为上市公司
df['cu_50_3_condition'] = False
df['cu_50_3_constraint'] = None
# 标记条件：实施要约回购（存在有效回购方案且回购方式为要约回购）
valid_condition = (df['存在回购方案']) & (df['回购方式'] == '要约回购') & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'cu_50_3_condition'] = True
______MASKED______
______MASKED______
______MASKED______
______MASKED______
# 更新约束标记（独立检查，不依赖subject和condition）
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
- condition: 实施要约回购
- constraint: 要约期限不得超过90个自然日
'''
df = df.copy()
# 初始化标记列
df['cu_50_3_subject'] = True # 所有公司均为上市公司
df['cu_50_3_condition'] = False
df['cu_50_3_constraint'] = None
# 标记条件：实施要约回购（存在有效回购方案且回购方式为要约回购）
valid_condition = (df['存在回购方案']) & (df['回购方式'] == '要约回购') & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'cu_50_3_condition'] = True
# 标记约束：计算自然日差（需处理空值）
has_valid_dates = df['实施开始日'].notna() & df['实施截止日'].notna()
duration = (df['实施截止日'] - df['实施开始日']).dt.days
valid_constraint = (duration <= 90) & has_valid_dates
# 更新约束标记（独立检查，不依赖subject和condition）
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_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_50_3",
"derived_derived_id": 3,
"derived_id": 1,
"id": "cu_50_3_1",
"law_article_id": 50,
"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_50_3
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约期限不得超过90个自然日","contextual_info": null}
必要的额外信息: 只检查'决议通过日'当日的情况
# 附加信息
## 你可以操作的dataframe的columns:
[
# 基本信息
'日期', '公司简称', '公司法律情况',
# 股票信息
'收盘价', '总股本', '日收益率', '前收盘价', '上市日期', '发行价格',
'净资产', '净利润', '每股净资产', '每股净利润',
# 财务信息
'公告类型', '公告日期', '收盘价减每股净资产', '收盘价减每股净利润',
# 回购行为
'存在回购方案', '决议通过日', '实施开始日', '实施截止日',
'回购方式', '回购用途', '回购数量上限', '回购数量下限', '资金总额上限', '资金总额下限', '要约期限', '要约价格',
'申报价格', '当日回购数量', '累计回购数量', '已使用资金',
# 以集中竞价方式出售已回购的股份
'出售计划披露日', '存在出售计划', '出售开始日', '出售截止日', '拟出售比例','拟出售数量', '当日出售价格', '当日出售比例', '当日出售数量', '累计出售数量', '累计出售比例', '计划内累计出售比例', '披露出售进展',
]
## 其中:
- 这是一个二维的面板数据, 根据['日期', '公司简称']可以定位到特定公司在特定日期的状态. 数据已经按照公司简称和日期排序.
- 所有公司均为在本交易所上市的上市公司
- 所有日期相关的列都已经是pd.datetime格式, ['日期']列本身就是交易日, 不需要额外计算交易日, 但如需自然日, 要另行计算.
- 所有价格的单位都是元而非万元, 千元或百万元; 所有的比例都是小数而非百分数
- '公司法律情况'columns存在空值或者"重大违法行为"字符串
- ['存在回购方案', '存在出售计划']为布尔值, 表示当日是否存在股份回购方案或以集中竞价方式出售已回购股份的计划
- 关于股份回购行为
'决议通过日'是董事会或者股东大会最终审议通过股份回购方案的日期), ['实施开始日', '实施截止日']是该方案披露的相关日期.
'回购方式'有['竞价回购', '要约回购']两种情况, '回购用途'有['维护公司价值及股东权益所必需', '股权激励或者员工持股计划', '转换上市公司发行的可转换为股票的公司债券']
note:
- 理论上你撰写合规检验代码所需要的数据都可以从一致的数据中得到, 对于没有直接对应的数据你需要自己计算得到, 不要简单地认为无法完成.
- 除非材料提供, 否则不要主动进行简化的假设. 如果你认为所给的信息不足以判断案例的合规性, 可以在函数的结尾进行注释说明. 但这种情况应该很少出现.
你被分配的题目是代码补全任务，有部分代码被 mask 掉的 Ground Truth 代码作为提示，请你仔细思考代码结构和ComplianceUnit的联系，补全 Ground Truth 代码。你仍然需要输出<CODE></CODE>包过的完整代码。
以下是被 mask 掉的 GT 代码:
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
- condition: 实施要约回购
- constraint: 要约期限不得超过90个自然日
'''
df = df.copy()
# 初始化标记列
df['cu_50_3_subject'] = True # 所有公司均为上市公司
df['cu_50_3_condition'] = False
df['cu_50_3_constraint'] = None
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_constraint'] = False
return df
```
|
```python
import pandas as pd
def check_cu_50_3(df):
'''
合规性检查函数，对应CU_50_3条款：
- subject: 上市公司
- condition: 实施要约回购
- constraint: 要约期限不得超过90个自然日
'''
df = df.copy()
# 初始化标记列
df['cu_50_3_subject'] = True # 所有公司均为上市公司
df['cu_50_3_condition'] = False
df['cu_50_3_constraint'] = None
# 标记条件：实施要约回购（存在有效回购方案且回购方式为要约回购）
valid_condition = (df['存在回购方案']) & (df['回购方式'] == '要约回购') & (df['日期'] == df['决议通过日'])
df.loc[valid_condition, 'cu_50_3_condition'] = True
# 标记约束：计算自然日差（需处理空值）
has_valid_dates = df['实施开始日'].notna() & df['实施截止日'].notna()
duration = (df['实施截止日'] - df['实施开始日']).dt.days
valid_constraint = (duration <= 90) & has_valid_dates
# 更新约束标记（独立检查，不依赖subject和condition）
df.loc[valid_constraint, 'cu_50_3_constraint'] = True
df.loc[~valid_constraint, 'cu_50_3_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_50_3",
"derived_derived_id": 4,
"derived_id": 1,
"id": "cu_50_3_1",
"law_article_id": 50,
"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_51_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约价格不得低于回购股份方案公告日前20个交易日该种股票每日加权平均价的算术平均值","contextual_info": null}
必要的额外信息: 方案公告日按照'决议通过日'计算, 只检查当日情况, 价格的计算也以该日为基准; 计算均价时采用收盘价代表该日价格, 不考虑日内价格变化. 不考虑取不到30个交易日的情况, 一定能取到.
你被分配的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
import pandas as pd
def check_meu_51_2(df):
'''
验证MEU_51_2合规性：
- subject: 上市公司（所有行自动满足）
- condition: 实施要约回购（回购方式为要约回购）
- constraint: 要约价格不低于方案公告日前20个交易日平均价
'''
df = df.copy()
# 初始化标记列
df['meu_51_2_subject'] = True # 所有公司均为上市公司
df['meu_51_2_condition'] = df['回购方式'] == '要约回购'
df['meu_51_2_constraint'] = None # 默认设为False
# 计算前20日交易均价逻辑（使用收盘价算术平均）
# 步骤1：提取有效决议记录
valid_resolutions = df[['公司简称', '决议通过日']].dropna().drop_duplicates()
# 步骤2：计算每个决议对应的20日收盘价算术平均
avg_price_list = []
for _, row in valid_resolutions.iterrows():
company = row['公司简称']
resolution_date = row['决议通过日']
# 获取决议日前20个交易日数据
company_data = df[(df['公司简称'] == company) & (df['日期'] < resolution_date)]
sorted_dates = company_data.sort_values('日期', ascending=False)
last_20 = sorted_dates.head(20)
if len(last_20) == 20:
# 计算收盘价算术平均值
avg_price = last_20['收盘价'].mean()
avg_price_list.append({
'公司简称': company,
'决议通过日': resolution_date,
'ref_price': avg_price
})
# 步骤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": 0,
"derived_id": 1,
"id": "cu_51_2_1",
"law_article_id": 51,
"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_51_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约价格不得低于回购股份方案公告日前20个交易日该种股票每日加权平均价的算术平均值","contextual_info": null}
必要的额外信息: 方案公告日按照'决议通过日'计算, 只检查当日情况, 价格的计算也以该日为基准; 计算均价时采用收盘价代表该日价格, 不考虑日内价格变化. 不考虑取不到30个交易日的情况, 一定能取到.
你被分配的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
import pandas as pd
def check_meu_51_2(df):
'''
验证MEU_51_2合规性：
- subject: 上市公司（所有行自动满足）
- condition: 实施要约回购（回购方式为要约回购）
- constraint: 要约价格不低于方案公告日前20个交易日平均价
'''
df = df.copy()
# 初始化标记列
df['meu_51_2_subject'] = True # 所有公司均为上市公司
df['meu_51_2_condition'] = df['回购方式'] == '要约回购'
df['meu_51_2_constraint'] = None # 默认设为False
# 计算前20日交易均价逻辑（使用收盘价算术平均）
# 步骤1：提取有效决议记录
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
company_data = df[(df['公司简称'] == company) & (df['日期'] < resolution_date)]
sorted_dates = company_data.sort_values('日期', ascending=False)
last_20 = sorted_dates.head(20)
if len(last_20) == 20:
# 计算收盘价算术平均值
avg_price = last_20['收盘价'].mean()
avg_price_list.append({
'公司简称': company,
'决议通过日': resolution_date,
'ref_price': avg_price
})
# 步骤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
```
|
```python
import pandas as pd
def check_meu_51_2(df):
'''
验证MEU_51_2合规性：
- subject: 上市公司（所有行自动满足）
- condition: 实施要约回购（回购方式为要约回购）
- constraint: 要约价格不低于方案公告日前20个交易日平均价
'''
df = df.copy()
# 初始化标记列
df['meu_51_2_subject'] = True # 所有公司均为上市公司
df['meu_51_2_condition'] = df['回购方式'] == '要约回购'
df['meu_51_2_constraint'] = None # 默认设为False
# 计算前20日交易均价逻辑（使用收盘价算术平均）
# 步骤1：提取有效决议记录
valid_resolutions = df[['公司简称', '决议通过日']].dropna().drop_duplicates()
# 步骤2：计算每个决议对应的20日收盘价算术平均
avg_price_list = []
for _, row in valid_resolutions.iterrows():
company = row['公司简称']
resolution_date = row['决议通过日']
# 获取决议日前20个交易日数据
company_data = df[(df['公司简称'] == company) & (df['日期'] < resolution_date)]
sorted_dates = company_data.sort_values('日期', ascending=False)
last_20 = sorted_dates.head(20)
if len(last_20) == 20:
# 计算收盘价算术平均值
avg_price = last_20['收盘价'].mean()
avg_price_list.append({
'公司简称': company,
'决议通过日': resolution_date,
'ref_price': avg_price
})
# 步骤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": 1,
"derived_id": 1,
"id": "cu_51_2_1",
"law_article_id": 51,
"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_51_2
法律的合规检查单元内容: {"subject": "上市公司","condition": "实施要约回购","constraint": "要约价格不得低于回购股份方案公告日前20个交易日该种股票每日加权平均价的算术平均值","contextual_info": null}
必要的额外信息: 方案公告日按照'决议通过日'计算, 只检查当日情况, 价格的计算也以该日为基准; 计算均价时采用收盘价代表该日价格, 不考虑日内价格变化. 不考虑取不到30个交易日的情况, 一定能取到.
你被分配的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
import pandas as pd
def check_meu_51_2(df):
'''
验证MEU_51_2合规性：
- subject: 上市公司（所有行自动满足）
- condition: 实施要约回购（回购方式为要约回购）
- constraint: 要约价格不低于方案公告日前20个交易日平均价
'''
df = df.copy()
# 初始化标记列
df['meu_51_2_subject'] = True # 所有公司均为上市公司
df['meu_51_2_condition'] = df['回购方式'] == '要约回购'
df['meu_51_2_constraint'] = None # 默认设为False
# 计算前20日交易均价逻辑（使用收盘价算术平均）
# 步骤1：提取有效决议记录
valid_resolutions = df[['公司简称', '决议通过日']].dropna().drop_duplicates()
# 步骤2：计算每个决议对应的20日收盘价算术平均
avg_price_list = []
for _, row in valid_resolutions.iterrows():
company = row['公司简称']
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
avg_price = last_20['收盘价'].mean()
avg_price_list.append({
'公司简称': company,
'决议通过日': resolution_date,
'ref_price': avg_price
})
# 步骤3：合并参考价格到主表
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
______MASKED______
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: 要约价格不低于方案公告日前20个交易日平均价
'''
df = df.copy()
# 初始化标记列
df['meu_51_2_subject'] = True # 所有公司均为上市公司
df['meu_51_2_condition'] = df['回购方式'] == '要约回购'
df['meu_51_2_constraint'] = None # 默认设为False
# 计算前20日交易均价逻辑（使用收盘价算术平均）
# 步骤1：提取有效决议记录
valid_resolutions = df[['公司简称', '决议通过日']].dropna().drop_duplicates()
# 步骤2：计算每个决议对应的20日收盘价算术平均
avg_price_list = []
for _, row in valid_resolutions.iterrows():
company = row['公司简称']
resolution_date = row['决议通过日']
# 获取决议日前20个交易日数据
company_data = df[(df['公司简称'] == company) & (df['日期'] < resolution_date)]
sorted_dates = company_data.sort_values('日期', ascending=False)
last_20 = sorted_dates.head(20)
if len(last_20) == 20:
# 计算收盘价算术平均值
avg_price = last_20['收盘价'].mean()
avg_price_list.append({
'公司简称': company,
'决议通过日': resolution_date,
'ref_price': avg_price
})
# 步骤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": 2,
"derived_id": 1,
"id": "cu_51_2_1",
"law_article_id": 51,
"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.