GVKun编程网logo

Itertools的问题-下一个函数(初级Python用户)(python中itertools的用法)

16

关于执行魅力服务时,将显示错误ERROR:JAVA_HOME设置为无效目录如何克服这个问题?的问题就给大家分享到这里,感谢你花时间阅读本站内容,更多关于alluxioError:Cannotfind'

关于执行魅力服务时,将显示错误ERROR:JAVA_HOME设置为无效目录如何克服这个问题?的问题就给大家分享到这里,感谢你花时间阅读本站内容,更多关于alluxio Error: Cannot find ''java'' on path or under $JAVA_HOME/bin/、android 上的 Flutter 运行问题 ERROR: JAVA_HOME 设置为无效目录、c# – 你如何克服这个问题? Jquery ajax服务器超时、cordova platform 添加 android get an error in JAVA_HOME等相关知识的信息别忘了在本站进行查找喔。

本文目录一览:

执行魅力服务时,将显示错误ERROR:JAVA_HOME设置为无效目录如何克服这个问题?

执行魅力服务时,将显示错误ERROR:JAVA_HOME设置为无效目录如何克服这个问题?

如何解决执行魅力服务时,将显示错误ERROR:JAVA_HOME设置为无效目录如何克服这个问题??

执行魅力服务时出现错误错误:将JAVA_HOME设置为无效目录,并且无法生成报告,无法理解魅力与JAVA_Home环境变量之间的关系

解决方法

暂无找到可以解决该程序问题的有效方法,小编努力寻找整理中!

如果你已经找到好的解决方法,欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@)

alluxio Error: Cannot find ''java'' on path or under $JAVA_HOME/bin/

alluxio Error: Cannot find ''java'' on path or under $JAVA_HOME/bin/

问题描述:

./bin/alluxio-start.sh all 或者./bin/alluxio format的时候不能启停或格式化其它节点儿,日志中报错如下:

[2020-07-30 15:48:18][host-42-59] nohup: ignoring input
[2020-07-30 15:48:18][host-42-59] which: no java in (/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/openssh-7.4p1/bin)^M
[2020-07-30 15:48:18][host-42-59] Error: Cannot find ''java'' on path or under $JAVA_HOME/bin/.^M
[2020-07-30 15:48:18][host-42-59] Connection to host-42-59 closed.^M

这个错误是说path (/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/openssh-7.4p1/bin) 中没有找到java,并且在$JAVA_HOME中也没有找到

但是:

# $JAVA_HOME 没问题
$ echo $JAVA_HOME
/usr/jdk64/jdk1.8.0_112/
# which 能找到
$ which java
/usr/jdk64/jdk1.8.0_112/bin/java
# profile中确实已配置
$ cat /etc/profile
export PATH=/usr/local/openssh-7.4p1/sbin:/usr/local/openssh-7.4p1/bin:$PATH
export JAVA_HOME=/usr/jdk64/jdk1.8.0_112
export JRE_HOME=/usr/jdk64/jdk1.8.0_112/jre
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib
export PATH=$JAVA_HOME/bin:$PATH

这个问题出的好奇怪,既然我配置了JAVA_HOME找不到,那只能想法把java添加到他找查的path中一试,OK

解决办法:

# 找到java安装目录
$ which java
/usr/jdk64/jdk1.8.0_112/bin/java
# 转链接到alluxio which 查找的路径中的一个
$ ln -s /usr/jdk64/jdk1.8.0_112/bin/java /usr/bin/java

android 上的 Flutter 运行问题 ERROR: JAVA_HOME 设置为无效目录

android 上的 Flutter 运行问题 ERROR: JAVA_HOME 设置为无效目录

如何解决android 上的 Flutter 运行问题 ERROR: JAVA_HOME 设置为无效目录?

这是我第一次使用 MAC 计算机,我正在尝试在 android 设备上运行它(iphone 工作正常)但是当我尝试在 android 模拟器上编译文件时收到一条错误消息

错误信息是:

Launching lib/main.dart on sdk gphone x86 in debug mode...
lib/main.dart:1
ERROR: JAVA_HOME is set to an invalid directory: /Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation.
Exception: Gradle task assembleDebug Failed with exit code 1
Exited (sigterm)

感谢所有帮助,谢谢。

解决方法

暂无找到可以解决该程序问题的有效方法,小编努力寻找整理中!

如果你已经找到好的解决方法,欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@)

c# – 你如何克服这个问题? Jquery ajax服务器超时

c# – 你如何克服这个问题? Jquery ajax服务器超时

我正在使用asp.net mvc,C#和 jquery.我的网站大量使用ajax.这导致了一个问题,我不知道如何解决它(比我目前的解决方案更好地解决它).

场景.

>用户登录我的网站 – cookie设置,服务器超时30分钟
>用户离开30分钟
>用户回来并点击我的一个启用了ajax的jquery选项卡
>请求发送到服务器
>服务器发送nope用户超时将其发送回登录页面.
>因为它是一个ajax请求,重定向会在选项卡中呈现.它看起来很丑陋(在标签中呈现整个页面),用户可能在这一点上非常困惑.

问题

>就服务器和ajax而言,ajax请求有效并且成功响应被发回.所以我无法检查错误,因为请求成功,而不是正确的数据回来.

解决方案1

>用户登录网站.
> Jquery ajax请求查找用户超时
>超时比服务器超时少60秒
>一旦javascript端超时被击中.出现Jquery对话框并告诉他们他们的会话已过期并强制他们重定向到登录包.

>用户无法单击任何内容,因为对话框会阻止该操作.如果某些用户使用firebug或者他们可以移除它,但服务器超时仍然会生效,他们将获得丑陋的版本(不要在意).

>如果用户发出ajax请求,则重置服务器端的超时以及客户端的超时.

问题

>用户可以走开,另一个人可能会来,超时消息可能会启动,但他们仍有可能有45秒的时间尝试发出新请求并重置超时.这非常低,并不太担心.
>有时我观察到它只是超时(客户端)而我不知道为什么.我永远无法重现问题(似乎发生在其他人身上,但在我测试时却没有).所以我猜测有些东西没有写入或其他出错的地方.

所以2号真的是我想找到另一个解决方案的重要原因.

解决方案2(推测).

我想也许如果我可以制作我自己的响应标题或者其他什么,如果服务器超时那么我可以发送一些303重定向或我可以检查的那种性质的东西然后根据它进行jquery重定向.

但是我不知道在我的C#代码中该怎么做,或者我可以做那样的事情.

解决方法

您可以随时在logon操作中添加自定义HTTP标头,该标头可以被AJAX调用拦截并相应地执行操作:

public ActionResult logon()
{
    response.addheader("X-logoN","logon");
    return View();
}

并且在成功回调检查是否存在此标头:

$.ajax({
    url: '/home/someaction',success: function (data,textStatus,XMLHttpRequest) {
        if (XMLHttpRequest.getResponseHeader('X-logoN') === 'logon') {
            // the logon page is being displayed 
            // probably timeout or unaithorized => act accordingly
        }
    }
});

cordova platform 添加 android get an error in JAVA_HOME

cordova platform 添加 android get an error in JAVA_HOME

我只是在Windows 8中安装cordova 3.3,当我使用命令“ cordova
platform add android”时,我收到此错误消息

Error: failed to run 'java -version',make sure your java environment is set up including jdk and jre
your JAVA_HOME variable is c:\program files(x86)\java\jdk1.7.0_25\bin
Error: Command failed: 'java' is not recognized as an internal or external command,operable program or batch file.

这是我的JAVA_HOME C:\ Program Files
(x86)\ Java \ jdk1.7.0_25 \ bin的系统变量,对于路径,我添加了一个C:\ Program Files
(x86)\ Java \ jdk1.7.0_25; C: \ Program Files(x86)\ Java \ jre7有人可以帮助我
解决此问题吗?

关于执行魅力服务时,将显示错误ERROR:JAVA_HOME设置为无效目录如何克服这个问题?的介绍现已完结,谢谢您的耐心阅读,如果想了解更多关于alluxio Error: Cannot find ''java'' on path or under $JAVA_HOME/bin/、android 上的 Flutter 运行问题 ERROR: JAVA_HOME 设置为无效目录、c# – 你如何克服这个问题? Jquery ajax服务器超时、cordova platform 添加 android get an error in JAVA_HOME的相关知识,请在本站寻找。

在这篇文章中,我们将为您详细介绍测试之间出现jest.spyOn和嵌套的fs.writeFile问题的内容,并且讨论关于testestring的相关问题。此外,我们还会涉及一些关于asp.net – Response.WriteFile和Response.Redirect、asp.net – 我何时可以在Response.WriteFile()中使用它后删除文件?、ASP.NET 使用Response.WriteFile方法下载文件、Dart-“ file.writeAsBytes(bytes,flush:true);”和“ file.writeAsBytes(bytes);”,两者之间有什么区别?哪个更安全?的知识,以帮助您更全面地了解这个主题。

本文目录一览:

测试之间出现jest.spyOn和嵌套的fs.writeFile问题(testestring)

测试之间出现jest.spyOn和嵌套的fs.writeFile问题(testestring)

如何解决测试之间出现jest.spyOn和嵌套的fs.writeFile问题?

我得到了旧项目。 我要测试一下。 这是express.js上的简单表单处理程序。 我使用了<X(N)>

jest.spyOn(fs,''writeFile'')

我也使用了超级测试。

在测试中,我使用beforeEach(() => { fs.writeFile.mockClear(); }); ,并且在一个测试中可以正常工作,但是如果在其他测试中使用它,则测试将失败。

代码包含嵌套expect(fs.writeFile.mock.calls.length).toBe(1)的调用,例如

fs

fs.writeFile(filename,fileContent,(error) => { if (error) throw error; fs.appendFile(logFilename,logContent,(error) => {if (error) throw error;}); }); 在后​​台使用fs.appendFile,但在第二项测试执行超级测试请求时运行。

我创建了两种解决方法: 首先

fs.writeFile

第二

// empty test with supertest request
test(''First test with fs.writeFile'',() => {/*...*/});
test(''Dummy test'',done => {
  //const request = require(''supertest'');
  //const app = require(''../myApp'');
  request(app)
    .post()
    .attach(''cv'',file)
    .then(response => {
      done();
    })
});
test(''Another test with fs.writeFile'',() => {/*...*/});

工作示例

  • https://github.com/speker2010/jest-express
  • https://github.com/speker2010/jest-express/tree/pass-tests

失败测试示例

  • https://github.com/speker2010/jest-express/tree/failing-tests

在这种情况下,如何看起来像是很好的测试?

解决方法

暂无找到可以解决该程序问题的有效方法,小编努力寻找整理中!

如果你已经找到好的解决方法,欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@)

asp.net – Response.WriteFile和Response.Redirect

asp.net – Response.WriteFile和Response.Redirect

我正在发布一个页面URL
例如mysite.com/disclaimer/someinfo
此页面显示协议,如果用户单击“同意”按钮,则PDF文件将作为附件进行流式处理.

这样做的目的是用户可以共享此URL,但链接后的任何其他人也必须在下载文件之前阅读协议.实际文件没有URL,但保存在服务器的其他位置,因此下载文件的唯一方法是单击“[Agree]”按钮.

然而 – 我发现很难的是,点击按钮并开始下载后,我希望页面“消失”.带按钮的页面保留在屏幕上.理想情况下,他们会被重定向回他们来自的页面.我渴望不需要javascript或cookies.引用者存储在初始页面加载到表单上的隐藏字段中.

我尝试了不同的方法,尝试在标题中写入307重定向,文件向用户发出警告,表明他们的帖子数据被重定向.我下面的代码仅适用于支持元刷新的浏览器(例如Firefox; IE7不支持Chrome / Safari)

我可以看到为什么这不起作用的逻辑.浏览器有一个响应,就是预期的文件.将文件发送给他们然后将浏览器重定向到另一个页面的正确方法是什么.感觉来自用户p.o.v.一旦他们点击按钮,这个“接受”页面就会消失.

我有:

protected void Page_Load(object sender,EventArgs e)
    {
        if (Request.UrlReferrer != null & Request.UrlReferrer.ToString() != "")
        {
            Uri referrer = Request.UrlReferrer;
            if (!IsPostBack)
            { hfReferrer.Value = Request.UrlReferrer.ToString(); }
        }
    }

    protected void buttonAccept_Click(object sender,EventArgs e)
    {
        //stream file
        Node nodeCurrent = Node.GetCurrent();
        string fileName = nodeCurrent.GetProperty("documentFile").Value.ToString();
        System.IO.FileInfo file = new System.IO.FileInfo(fileName); 
        if (file.Exists) //set appropriate headers  
        {
            Response.Clear();

            if (hfReferrer.Value !="")
            {response.addheader("Refresh",string.Format("3; URL={0}",hfReferrer.Value));}

            response.addheader("Content-disposition","attachment; filename=" + file.Name);
            response.addheader("Content-Length",file.Length.ToString());
            Response.ContentType = "application/pdf";

            // write file to browser
            Response.WriteFile(file.FullName);
            Response.End();
        }

我不想使用javascript / pop-ups等.
目前用户只需点击一个链接转到另一个页面,但这感觉不太对劲.

理想情况下,我想遵循一个很好的标准.但我不知道在哪里看.

解决方法

我建议尝试稍微不同的行为.在buttonAccept_Click事件处理程序上,将用户重定向到感谢页面.在这个感谢页面的Page_Load中有下载文件的代码. 这很容易实现,并为用户提供更好的体验.

asp.net – 我何时可以在Response.WriteFile()中使用它后删除文件?

asp.net – 我何时可以在Response.WriteFile()中使用它后删除文件?

WriteFile调用是否正确同步,我可以删除调用后立即写入的文件吗?

解决方法

它是完全同步的,你可以通过使用Lutz Reflector查看HttpResponse.WriteFile的实现来看到.您可以在调用Response.WriteFile后立即删除该文件.

您无法保证响应流已完全传输到客户端,但调用Response.Flush也不能为您提供保证.所以我认为在删除文件之前不需要调用Response.Flush.

避免将文件加载到MemoryStream中,它不会给您带来任何好处,并且会占用内存,特别是对于大型文件.

ASP.NET 使用Response.WriteFile方法下载文件

ASP.NET 使用Response.WriteFile方法下载文件

在IIS中,直接在浏览器中输入文件的路径可实现文件的下载,但是这个方法不方便控制用户的权限,所以小猪使用了下列方法来输出文件流。取代了直接下载文件。

这样就可以在下载文件之前验证用户的信息等等。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 string path = Server.MapPath("~/小猪测试.doc");//文件的路径      System.IO.FileInfo file = new System.IO.FileInfo(path);      Response.Clear();      Response.Charset = "utf-8";//设置输出的编码      Response.ContentEncoding = System.Text.Encoding.UTF8;      // 添加头信息,为"文件下载/另存为"对话框指定默认文件名        response.addheader("Content-disposition", "attachment; filename=" + Server.UrlEncode(file.Name));      // 添加头信息,指定文件大小,让浏览器能够显示下载进度        response.addheader("Content-Length", file.Length.ToString());      // 指定返回的是一个不能被客户端读取的流,必须被下载        Response.ContentType = "application/msword";      // 把文件流发送到客户端        Response.WriteFile(file.FullName);      Response.End();

重要说明:当您在 ASP.NET 应用程序的 Web.config 文件中将编译元素的 debug 属性值设置为 false 时,必须针对要下载的文件大小将 server.scripttimeout 属性设置为适当的值。默认情况下,server.scripttimeout 值被设置为 90 秒。但是,当 debug 属性被设置为 true 时,server.scripttimeout 值将被设置为一个非常大的值(30,000,000 秒)

Dart-“ file.writeAsBytes(bytes,flush:true);”和“ file.writeAsBytes(bytes);”,两者之间有什么区别?哪个更安全?

Dart-“ file.writeAsBytes(bytes,flush:true);”和“ file.writeAsBytes(bytes);”,两者之间有什么区别?哪个更安全?

如何解决Dart-“ file.writeAsBytes(bytes,flush:true);”和“ file.writeAsBytes(bytes);”,两者之间有什么区别?哪个更安全??

医生说:“如果将参数flush设置为true,则在返回的Future完成之前,写入的数据将被刷新到文件系统。”

您能详细解释一下吗?

如何安全地写入文件。

解决方法

暂无找到可以解决该程序问题的有效方法,小编努力寻找整理中!

如果你已经找到好的解决方法,欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@)

关于测试之间出现jest.spyOn和嵌套的fs.writeFile问题testestring的问题就给大家分享到这里,感谢你花时间阅读本站内容,更多关于asp.net – Response.WriteFile和Response.Redirect、asp.net – 我何时可以在Response.WriteFile()中使用它后删除文件?、ASP.NET 使用Response.WriteFile方法下载文件、Dart-“ file.writeAsBytes(bytes,flush:true);”和“ file.writeAsBytes(bytes);”,两者之间有什么区别?哪个更安全?等相关知识的信息别忘了在本站进行查找喔。

这篇文章主要围绕Itertools的问题-下一个函数初级Python用户展开,旨在为您提供一份详细的参考资料。我们将全面介绍Itertools的问题-下一个函数的优缺点,解答初级Python用户的相关问题,同时也会为您带来Itertools in python、itertools 中的 Python 排列、itertools“上一个”(与下一个相反)python、more_itertools 无法在 Python 3.6 中从 functools 导入cached_property的实用方法。

本文目录一览:

Itertools的问题-下一个函数(初级Python用户)(python中itertools的用法)

Itertools的问题-下一个函数(初级Python用户)(python中itertools的用法)

使用索引df_curr = df_curr[sorted(df_curr)] 来跟踪当前歌曲,在循环之前使用current_song_index对其进行初始化,并在每条“ next”命令中将其前进。

0

Itertools in python

Itertools in python

Itertools in python

  • 定义
  1. Itertools:Functions creating iterators for efficient looping(是一系列函数,用来创建迭代器,是为了更有效的循环。
  2. 迭代器:可以看成是一个for循环的封装。有无限循环和有限循环
    举个例子:
// 无限循环迭代器cycle
cycle('ABCD') --> A B C D A B C D ...
  1. 对于Itertool functions,它是用来创建和返回一个迭代器。
# itertools.chain(*iterables) 创建一个迭代器
def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element
# classmethod chain.from_iterable(iterable) 类似chain()
def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
       	# yield 相当于return, 只是它返回的是一种iterator
            yield element
  • 通俗来说,这两个迭代器可以把它看作是把这些列表打碎了给它的元素提取出来。也可以看作是flatten扁平化的一个过程。
    举例:
# output: [{'a': 0}, {'b': 1}, {'c': 2}, {'d': 3}]
ite = itertools.chain.from_iterable(
	[
		[{'a':0}, {'b':1}], 
		[{'c':2}], 
		[{'d':3}]
	]
)
print(list(ite)) 

  • 总结
    所以当结构嵌套多层的时候,可以用这个迭代器的方法高效遍历。

  • 可以继续学习的点:
    迭代器结合map,用法更高效。

参考文献

https://docs.python.org/zh-cn/3/library/itertools.html#itertools.chain

itertools 中的 Python 排列

itertools 中的 Python 排列

如何解决itertools 中的 Python 排列?

任务

给你一个字符串。 您的任务是按字典排序顺序打印字符串大小 k 的所有可能排列。

输入格式:

一行包含空格分隔的字符串 S 和整数值 k。

约束:

0<k<=len(S)。该字符串仅包含大写字符。

输出格式

在单独的行上打印字符串 S 的排列。

样本输入: HACK 2 样本输出

AC
AH
AK
CA
CH
CK
HA
HC
HK
KA
KC
KH

我的代码:

from itertools import permutations
k,s=input().split()
for i in sorted(list(permutations(s.upper(),int(k)))):
    print("".join(i))

我收到此错误:

Traceback (most recent call last):
  File "/tmp/submission/20210723/08/54/hackerrank-3eed224fdadc2fbdec48f75b70fd9419/code/Solution.py",line 4,in <module>
    for i in sorted(list(permutations(s.upper(),int(k)))):
ValueError: invalid literal for int() with base 10: ''HACK''

怎么办?

解决方法

暂无找到可以解决该程序问题的有效方法,小编努力寻找整理中!

如果你已经找到好的解决方法,欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@)

itertools“上一个”(与下一个相反)python

itertools“上一个”(与下一个相反)python

我目前正在使用类似

>> import itertools>> ABC = [a, b, c]>> abc = itertools.cycle( ABC )>> next( abc )a>> next( abc )b    >> next( abc )c

我希望下一个电话是

>> previous( abc )b

itertools中是否有一种方法可以做到这一点?

答案1

小编典典

不,没有。

由于Python的迭代协议的工作方式,如果previous不保留所生成值的完整历史记录就无法实现。Python不会这样做,并且鉴于内存需求,您可能不希望这样做。

more_itertools 无法在 Python 3.6 中从 functools 导入cached_property

more_itertools 无法在 Python 3.6 中从 functools 导入cached_property

more_itertools 无法在 python 3.6 中从 functools 导入cached_property

问题内容

我尝试使用以下命令从 visual studio 代码中的终端运行grade_analysis.py:

~/documents/school/ml4t_2023fall/assess_portfolio$ pythonpath=../:. python grade_analysis.py 根据班级设置说明

但是,当我运行命令时,grade_analysis.py 似乎无法提升级别并从 grading.grading.py 文件中获取信息。

我使用这个命令是错误的还是遗漏了什么?

这是我收到的错误:

立即学习“Python免费学习笔记(深入)”;

2023fall/assess_portfolio$ pythonpath=../:. python grade_analysis.py
traceback (most recent call last):
  file "grade_analysis.py", line 20, in <module>
    import pytest                                                                                                                                                         
  file "/home/clopez/miniconda3/envs/ml4t/lib/python3.6/site-packages/pytest.py", line 34, in <module>
    from _pytest.python_api import approx
  file "/home/clopez/miniconda3/envs/ml4t/lib/python3.6/site-packages/_pytest/python_api.py", line 13, in <module>
    from more_itertools.more import always_iterable
  file "/home/clopez/miniconda3/envs/ml4t/lib/python3.6/site-packages/more_itertools/__init__.py", line 3, in <module>
    from .more import *  # noqa
  file "/home/clopez/miniconda3/envs/ml4t/lib/python3.6/site-packages/more_itertools/more.py", line 5, in <module>
    from functools import cached_property, partial, reduce, wraps
importerror: cannot import name ''cached_property''
登录后复制

环境设置说明

conda 环境 yml

name: ml4t
channels:
- conda-forge
- defaults
dependencies:
- python=3.6
- cycler=0.10.0
- kiwisolver=1.1.0
- matplotlib=3.0.3
- numpy=1.16.3
- pandas=0.24.2
- pyparsing=2.4.0
- python-dateutil=2.8.0
- pytz=2019.1
- scipy=1.2.1
- seaborn=0.9.0
- six=1.12.0
- joblib=0.13.2
- pytest=5.0
- pytest-json=0.4.0
- future=0.17.1
- pprofile=2.0.2
- pip
- pip:
  - jsons==0.8.8
  - gradescope-utils
  - subprocess32
登录后复制

等级分析.py

"""MC1-P1: Analyze a portfolio - grading script.                                                                                              
                                                                                              
Usage:                                                                                                
- Switch to a student feedback directory first (will write "points.txt" and "comments.txt" in pwd).                                                                                               
- Run this script with both ml4t/ and student solution in PYTHONPATH, e.g.:                                                                                               
    PYTHONPATH=ml4t:MC1-P1/jdoe7 python ml4t/mc1_p1_grading/grade_analysis.py                                                                                             
                                                                                              
Copyright 2017, Georgia Tech Research Corporation                                                                                             
Atlanta, Georgia 30332-0415                                                                                               
All Rights Reserved                                                                                               
"""                                                                                               
                                                                                              
import datetime                                                                                               
import os                                                                                             
import sys                                                                                                
import traceback as tb                                                                                                
from collections import OrderedDict, namedtuple                                                                                               
                                                                                              
import pandas as pd                                                                                               
import pytest                                                                                             
from grading.grading import (                                                                                             
    GradeResult,                                                                                              
    IncorrectOutput,                                                                                              
    grader,                                                                                               
    run_with_timeout,                                                                                             
)                                                                                             
from util import get_data                                                                                             
                                                                                              
# Student code                                                                                                
# Spring ''16 renamed package to just "analysis" (BPH)                                                                                             
main_code = "analysis"  # module name to import                                                                                               
                                                                                              
# Test cases                                                                                              
# Spring ''16 test cases only check sharp ratio, avg daily ret, and cum_ret (BPH)                                                                                              
PortfolioTestCase = namedtuple(                                                                                               
    "PortfolioTestCase", ["inputs", "outputs", "description"]                                                                                             
)                                                                                             
portfolio_test_cases = [                                                                                              
    PortfolioTestCase(                                                                                                
        inputs=dict(                                                                                              
            start_date="2010-01-01",                                                                                              
            end_date="2010-12-31",                                                                                                
            symbol_allocs=OrderedDict(                                                                                                
                [("GOOG", 0.2), ("AAPL", 0.3), ("GLD", 0.4), ("XOM", 0.1)]                                                                                                
            ),                                                                                                
            start_val=1000000,                                                                                                
        ),                                                                                                
        outputs=dict(                                                                                             
            cum_ret=0.255646784534,                                                                                               
            avg_daily_ret=0.000957366234238,                                                                                              
            sharpe_ratio=1.51819243641,                                                                                               
        ),                                                                                                
        description="Wiki example 1",                                                                                             
    ),                                                                                                
    PortfolioTestCase(                                                                                                
        inputs=dict(                                                                                              
            start_date="2010-01-01",                                                                                              
            end_date="2010-12-31",                                                                                                
            symbol_allocs=OrderedDict(                                                                                                
                [("AXP", 0.0), ("HPQ", 0.0), ("IBM", 0.0), ("HNZ", 1.0)]                                                                                              
            ),                                                                                                
            start_val=1000000,                                                                                                
        ),                                                                                                
        outputs=dict(                                                                                             
            cum_ret=0.198105963655,                                                                                               
            avg_daily_ret=0.000763106152672,                                                                                              
            sharpe_ratio=1.30798398744,                                                                                               
        ),                                                                                                
        description="Wiki example 2",                                                                                             
    ),                                                                                                
    PortfolioTestCase(                                                                                                
        inputs=dict(                                                                                              
            start_date="2010-06-01",                                                                                              
            end_date="2010-12-31",                                                                                                
            symbol_allocs=OrderedDict(                                                                                                
                [("GOOG", 0.2), ("AAPL", 0.3), ("GLD", 0.4), ("XOM", 0.1)]                                                                                                
            ),                                                                                                
            start_val=1000000,                                                                                                
        ),                                                                                                
        outputs=dict(                                                                                             
            cum_ret=0.205113938792,                                                                                               
            avg_daily_ret=0.00129586924366,                                                                                               
            sharpe_ratio=2.21259766672,                                                                                               
        ),                                                                                                
        description="Wiki example 3: Six month range",                                                                                                
    ),                                                                                                
    PortfolioTestCase(                                                                                                
        inputs=dict(                                                                                              
            start_date="2010-01-01",                                                                                              
            end_date="2013-05-31",                                                                                                
            symbol_allocs=OrderedDict(                                                                                                
                [("AXP", 0.3), ("HPQ", 0.5), ("IBM", 0.1), ("GOOG", 0.1)]                                                                                             
            ),                                                                                                
            start_val=1000000,                                                                                                
        ),                                                                                                
        outputs=dict(                                                                                             
            cum_ret=-0.110888530433,                                                                                              
            avg_daily_ret=-6.50814806831e-05,                                                                                             
            sharpe_ratio=-0.0704694718385,                                                                                                
        ),                                                                                                
        description="Normalization check",                                                                                                
    ),                                                                                                
    PortfolioTestCase(                                                                                                
        inputs=dict(                                                                                              
            start_date="2010-01-01",                                                                                              
            end_date="2010-01-31",                                                                                                
            symbol_allocs=OrderedDict(                                                                                                
                [("AXP", 0.9), ("HPQ", 0.0), ("IBM", 0.1), ("GOOG", 0.0)]                                                                                             
            ),                                                                                                
            start_val=1000000,                                                                                                
        ),                                                                                                
        outputs=dict(                                                                                             
            cum_ret=-0.0758725033871,                                                                                             
            avg_daily_ret=-0.00411578300489,                                                                                              
            sharpe_ratio=-2.84503813366,                                                                                              
        ),                                                                                                
        description="One month range",                                                                                                
    ),                                                                                                
    PortfolioTestCase(                                                                                                
        inputs=dict(                                                                                              
            start_date="2011-01-01",                                                                                              
            end_date="2011-12-31",                                                                                                
            symbol_allocs=OrderedDict(                                                                                                
                [("WFR", 0.25), ("ANR", 0.25), ("MWW", 0.25), ("FSLR", 0.25)]                                                                                             
            ),                                                                                                
            start_val=1000000,                                                                                                
        ),                                                                                                
        outputs=dict(                                                                                             
            cum_ret=-0.686004563165,                                                                                              
            avg_daily_ret=-0.00405018240566,                                                                                              
            sharpe_ratio=-1.93664660013,                                                                                              
        ),                                                                                                
        description="Low Sharpe ratio",                                                                                               
    ),                                                                                                
    PortfolioTestCase(                                                                                                
        inputs=dict(                                                                                              
            start_date="2010-01-01",                                                                                              
            end_date="2010-12-31",                                                                                                
            symbol_allocs=OrderedDict(                                                                                                
                [("AXP", 0.0), ("HPQ", 1.0), ("IBM", 0.0), ("HNZ", 0.0)]                                                                                              
            ),                                                                                                
            start_val=1000000,                                                                                                
        ),                                                                                                
        outputs=dict(                                                                                             
            cum_ret=-0.191620333598,                                                                                              
            avg_daily_ret=-0.000718040989619,                                                                                             
            sharpe_ratio=-0.71237182415,                                                                                              
        ),                                                                                                
        description="All your eggs in one basket",                                                                                                
    ),                                                                                                
    PortfolioTestCase(                                                                                                
        inputs=dict(                                                                                              
            start_date="2006-01-03",                                                                                              
            end_date="2008-01-02",                                                                                                
            symbol_allocs=OrderedDict(                                                                                                
                [("MMM", 0.0), ("MO", 0.9), ("MSFT", 0.1), ("INTC", 0.0)]                                                                                             
            ),                                                                                                
            start_val=1000000,                                                                                                
        ),                                                                                                
        outputs=dict(                                                                                             
            cum_ret=0.43732715979,                                                                                                
            avg_daily_ret=0.00076948918955,                                                                                               
            sharpe_ratio=1.26449481371,                                                                                               
        ),                                                                                                
        description="Two year range",                                                                                             
    ),                                                                                                
]                                                                                             
abs_margins = dict(                                                                                               
    cum_ret=0.001, avg_daily_ret=0.00001, sharpe_ratio=0.001                                                                                              
)  # absolute margin of error for each output                                                                                             
points_per_output = dict(                                                                                             
    cum_ret=2.5, avg_daily_ret=2.5, sharpe_ratio=5.0                                                                                              
)  # points for each output, for partial credit                                                                                               
points_per_test_case = sum(points_per_output.values())                                                                                                
max_seconds_per_call = 5                                                                                              
                                                                                              
# Grading parameters (picked up by module-level grading fixtures)                                                                                             
max_points = float(len(portfolio_test_cases) * points_per_test_case)                                                                                              
html_pre_block = (                                                                                                
    True  # surround comments with HTML <pre> tag (for T-Square comments field)                                                                                               
)                                                                                             
                                                                                              
# Test functon(s)                                                                                             
@pytest.mark.parametrize("inputs,outputs,description", portfolio_test_cases)                                                                                              
def test_analysis(inputs, outputs, description, grader):                                                                                              
    """Test get_portfolio_value() and get_portfolio_stats() return correct values.                                                                                                
                                                                                              
    Requires test inputs, expected outputs, description, and a grader fixture.                                                                                                
    """                                                                                               
                                                                                              
    points_earned = 0.0  # initialize points for this test case                                                                                               
    try:                                                                                              
        # Try to import student code (only once)                                                                                              
        if not main_code in globals():                                                                                                
            import importlib                                                                                              
                                                                                              
            # * Import module                                                                                             
            mod = importlib.import_module(main_code)                                                                                              
            globals()[main_code] = mod                                                                                                
                                                                                              
        # Unpack test case                                                                                                
        start_date_str = inputs["start_date"].split("-")                                                                                              
        start_date = datetime.datetime(                                                                                               
            int(start_date_str[0]),                                                                                               
            int(start_date_str[1]),                                                                                               
            int(start_date_str[2]),                                                                                               
        )                                                                                             
        end_date_str = inputs["end_date"].split("-")                                                                                              
        end_date = datetime.datetime(                                                                                             
            int(end_date_str[0]), int(end_date_str[1]), int(end_date_str[2])                                                                                              
        )                                                                                             
        symbols = list(                                                                                               
            inputs["symbol_allocs"].keys()                                                                                                
        )  # e.g.: [''GOOG'', ''AAPL'', ''GLD'', ''XOM'']                                                                                             
        allocs = list(                                                                                                
            inputs["symbol_allocs"].values()                                                                                              
        )  # e.g.: [0.2, 0.3, 0.4, 0.1]                                                                                               
        start_val = inputs["start_val"]                                                                                               
        risk_free_rate = inputs.get("risk_free_rate", 0.0)                                                                                                
                                                                                              
        # the wonky unpacking here is so that we only pull out the values we say we''ll test.                                                                                              
        def timeoutwrapper_analysis():                                                                                                
            student_rv = analysis.assess_portfolio(                                                                                               
                sd=start_date,                                                                                                
                ed=end_date,                                                                                              
                syms=symbols,                                                                                             
                allocs=allocs,                                                                                                
                sv=start_val,                                                                                             
                rfr=risk_free_rate,                                                                                               
                sf=252.0,                                                                                             
                gen_plot=False,                                                                                               
            )                                                                                             
            return student_rv                                                                                             
                                                                                              
        result = run_with_timeout(                                                                                                
            timeoutwrapper_analysis, max_seconds_per_call, (), {}                                                                                             
        )                                                                                             
        student_cr = result[0]                                                                                                
        student_adr = result[1]                                                                                               
        student_sr = result[3]                                                                                                
        port_stats = OrderedDict(                                                                                             
            [                                                                                             
                ("cum_ret", student_cr),                                                                                              
                ("avg_daily_ret", student_adr),                                                                                               
                ("sharpe_ratio", student_sr),                                                                                             
            ]                                                                                             
        )                                                                                             
        # Verify against expected outputs and assign points                                                                                               
        incorrect = False                                                                                             
        msgs = []                                                                                             
        for key, value in port_stats.items():                                                                                             
            if abs(value - outputs[key]) > abs_margins[key]:                                                                                              
                incorrect = True                                                                                              
                msgs.append(                                                                                              
                    "    {}: {} (expected: {})".format(                                                                                               
                        key, value, outputs[key]                                                                                              
                    )                                                                                             
                )                                                                                             
            else:                                                                                             
                points_earned += points_per_output[key]  # partial credit                                                                                             
                                                                                              
        if incorrect:                                                                                             
            inputs_str = (                                                                                                
                "    start_date: {}\n"                                                                                                
                "    end_date: {}\n"                                                                                              
                "    symbols: {}\n"                                                                                               
                "    allocs: {}\n"                                                                                                
                "    start_val: {}".format(                                                                                               
                    start_date, end_date, symbols, allocs, start_val                                                                                              
                )                                                                                             
            )                                                                                             
            raise IncorrectOutput(                                                                                                
                "One or more stats were incorrect.\n  Inputs:\n{}\n  Wrong"                                                                                               
                " values:\n{}".format(inputs_str, "\n".join(msgs))                                                                                                
            )                                                                                             
    except Exception as e:                                                                                                
        # Test result: failed                                                                                             
        msg = "Test case description: {}\n".format(description)                                                                                               
                                                                                              
        # Generate a filtered stacktrace, only showing erroneous lines in student file(s)                                                                                             
        tb_list = tb.extract_tb(sys.exc_info()[2])                                                                                                
        for i in range(len(tb_list)):                                                                                             
            row = tb_list[i]                                                                                              
            tb_list[i] = (                                                                                                
                os.path.basename(row[0]),                                                                                             
                row[1],                                                                                               
                row[2],                                                                                               
                row[3],                                                                                               
            )  # show only filename instead of long absolute path                                                                                             
        tb_list = [row for row in tb_list if row[0] == "analysis.py"]                                                                                             
        if tb_list:                                                                                               
            msg += "Traceback:\n"                                                                                             
            msg += "".join(tb.format_list(tb_list))  # contains newlines                                                                                              
        msg += "{}: {}".format(e.__class__.__name__, str(e))                                                                                              
                                                                                              
        # Report failure result to grader, with stacktrace                                                                                                
        grader.add_result(                                                                                                
            GradeResult(outcome="failed", points=points_earned, msg=msg)                                                                                              
        )                                                                                             
        raise                                                                                             
    else:                                                                                             
        # Test result: passed (no exceptions)                                                                                             
        grader.add_result(                                                                                                
            GradeResult(outcome="passed", points=points_earned, msg=None)                                                                                             
        )                                                                                             
                                                                                              
                                                                                              
if __name__ == "__main__":                                                                                                
    pytest.main(["-s", __file__])
登录后复制

我已激活 conda 环境并设置文件,以便它应该能够访问 util.py 文件和 grading.py 文件。

我希望运行命令后,analysis.py 文件将使用grade_analysis.py 进行评分。


正确答案


这就是为什么使用 conda-lock 锁文件(或容器化)比使用 yaml 更能实现长期可重复性。附加依赖项(如 more-itertools)在 yaml 中不受限制,并且其他包的依赖项可能没有适当的上限。在这种情况下,op 最终得到了 more_itertools 模块的一个版本,该模块引用了后来才添加到 functools 的内容。

二分法显示了从 more_itertools v10 开始的有问题的引用(对 cached_property),因此设置上限应该可以解决问题:

name: ml4t
channels:
  - conda-forge
  - defaults
dependencies:
  - python=3.6
  - cycler=0.10.0
  - kiwisolver=1.1.0
  - matplotlib=3.0.3
  - more-itertools<10  # <- prevent v10+
  - numpy=1.16.3
  - pandas=0.24.2
  - pyparsing=2.4.0
  - python-dateutil=2.8.0
  - pytz=2019.1
  - scipy=1.2.1
  - seaborn=0.9.0
  - six=1.12.0
  - joblib=0.13.2
  - pytest=5.0
  - pytest-json=0.4.0
  - future=0.17.1
  - pprofile=2.0.2
  - pip
  - pip:
    - jsons==0.8.8
    - gradescope-utils
    - subprocess32

登录后复制

使用此 yaml,并测试导致错误的导入现在可以正常工作:

$ python -c "from more_itertools.more import always_iterable"
$ echo $?
0
登录后复制

以上就是more_itertools 无法在 Python 3.6 中从 functools 导入cached_property的详细内容,更多请关注php中文网其它相关文章!

关于Itertools的问题-下一个函数初级Python用户的问题我们已经讲解完毕,感谢您的阅读,如果还想了解更多关于Itertools in python、itertools 中的 Python 排列、itertools“上一个”(与下一个相反)python、more_itertools 无法在 Python 3.6 中从 functools 导入cached_property等相关内容,可以在本站寻找。

本文标签: