小编nmu*_*thy的帖子

我看到越来越多的软件组织在面向服务的体系结构中使用gRPC,但人们仍然在使用REST.在什么用例中使用gRPC是有意义的,何时使用REST进行服务间通信是有意义的？

有趣的是,我遇到过使用REST和gRPC的开源项目.例如,Kubernetes和Docker Swarm都在某种程度上使用gRPC进行集群协调,但也公开REST API以与主/领导节点连接.为什么不上下使用gRPC？

我正在使用ScalaTest与Akka TestKit为我编写的演员编写单元和集成测试,以简单地向另一个演员发送消息,而不会改变任何内部状态.以此为例:

class MyActor extends Actor {
  val anotherActor = context.actorOf(Props[AnotherActor])
  def receive: Receive = {
    case MyMessage => anotherActor ! AnotherMessage
  }
}

我想写一个测试,确认由于anotherActor处理AnotherMessage而MyActor处理MyMessage.经典的例子是用来TestActorRef获取底层actor并检查一些应该在收到消息时受到影响的内部状态,如下所示:

val testActorRef = TestActorRef(new MyActor)
"MyActor" should "change some internal state when it receives MyMessage" in {
  testActorRef ! MyMessage
  testActorRef.underlyingActor.someState shouldBe "altered"
}

但就我而言,我并不关心这种状态.事实上,我想避免持有任何这样的状态.TestProbe因为你仍然需要TestProbe.ref和被测试的演员一起注册,所以我不是那么寻找.在大多数情况下,我查看了有关测试的Akka文档中的所有示例(http://doc.akka.io/docs/akka/snapshot/scala/testing.html),但没有找到任何合适的内容.

在我最近与一家信誉良好的软件公司进行的一次采访中,我被绊倒,试图为一个看似微不足道的Scala问题提供有效的解释.考虑以下:

case class Person(var age: Int)
def person = new Person(10)
person.age = 3
println(person)

这是println声明返回的内容:

Person(10)

问题是为什么这个以及我分配时发生3了person.age什么？

我正在尝试使用预先打包的EC2脚本启动一个独立的Spark集群,但它只是无限期地挂起'ssh-ready'状态:

ubuntu@machine:~/spark-1.2.0-bin-hadoop2.4$ ./ec2/spark-ec2 -k <key-pair> -i <identity-file>.pem -r us-west-2 -s 3 launch test
Setting up security groups...
Searching for existing cluster test...
Spark AMI: ami-ae6e0d9e
Launching instances...
Launched 3 slaves in us-west-2c, regid = r-b_______6
Launched master in us-west-2c, regid = r-0______0
Waiting for all instances in cluster to enter 'ssh-ready' state..........

然而,我可以在没有投诉的情

ubuntu@machine:~$ ssh -i <identity-file>.pem root@master-ip
Last login: Day MMM DD HH:mm:ss 20YY from c-AA-BBB-CCCC-DDD.eee1.ff.provider.net

       __|  __|_  )
       _|  (     /   Amazon Linux AMI
      ___|\___|___|

https://aws.amazon.com/amazon-linux-ami/2013.03-release-notes/
There are …

Unicode运算符\u21D2" ?"(有时被写为=>)是在函数组合器,函数定义,大小写匹配语句等中使用的Scala编程语言中普遍存在的常见词汇标识符.我通常必须将此运算符复制并粘贴到我的代码中来自其他地方,但这可能会非常烦人.

有没有人知道在您选择的IDE中生成此符号的快捷方式？我通常使用JetBrains IntelliJ,SublimeText和VIM等程序.

我必须为某些Python应用程序编写RPC服务。我有一个IDL文件solver.proto，并使用该grpcio-tools模块从中生成了一些代码。这是结果项目结构：

solver-service
  ??? main.py
  ??? protos/
       ??? __init__.py       
       ??? __pycache__
       ?     ??? ... 
       ??? generate_pb.py
       ??? solver.proto
       ??? solver_pb2.py
       ??? solver_pb2_grpc.py

我将PYTHONPATH设置为/abs/path/to/solver-service，我尝试从该目录导入自动生成的gRPC类，但是单击以下命令：

solver-service$ python3
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import protos.solver_pb2
>>> import protos.solver_pb2_grpc
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/abs/path/to/solver-service/protos/solver_pb2_grpc.py", line 4, in <module>
    import …

SBERT ( https://www.sbert.net/ )sentence-transformer库 ( https://pypi.org/project/sentence-transformers/ ) 是 Python 开源 LLM 生态系统中用于生成文本块向量嵌入的最流行的库。它有一个简单的 API，但却是一个非常大的依赖项。它所有的膨胀从何而来？

下面是使用此工具构建基础 Docker 容器映像的屏幕截图，该工具接管11 mins构建，最终映像大小为7.5 GB：

作为参考，这是我的Dockerfile.base：

FROM python:3.11.2-slim-bullseye
RUN pip install --upgrade pip && pip install sentence-transformers

我预计这是因为它安装了一些已经预先打包的模型，但是当我尝试他们流行的入门片段时

FROM python:3.11.2-slim-bullseye
RUN pip install --upgrade pip && pip install sentence-transformers

它又向我的文件系统下载了数百 MB 的文件。所以我想找到一种方法将其精简为我需要的包。我相信这个库的大小很大程度上取决于底层torch依赖项（6.9 GB），而底层依赖项又由于其底层nvidia-*依赖项而占用了大量磁盘空间（顺便说一句，这些依赖项安装在哪里？）

假设我已经将一个模型下载到我的文件系统（即path/to/all-MiniLM-L6-v2来自 HuggingFace 的存储库），而我想要做的就是在 CPU 上运行上面的代码。如何才能只安装我需要的东西而不造成臃肿？

现在假设我选择了一个 GPU 来运行它。为了让这段代码在不膨胀的情况下运行，我需要的下一组边际依赖项是什么？

我有一些代码（项目源可在这里-https : //github.com/natemurthy/testing-final-vals）：

object Main extends App {
  final val NAME = "foo"
}

我正在使用ScalaTest和SBT Coverage插件来测试此代码，如下所示：

import org.scalatest.{FlatSpec,Matchers}

class MainTest extends FlatSpec with Matchers {
  it should "have a name" in {
    Main.NAME shouldBe "foo"
  }
}

但是由于某些原因，当我lazy在此表达式中包含修饰符时，我只会得到覆盖点：

为什么会这样呢？

我有一个映射器函数定义如下:

def foo(x:Int) = if (x>2) x*2

这种方法的类型签名是Int => AnyVal.现在,如果我将此函数映射到整数列表:

scala> List(-1,3,-4,0,5).map(foo)
res0: List[AnyVal] = List((), 6, (), (), 10)

我需要一种Unit从Ints 中过滤掉s 的方法:

scala> res0.filter(_.isInstanceOf[Int]).map(_.asInstanceOf[Int])
res1: List[Int] = List(6, 10)

一切似乎都精确表达,直到我必须做的过滤器,地图上res0提取我关心的值.我可以使用matchers或if-else in foo来确保我返回一个Int但是我仍然需要过滤由map操作产生的不需要的值.

任何经过良好调查的Scala开发人员都能阅读这篇文章,可以更深入地了解这种方法的好坏,特别是当我的馆藏变得越来越大时(例如,这个集合可能是分布式Spark RDD)吗？在功能上有更多惯用的方法吗？

我写了很多依赖于精确的周期性方法调用的代码.我一直在使用Python的futures库将调用提交到运行时的线程池,并在循环中的调用之间休眠:

executor = ThreadPoolExecutor(max_workers=cpu_count())

def remote_call():
    # make a synchronous bunch of HTTP requests

def loop():
    while True:
        # do work here
        executor.submit(remote_call)
        time.sleep(60*5)

但是,我注意到这个实现在长时间运行后引入了一些漂移(例如,我运行此代码大约10个小时,并注意到大约7秒的漂移).对于我的工作,我需要在确切的秒上运行,毫秒甚至更好.有些人指出我asyncio("火与忘记"python async/await),但我无法在Python 2.7中使用它.

我不是在寻找黑客.我真正想要的是类似于Go time.Tick或Netty的东西HashedWheelTimer.

以下是我昨天与我的研究小组分享的一些代码:https://gist.github.com/natemurthy/019e49e6f5f0d1be8719.编译之后,我使用以下堆参数运行map.scala:

$ scala -J"-Xmx4G" map

并获得4个独立测试的以下结果:

// (1L to 20000000L).map(_*2)
(Map) multiplying 20 million elements by 2
(Reduce) sum: 400000020000000
Total MapReduce time: 7.562381

// (1L to 20000000L).toArray.map(_*2)
(Map) multiplying 20 million elements by 2
(Reduce) sum: 400000020000000
Total MapReduce time: 1.233997

// (1L to 20000000L).toVector.map(_*2)
(Map) multiplying 20 million elements by 2
(Reduce) sum: 400000020000000
Total MapReduce time: 15.041896 

// (1L to 20000000L).par.map(_*2)
(Map) multiplying 20 million elements by 2
(Reduce) sum: 400000020000000
Total MapReduce …