semvec/pypi-packages huggingface dataset:
climap 0.1.1
A rich command line utility for accessing emails
Requires Python: >=3.8,<4.0


[![version](https://img.shields.io/pypi/v/climap?color=green)](https://pypi.org/project/climap/)
[![supports](https://img.shields.io/pypi/pyversions/climap?color=blue&label=supports)](https://pypi.org/project/climap/)
[![test coverage](https://codecov.io/gh/symonk/climap/branch/main/graph/badge.svg)](https://codecov.io/gh/symonk/climap)
[![docs](https://img.shields.io/badge/documentation-online-brightgreen.svg)](https://symonk.github.io/climap/)


# climap (**ALPHA**)

-----

A rich-based command line utility for IMAP. Written solely in python.
poetrybot 0.2.0
poetrybot is a Telegram bot to quote poems between friends.
Requires Python: >=3.9,<4.0
Keywords: telegram,bot

poetrybot
=========

poetrybot is a Telegram bot to quote poems between friends. It's written in
Python and it is released under the EUPL 1.2 license.

Friends are defined by an allow list in which every account have to be in order
to to use the bot.
The management of the bot is provided by a REST API defined in the subpackage
``poetrybot.web``.


Installation
------------

1. Create your bot using Telegram `@BotFather <https://t.me/botfather>`_.
2. Install (preferably inside a virtualenv) the bot using:

   .. code-block::

      pip install poetrybot

3. The bot uses environment variables as configuration, you have to export the
   following before starting it:

   .. code-block::

      export AUTH_TOKEN=<my secret auth token>
      export DATABASE_URL=sqlite:////absolute/path/to/poetrybot.db
      export TELEGRAM_TOKEN=<telegram bot API key>

   ``AUTH_TOKEN`` is used to authenticate to the REST API used to manage the
   bot. Full specification is in the ``docs/openapi.yml`` file.
   Just create a long enough random string, for example using ``pwgen -sy 50``.
4. Launch the bot:

   .. code-block::

      poetrybot
5. To use the REST API install a WSGI HTTP Server, for example gunicorn, and
   then:

   .. code-block::

      gunicorn poetrybot.web.wsgi:app

6. Use the REST API to insert allowed friends, poets and poems. The fastest way
   to look at the API is to load the API specification into
   https://editor.swagger.io

An alternative is to clone the repository and use the provided ``Dockerfile``.

Usage
-----

To use the bot you only have to use the ``/quote`` command. The bot can be
added to one or more channels but it's not required. But remember that only
friends in allow list will be able to interact with the bot.

The ``/quote`` command used without parameters will make the bot to quote a
random poem, but optionally the author and the argument can be specified:

* ``/quote`` returns a random poem;
* ``/quote AUTHOR`` returns a random poem by ``AUTHOR``.

  ``AUTHOR`` is the name or part of the name of the poet case insensitive:

  .. code-block::

     /quote Giovanni Pascoli
     /quote pascoli
     /quote ascol

  will return a random poem by Giovanni Pascoli, if you don't have another
  poet with *ascol* inside the name;
* ``/quote AUTHOR about ARGUMENT`` returns a random poem by ``AUTHOR`` about
  ``ARGUMENT``.

  ``ARGUMENT`` is, like ``AUTHOR``, case insensitive and can be part of a word.
  ``about`` is, instead, case sensitive;
* ``/quote about ARGUMENT`` returns a random poem about ``ARGUMENT``.
autocopyright 1.1.0
Script for adding copyright notes at the top of files.
Requires Python: >=3.9,<4.0

# autocopyright

Autocopyright is a script which was designed to automatically add copyright notices at
the top of source files. It uses jinja2 templates which can be automatically filled with
values pulled from `pyproject.toml` and other files.

## Example

To run autocopyright you must specify comment sign, directory to traverse, glob patterns
of files to modify and path to license template.

```
autocopyright -s "#" -d autocopyright -g "*.py" -g "*.pyi" -l "./templates/MIT.md.jinja2"
```

## Templates

Autocopyright uses Jinja2 templates to determine content of copyright header. Such
template is loaded from predefined destination and rendered with few special variables
available. Those variables are listed below:

- `now` - `datetime.datetime` object holding current time (determined once, at the
  beginning of script execution)

- `pyproject` - dictionary-like object holding loaded content of `pyproject.toml` file
  loaded from current working directory of script.

Template for **LGPL-3.0** license could look like this:

```jinja
Copyright {{ now.year }} {{ pyproject.tool.poetry.authors[0] }}

This file is part of {{ pyproject.tool.poetry["name"] }}.
{{ pyproject.tool.poetry.repository }}

{{ pyproject.tool.poetry["name"] }} is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.

{{ pyproject.tool.poetry["name"] }} is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.

You should have received a copy of the GNU Lesser General Public License
along with {{ pyproject.tool.poetry["name"] }}. If not, see <http://www.gnu.org/licenses/>.
```

## Pre-commit hook

To add this script as pre commit hook, create `.pre-commit-config.yaml` file, or append
to existing one, following lines:

```yaml
repos:
  - repo: https://github.com/Argmaster/autocopyright
    rev: "v1.1.0"
    hooks:
      - id: autocopyright
        args:
          [
            -s,
            "#",
            -d,
            <your-project-source-dir-name>,
            -g,
            "*.py",
            -l,
            <path-to-license-template>,
          ]
```

Replace `<your-project-source-dir-name>` with valid name of your project source
directory, for example `source` or `src`.

Replace `<path-to-license-template>` with path to jinja2 template file containing
license note, eg. `"./templates/LGPL3.md.jinja2"`. See **Templates** section for example
of template content.
deepops 1.8
Python deepops module
Keywords: deep operations merge remove

PYTHON DEEPOPS MODULE
=====================

This module contains some functions for performing "deep" operations on
standard Python "compound" data structures - lists/sets/dictionaries:

* `deepmerge()` - merges two compound structures, including all sub-items,
  e.g. items to lists and sets, missing keys/items to dictionaries, optionally
  replacing clashing simple types.
* `deepremoveitems()` - removes items (simple types, or whole compound
  structures) from within another compound data structure.
* `deepfilter()` - returns the part of one compound structure that is matched
  by the other: essentially the opposite of deepremoveitems().
* `deepdiff()` - compares two compound structures and returns a tuple of items
  to be removed and items to be updated: these could be passed to
  `deepremoveitems()` and `deepmerge()`, respectively, to transform one into
  the other (although note that they would need to be `deepcopy()`ed first).
* `deepsetdefault()` - similar to dict.setdefault() except that it can set the
  default at arbitrarily deep paths into a dictionary.
* `deepget()` - similar to dict.get() but can copy with arbitrarily deep paths
  into an indexable structure.

The module was developed and used under Python 3.4-3.7 but seems to
work OK in basic testing under 2.7.

Author
------

Robert Franklin <rcf@mince.net>, UK