I am please to announce the availability of the first beta release of the
"plum-py" package.
This package provides classes and utility functions to efficiently pack and
unpack bytes similar to what the standard library `struct` module offers.
This package expands significantly on that capability with much more
powerful and convenient access and control of bytes within a buffer
(including handling variable size/type relationships within the buffer
data).
The package provides a large number of fundamental types (e.g.
numbers, structures, arrays, etc.) for specifying buffer data structure.
Each type conforms to a "plug-and-play" architecture facilitating the
ability to be combined in any way, including deeply nested structures of
arbitrary
type. You may also write your own custom types that conform to
the "plug-and-play" architecture API and use them in combination with any
of the fundamental types provided.
Docs: https://plum-py.readthedocs.io/en/latest/index.html
PyPi: https://pypi.org/project/plum-py/
Repo: https://gitlab.com/dangass/plum
License: MIT
With Regards,
Dan Gass
(dan.gass at gmail)
I am pleased to announce release 2020.1 of SfePy.
Description
-----------
SfePy (simple finite elements in Python) is a software for solving systems of
coupled partial differential equations by the finite element method or by the
isogeometric analysis (limited support). It is distributed under the new BSD
license.
Home page: http://sfepy.org
Mailing list: https://mail.python.org/mm3/mailman3/lists/sfepy.python.org/
Git (source) repository, issue tracker: https://github.com/sfepy/sfepy
Highlights of this release
--------------------------
- reading/writing of additional mesh formats by using meshio [2]
- Python 3 only from now on
For full release notes see [1].
Cheers,
Robert Cimrman
[1] http://docs.sfepy.org/doc/release_notes.html#id1
[2] https://github.com/nschloe/meshio
---
Contributors to this release in alphabetical order:
Robert Cimrman
Lubos Kejzlar
Vladimir Lukes
In the last two weeks, we have discussed and investigated concepts
around running this year’s EuroPython conference as an online
conference. We have looked at conference tools, your feedback, drafted
up ideas on what we can do to make the event interesting and what we
can accomplish given our limited resources.
Today, we are happy to announce that we will be running
* EuroPython 2020 *
from July 23 - 26 2020
as an online conference
We are planning the following structure:
- 2 conference days with keynotes, talks, lightning talks, poster
session (Thursday and Friday)
- 2 sprint days with multiple sprint teams (Saturday and Sunday)
Attending the conference days will require a ticket, participating in
the sprint days will be free.
We will publish additional information on the new format as it becomes
available. A few updates for today (more details will follow in
separate blog posts):
Call for Papers (CFP)
---------------------
With the new plan in place, we will extend and retarget the CFP we had
been running in the last three weeks to the online setup.
Please note that we will not have training sessions at EuroPython
2020. We will have keynotes, 30 and 45-minute talks, panels,
interactive sessions, as well as try to come up with a format for
doing posters and lightning talks.
Unlike for our in-person event, speakers will get free tickets to the
event, since we don’t have to cover catering costs.
We need your help
-----------------
Given that we had already put a lot of work into the in-person event
organization, a lot of which we’ll now have to adapt or redo for the
online set up in the few months ahead of us, we will need more help
from the community to make this happen.
If you would like to help, please write to board(a)europython.eu. We are
specifically looking for people with experience using online
conference tools to help host tracks during the conference days.
Sponsoring
----------
As for the in-person event, we will have sponsorship packages
available for the online event as well. Because the format is
different, we’ll have to adjust the packages we had intended for the
in-person to an online setup.
If you are interested in sponsoring EuroPython 2020, please write to
sponsoring(a)europython.eu. We will then send you more details, as they
become available.
Help spread the word
--------------------
Please help us spread this message by sharing it on your social
networks as widely as possible. Thank you !
Link to the blog post:
https://blog.europython.eu/post/614102095419850752/europython-2020-online-c…
Tweet:
https://twitter.com/europython/status/1244947459006173184
Thanks,
--
EuroPython 2020 Team
https://ep2020.europython.eu/https://www.europython-society.org/
I am please to share you with a interview summary[Chinese Language] about
python.
Mainly covering backend architecture including python principle, design
patterns , data structure, Git, Redis, MySql, Spider, ELK,Kafka, Istio,
Kubernetes...
I will keep updating contents future , If you love the Chinese version,
welcome to join contribution
Repo: https://github.com/DasyDong/interview_python_practice/
With Regards
Dasy
--
Python-announce-list mailing list -- python-announce-list(a)python.org
To unsubscribe send an email to python-announce-list-leave(a)python.org
https://mail.python.org/mailman3/lists/python-announce-list.python.org/
Support the Python Software Foundation:
http://www.python.org/psf/donations/
Hi all,
SonarSource is happy to announce support of Python 3.8, including the
walrus operator, and 10 new rules related to method signature and
visibility.
Details here:
https://community.sonarsource.com/t/sonarcloud-scans-python-3-8-code-and-de…
These improvements are available today on sonarcloud.io, where Python
static analysis is free for open source projects. Python analysis is also
free in SonarQube, with taint analysis available in commercial editions.
These changes will be available in the upcoming SonarQube 8.3.
Thx!
Ann
---
*G. Ann Campbell* | SonarSource
*Product Marketing Manager*
@GAnnCampbell
https://sonarsource.com
Vulture - Find dead code
========================
Vulture finds unused code in Python programs. This is useful for
cleaning up and finding errors in large code bases. If you run Vulture
on both your library and test suite you can find untested code.
Due to Python's dynamic nature, static code analyzers like Vulture are
likely to miss some dead code. Also, code that is only called
implicitly may be reported as unused. Nonetheless, Vulture can be a
very helpful tool for higher code quality.
Download
========
https://github.com/jendrikseipp/vulturehttp://pypi.python.org/pypi/vulture
Features
========
* fast: uses static code analysis
* tested: tests itself and has complete test coverage
* complements pyflakes and has the same output syntax
* sorts unused classes and functions by size with ``--sort-by-size``
* supports Python 2.7 and Python 3.5+
News
====
* Ignore unused import statements in `__init__.py` (RJ722, #192).
* Report first decorator's line number for unused decorated objects on
Python 3.8+ (RJ722, #200).
* Check code with black and pyupgrade.
Cheers
Jendrik
I am please to announce the availability of the "baseline" package.
This tool streamlines creation and maintenance of tests which compare string
output against a baseline. It offers a mechanism to compare a string against
a baselined copy and update the baselined copy to match the new value when a
mismatch occurs. The update process includes a manual step to facilitate a
review of the change before acceptance. The tool uses multi-line string
format
for string baselines to improve readability for human review.
Docs: https://baseline.readthedocs.io/en/latest/
PyPi: https://pypi.org/project/baseline/
Repo: https://github.com/dmgass/baseline
License: MIT
With Regards,
Dan Gass
(dan.gass at gmail)
***********
Quick Start
***********
Create an empty baseline with a triple quoted multi-line string. Place
the ending triple quote on a separate line and indent it to the level
you wish the string baseline update to be indented to. Add a compare of
the string being tested to the baseline string. Then save the file as
``fox.py``:
.. code-block:: python
from baseline import Baseline
expected = Baseline("""
""")
test_string = "THE QUICK BROWN FOX\n JUMPS\nOVER THE LAZY DOG."
assert test_string == expected
Run ``fox.py`` and observe that the ``assert`` raises an exception since
the strings are not equal. Because the comparison failed, the tool located
the triple quoted baseline string in the source file and updated it with the
miscompared value. When the interpretter exited, the tool saved the updated
source file but changed the file name to ``fox.update.py``:
.. code-block:: python
from baseline import Baseline
expected = Baseline("""
THE QUICK BROWN FOX
JUMPS
OVER THE LAZY DOG.
""")
test_string = "THE QUICK BROWN FOX\n JUMPS\nOVER THE LAZY DOG."
assert test_string == expected
After reviewing the change with your favorite file differencing tool,
accept the change by either manually overwriting the original file or use
the ``baseline`` command line tool to scan the directory for updated
scripts and accept them:
.. code-block:: shell
$ python -m baseline *
Found updates for:
fox.py
Hit [ENTER] to update, [Ctrl-C] to cancel
fox.update.py -> fox.py
Run ``fox.py`` again and observe the ``assert`` does not raise an exception
nor is a source file update generated. If in the future the test value
changes, the ``assert`` will raise an exception and cause a new source file
update to be generated. Simply repeat the review and acceptance step and you
are back in business!
<P><A HREF="https://baseline.readthedocs.io/en/latest/">
baseline 0.2.1</A> - Easy String Baseline (07-Jun-18)
=============================
Announcing python-blosc 1.9.0
=============================
What is new?
============
In this release we got rid of the support for Python 2.7 and 3.5.
Also, we fixed the copy of the leftovers of a chunk when its size is not a
multiple of the typesize. Although this is a very unusual situation,
it can certainly happen (e.g.
https://github.com/Blosc/python-blosc/issues/220).
Finally, sources for C-Blosc v1.18.1 have been included.
For more info, you can have a look at the release notes in:
https://github.com/Blosc/python-blosc/blob/master/RELEASE_NOTES.rst
More docs and examples are available in the documentation site:
http://python-blosc.blosc.org
What is it?
===========
Blosc (http://www.blosc.org) is a high performance compressor optimized
for binary data. It has been designed to transmit data to the processor
cache faster than the traditional, non-compressed, direct memory fetch
approach via a memcpy() OS call. Blosc works well for compressing
numerical arrays that contains data with relatively low entropy, like
sparse data, time series, grids with regular-spaced values, etc.
python-blosc (http://python-blosc.blosc.org/) is the Python wrapper for
the Blosc compression library, with added functions (`compress_ptr()`
and `pack_array()`) for efficiently compressing NumPy arrays, minimizing
the number of memory copies during the process. python-blosc can be
used to compress in-memory data buffers for transmission to other
machines, persistence or just as a compressed cache.
There is also a handy tool built on top of python-blosc called Bloscpack
(https://github.com/Blosc/bloscpack). It features a commmand line
interface that allows you to compress large binary datafiles on-disk.
It also comes with a Python API that has built-in support for
serializing and deserializing Numpy arrays both on-disk and in-memory at
speeds that are competitive with regular Pickle/cPickle machinery.
Sources repository
==================
The sources and documentation are managed through github services at:
http://github.com/Blosc/python-blosc
----
**Enjoy data!**
On behalf of the Jython development team, I am pleased to announce that
Jython 2.7.2 has been released.
Notable additions include:
* much improved support for locale, but as a backward-incompatible
change, it is provided as an opt-in.
* a main program that behaves more like CPython in many small ways,
including -i and -E support.
* a JAR and POM that may be cited as a dependency by other projects
using Gradle or Maven (experimental).
* a great many bug-fixes.
For the details see: https://www.jython.org/news and the NEWS link
there. Convenient download links are at https://www.jython.org/download .
Thanks are due to the many contributors to Jython for making this possible.
--
Jeff Allen
(forwarded from Jython-users, original message at
https://sourceforge.net/p/jython/mailman/message/36956522/
-Stefan Richthofer)
Hello,
https://github.com/pfalcon/pycopy
Pycopy is a minimalist, lightweight, resource-efficient implementation
of Python(-like) language. Pycopy to CPython is the same thing as
Scheme to Common Lisp. Executable sizes of 300-400KB, instant startup,
no need to carry around large monolithic library consisting largely of
legacy modules - some but not all of Pycopy's features.
Pycopy 3.x release solves the question of extensibility of Pycopy
builtin types (which by default provide subset of CPython
functionality) to full CPython compatibility. A couple of pretty
large Python applications, originally developed for CPython, now can
run with Pycopy.
Prebuilt binaries of this release are available at
https://github.com/pfalcon/pycopy/releases/tag/v3.0.5
More details about Pycopy
-------------------------
Pycopy strives to define a core language features suitable to easily
develop efficient software, while allow for extensibility to a wider
(and much more bloaty and less efficient) set of features for
compatibility with existing software.
Pycopy doesn't come with bulky hazardous lead-acid batteries. Instead,
a set of a few core modules are included builtin: inspired, being a
noticeable subset, and a little bit of extension, of the corresponding
CPython modules - clearly namespaced, to still allow room to implement
fully compatible CPython modules. These new modules aren't intended to
be an adhoc thing, just an alternative API with a constraint of
minimality. Implementation of that API also exists for CPython (WIP),
allowing Pycopy -> CPython compatibility.
The rest is handled outside the core language, via a separate project,
pycopy-lib: https://github.com/pfalcon/pycopy-lib , which strives to
port CPython stdlib to Pycopy, while, where needed, provide more
lightweight module variants and extensions.
Pycopy is a full-stack project, with ecosystem including a web
micro-framework, pure-Python Python parser, FFMPEG bindings, SDL
bindings, LLVM bindings, etc.: https://github.com/topics/pycopy
--
Best regards,
Paul mailto:pmiscml@gmail.com