pax_global_header00006660000000000000000000000064143650646510014524gustar00rootroot0000000000000052 comment=776db92b35ef122aadbb66f4c2ecc2574c3dc3da jaraco.text-3.11.1/000077500000000000000000000000001436506465100140315ustar00rootroot00000000000000jaraco.text-3.11.1/.coveragerc000066400000000000000000000001711436506465100161510ustar00rootroot00000000000000[run] omit = # leading `*/` for pytest-dev/pytest-cov#456 */.tox/* */pep517-build-env-* [report] show_missing = True jaraco.text-3.11.1/.editorconfig000066400000000000000000000003661436506465100165130ustar00rootroot00000000000000root = true [*] charset = utf-8 indent_style = tab indent_size = 4 insert_final_newline = true end_of_line = lf [*.py] indent_style = space max_line_length = 88 [*.{yml,yaml}] indent_style = space indent_size = 2 [*.rst] indent_style = space jaraco.text-3.11.1/.flake8000066400000000000000000000002101436506465100151750ustar00rootroot00000000000000[flake8] max-line-length = 88 # jaraco/skeleton#34 max-complexity = 10 extend-ignore = # Black creates whitespace before colon E203 jaraco.text-3.11.1/.github/000077500000000000000000000000001436506465100153715ustar00rootroot00000000000000jaraco.text-3.11.1/.github/FUNDING.yml000066400000000000000000000000331436506465100172020ustar00rootroot00000000000000tidelift: pypi/jaraco.text jaraco.text-3.11.1/.github/dependabot.yml000066400000000000000000000002241436506465100202170ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: "pip" directory: "/" schedule: interval: "daily" allow: - dependency-type: "all" jaraco.text-3.11.1/.github/workflows/000077500000000000000000000000001436506465100174265ustar00rootroot00000000000000jaraco.text-3.11.1/.github/workflows/main.yml000066400000000000000000000063361436506465100211050ustar00rootroot00000000000000name: tests on: [push, pull_request] env: # Environment variables to support color support (jaraco/skeleton#66): # Request colored output from CLI tools supporting it. Different tools # interpret the value differently. For some, just being set is sufficient. # For others, it must be a non-zero integer. For yet others, being set # to a non-empty value is sufficient. For tox, it must be one of # , 0, 1, false, no, off, on, true, yes. The only enabling value # in common is "1". FORCE_COLOR: 1 # MyPy's color enforcement (must be a non-zero number) MYPY_FORCE_COLOR: -42 # Recognized by the `py` package, dependency of `pytest` (must be "1") PY_COLORS: 1 # Make tox-wrapped tools see color requests TOX_TESTENV_PASSENV: >- FORCE_COLOR MYPY_FORCE_COLOR NO_COLOR PY_COLORS PYTEST_THEME PYTEST_THEME_MODE # Suppress noisy pip warnings PIP_DISABLE_PIP_VERSION_CHECK: 'true' PIP_NO_PYTHON_VERSION_WARNING: 'true' PIP_NO_WARN_SCRIPT_LOCATION: 'true' # Disable the spinner, noise in GHA; TODO(webknjaz): Fix this upstream # Must be "1". TOX_PARALLEL_NO_SPINNER: 1 jobs: test: strategy: matrix: python: - "3.7" - "3.11" - "3.12" # Workaround for actions/setup-python#508 dev: - -dev platform: - ubuntu-latest - macos-latest - windows-latest include: - python: "3.8" platform: ubuntu-latest - python: "3.9" platform: ubuntu-latest - python: "3.10" platform: ubuntu-latest - python: pypy3.9 platform: ubuntu-latest runs-on: ${{ matrix.platform }} continue-on-error: ${{ matrix.python == '3.12' }} steps: - uses: actions/checkout@v3 - name: Setup Python uses: actions/setup-python@v4 with: python-version: ${{ matrix.python }}${{ matrix.dev }} - name: Install tox run: | python -m pip install tox - name: Run tests run: tox docs: runs-on: ubuntu-latest env: TOXENV: docs steps: - uses: actions/checkout@v3 - name: Setup Python uses: actions/setup-python@v4 with: python-version: ${{ matrix.python }}${{ matrix.dev }} - name: Install tox run: | python -m pip install tox - name: Run tests run: tox check: # This job does nothing and is only used for the branch protection if: always() needs: - test - docs runs-on: ubuntu-latest steps: - name: Decide whether the needed jobs succeeded or failed uses: re-actors/alls-green@release/v1 with: jobs: ${{ toJSON(needs) }} release: needs: - check if: github.event_name == 'push' && contains(github.ref, 'refs/tags/') runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Setup Python uses: actions/setup-python@v4 with: python-version: 3.11-dev - name: Install tox run: | python -m pip install tox - name: Release run: tox -e release env: TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} jaraco.text-3.11.1/.pre-commit-config.yaml000066400000000000000000000001211436506465100203040ustar00rootroot00000000000000repos: - repo: https://github.com/psf/black rev: 22.6.0 hooks: - id: black jaraco.text-3.11.1/.readthedocs.yaml000066400000000000000000000003511436506465100172570ustar00rootroot00000000000000version: 2 python: install: - path: . extra_requirements: - docs # workaround for readthedocs/readthedocs.org#9623 build: # workaround for readthedocs/readthedocs.org#9635 os: ubuntu-22.04 tools: python: "3" jaraco.text-3.11.1/CHANGES.rst000066400000000000000000000050141436506465100156330ustar00rootroot00000000000000v3.11.1 ======= Fixed ``EncodingWarnings`` when reading/writing text. v3.11.0 ======= Added ``strip-prefix`` script. v3.10.0 ======= Prefer ``casefold`` in ``FoldedCase``. v3.9.1 ====== #10: Fixed broken tests in ``read_newlines`` and ``show-newlines``. v3.9.0 ====== Add ``jaraco.text.show-newlines`` script. v3.8.1 ====== Refreshed packaging. Enrolled with Tidelift. v3.8.0 ====== Added ``layouts`` module and ``to-qwerty`` and ``to-dvorak`` scripts. v3.7.0 ====== Introducing ``yield_lines``, ``drop_comment``, and ``join_continuation``. v3.6.0 ====== Fixed ``DeprecationWarning`` in ``importlib.resources.read_text`` as reported in #7. v3.5.1 ====== #5: Fixed warning in docs builds. v3.5.0 ====== Rely on PEP 420 for namespace package. v3.4.0 ====== Added ``WordSet.trim*`` methods. v3.3.0 ====== Require Python 3.6 or later. v3.2.0 ====== Added normalize_newlines function. 3.1 === Added ``wrap`` and ``unwrap`` functions and ``lorem_ipsum`` attribute containing the Lorem Ipsum sample text. 3.0.1 ===== Declare missing dependency on six. 3.0 === Removed ``local_format``, ``global_format``, and ``namespace_format``. Instead, developers should use `f-strings `_ on Python 3.6 and later or `future-fstrings `_ for compatibilty with older Pythons. This change eliminates the dependency on jaraco.collections and thus for now removes the circular dependency as reported in #3. 2.0 === Switch to `pkgutil namespace technique `_ for the ``jaraco`` namespace. 1.10.1 ====== Packaging refresh. Docs now published in RTD. 1.10 ==== FoldedCase now supports string-containment support in an unfortunately assymetric way. 1.9.2 ===== Fix bug where ``FoldedCase.__ne__`` was case-sensitive. 1.9.1 ===== Refresh packaging. 1.9 === Synchronize with skeleton. Update docs and expand tests on FoldedCase. Use method_cache for ``FoldedCase.lower``. 1.8 === Add remove_prefix and remove_suffix helpers. 1.7 === In Stripper, always strip the prefix, even if it's empty. 1.6.2 ===== Issue #1: Fix WordSet on Python 2. 1.6 === Drop dependency on jaraco.context (and its dependencies). 1.5 === Move hosting to github. Add missing namespace package declaration in distribution. 1.4 === Add Stripper class. 1.3 === Add SeparatedValues class. 1.0 === Initial implementation adopted from jaraco.util.string 10.8. jaraco.text-3.11.1/LICENSE000066400000000000000000000020321436506465100150330ustar00rootroot00000000000000Copyright Jason R. Coombs Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. jaraco.text-3.11.1/README.rst000066400000000000000000000044451436506465100155270ustar00rootroot00000000000000.. image:: https://img.shields.io/pypi/v/jaraco.text.svg :target: https://pypi.org/project/jaraco.text .. image:: https://img.shields.io/pypi/pyversions/jaraco.text.svg .. image:: https://github.com/jaraco/jaraco.text/workflows/tests/badge.svg :target: https://github.com/jaraco/jaraco.text/actions?query=workflow%3A%22tests%22 :alt: tests .. image:: https://img.shields.io/badge/code%20style-black-000000.svg :target: https://github.com/psf/black :alt: Code style: Black .. image:: https://readthedocs.org/projects/jaracotext/badge/?version=latest :target: https://jaracotext.readthedocs.io/en/latest/?badge=latest .. image:: https://img.shields.io/badge/skeleton-2023-informational :target: https://blog.jaraco.com/skeleton .. image:: https://tidelift.com/badges/package/pypi/jaraco.text :target: https://tidelift.com/subscription/pkg/pypi-jaraco.text?utm_source=pypi-jaraco.text&utm_medium=readme This package provides handy routines for dealing with text, such as wrapping, substitution, trimming, stripping, prefix and suffix removal, line continuation, indentation, comment processing, identifier processing, values parsing, case insensitive comparison, and more. See the docs (linked in the badge above) for the detailed documentation and examples. Layouts ======= One of the features of this package is the layouts module, which provides a simple example of translating keystrokes from one keyboard layout to another:: echo qwerty | python -m jaraco.text.to-dvorak ',.pyf echo "',.pyf" | python -m jaraco.text.to-qwerty qwerty Newline Reporting ================= Need to know what newlines appear in a file? :: $ python -m jaraco.text.show-newlines README.rst newline is '\n' For Enterprise ============== Available as part of the Tidelift Subscription. This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. `Learn more `_. Security Contact ================ To report a security vulnerability, please use the `Tidelift security contact `_. Tidelift will coordinate the fix and disclosure. jaraco.text-3.11.1/conftest.py000066400000000000000000000004571436506465100162360ustar00rootroot00000000000000import sys import pytest if sys.version_info < (3, 10): import pathlib2 as pathlib # pragma: nocover else: import pathlib # pragma: nocover @pytest.fixture def tmp_path(tmp_path): """ Override tmp_path to wrap in a more modern interface. """ return pathlib.Path(tmp_path) jaraco.text-3.11.1/docs/000077500000000000000000000000001436506465100147615ustar00rootroot00000000000000jaraco.text-3.11.1/docs/conf.py000066400000000000000000000022101436506465100162530ustar00rootroot00000000000000extensions = [ 'sphinx.ext.autodoc', 'jaraco.packaging.sphinx', ] master_doc = "index" html_theme = "furo" # Link dates and other references in the changelog extensions += ['rst.linker'] link_files = { '../CHANGES.rst': dict( using=dict(GH='https://github.com'), replace=[ dict( pattern=r'(Issue #|\B#)(?P\d+)', url='{package_url}/issues/{issue}', ), dict( pattern=r'(?m:^((?Pv?\d+(\.\d+){1,2}))\n[-=]+\n)', with_scm='{text}\n{rev[timestamp]:%d %b %Y}\n', ), dict( pattern=r'PEP[- ](?P\d+)', url='https://peps.python.org/pep-{pep_number:0>4}/', ), ], ) } # Be strict about any broken references nitpicky = True # Include Python intersphinx mapping to prevent failures # jaraco/skeleton#51 extensions += ['sphinx.ext.intersphinx'] intersphinx_mapping = { 'python': ('https://docs.python.org/3', None), } # Preserve authored syntax for defaults autodoc_preserve_defaults = True extensions += ['jaraco.tidelift'] jaraco.text-3.11.1/docs/history.rst000066400000000000000000000001211436506465100172060ustar00rootroot00000000000000:tocdepth: 2 .. _changes: History ******* .. include:: ../CHANGES (links).rst jaraco.text-3.11.1/docs/index.rst000066400000000000000000000006431436506465100166250ustar00rootroot00000000000000Welcome to |project| documentation! =================================== .. toctree:: :maxdepth: 1 history .. tidelift-referral-banner:: .. automodule:: jaraco.text :members: :undoc-members: :show-inheritance: .. automodule:: jaraco.text.layouts :members: :undoc-members: :show-inheritance: Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` jaraco.text-3.11.1/jaraco/000077500000000000000000000000001436506465100152705ustar00rootroot00000000000000jaraco.text-3.11.1/jaraco/text/000077500000000000000000000000001436506465100162545ustar00rootroot00000000000000jaraco.text-3.11.1/jaraco/text/Lorem ipsum.txt000066400000000000000000000024671436506465100212220ustar00rootroot00000000000000Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, turpis et commodo pharetra, est eros bibendum elit, nec luctus magna felis sollicitudin mauris. Integer in mauris eu nibh euismod gravida. Duis ac tellus et risus vulputate vehicula. Donec lobortis risus a elit. Etiam tempor. Ut ullamcorper, ligula eu tempor congue, eros est euismod turpis, id tincidunt sapien risus a quam. Maecenas fermentum consequat mi. Donec fermentum. Pellentesque malesuada nulla a mi. Duis sapien sem, aliquet nec, commodo eget, consequat quis, neque. Aliquam faucibus, elit ut dictum aliquet, felis nisl adipiscing sapien, sed malesuada diam lacus eget erat. Cras mollis scelerisque nunc. Nullam arcu. Aliquam consequat. Curabitur augue lorem, dapibus quis, laoreet et, pretium ac, nisi. Aenean magna nisl, mollis quis, molestie eu, feugiat in, orci. In hac habitasse platea dictumst. jaraco.text-3.11.1/jaraco/text/__init__.py000066400000000000000000000376171436506465100204030ustar00rootroot00000000000000import re import itertools import textwrap import functools try: from importlib.resources import files # type: ignore except ImportError: # pragma: nocover from importlib_resources import files # type: ignore from jaraco.functools import compose, method_cache from jaraco.context import ExceptionTrap def substitution(old, new): """ Return a function that will perform a substitution on a string """ return lambda s: s.replace(old, new) def multi_substitution(*substitutions): """ Take a sequence of pairs specifying substitutions, and create a function that performs those substitutions. >>> multi_substitution(('foo', 'bar'), ('bar', 'baz'))('foo') 'baz' """ substitutions = itertools.starmap(substitution, substitutions) # compose function applies last function first, so reverse the # substitutions to get the expected order. substitutions = reversed(tuple(substitutions)) return compose(*substitutions) class FoldedCase(str): """ A case insensitive string class; behaves just like str except compares equal when the only variation is case. >>> s = FoldedCase('hello world') >>> s == 'Hello World' True >>> 'Hello World' == s True >>> s != 'Hello World' False >>> s.index('O') 4 >>> s.split('O') ['hell', ' w', 'rld'] >>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta'])) ['alpha', 'Beta', 'GAMMA'] Sequence membership is straightforward. >>> "Hello World" in [s] True >>> s in ["Hello World"] True Allows testing for set inclusion, but candidate and elements must both be folded. >>> FoldedCase("Hello World") in {s} True >>> s in {FoldedCase("Hello World")} True String inclusion works as long as the FoldedCase object is on the right. >>> "hello" in FoldedCase("Hello World") True But not if the FoldedCase object is on the left: >>> FoldedCase('hello') in 'Hello World' False In that case, use ``in_``: >>> FoldedCase('hello').in_('Hello World') True >>> FoldedCase('hello') > FoldedCase('Hello') False >>> FoldedCase('ß') == FoldedCase('ss') True """ def __lt__(self, other): return self.casefold() < other.casefold() def __gt__(self, other): return self.casefold() > other.casefold() def __eq__(self, other): return self.casefold() == other.casefold() def __ne__(self, other): return self.casefold() != other.casefold() def __hash__(self): return hash(self.casefold()) def __contains__(self, other): return super().casefold().__contains__(other.casefold()) def in_(self, other): "Does self appear in other?" return self in FoldedCase(other) # cache casefold since it's likely to be called frequently. @method_cache def casefold(self): return super().casefold() def index(self, sub): return self.casefold().index(sub.casefold()) def split(self, splitter=' ', maxsplit=0): pattern = re.compile(re.escape(splitter), re.I) return pattern.split(self, maxsplit) # Python 3.8 compatibility _unicode_trap = ExceptionTrap(UnicodeDecodeError) @_unicode_trap.passes def is_decodable(value): r""" Return True if the supplied value is decodable (using the default encoding). >>> is_decodable(b'\xff') False >>> is_decodable(b'\x32') True """ value.decode() def is_binary(value): r""" Return True if the value appears to be binary (that is, it's a byte string and isn't decodable). >>> is_binary(b'\xff') True >>> is_binary('\xff') False """ return isinstance(value, bytes) and not is_decodable(value) def trim(s): r""" Trim something like a docstring to remove the whitespace that is common due to indentation and formatting. >>> trim("\n\tfoo = bar\n\t\tbar = baz\n") 'foo = bar\n\tbar = baz' """ return textwrap.dedent(s).strip() def wrap(s): """ Wrap lines of text, retaining existing newlines as paragraph markers. >>> print(wrap(lorem_ipsum)) Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, turpis et commodo pharetra, est eros bibendum elit, nec luctus magna felis sollicitudin mauris. Integer in mauris eu nibh euismod gravida. Duis ac tellus et risus vulputate vehicula. Donec lobortis risus a elit. Etiam tempor. Ut ullamcorper, ligula eu tempor congue, eros est euismod turpis, id tincidunt sapien risus a quam. Maecenas fermentum consequat mi. Donec fermentum. Pellentesque malesuada nulla a mi. Duis sapien sem, aliquet nec, commodo eget, consequat quis, neque. Aliquam faucibus, elit ut dictum aliquet, felis nisl adipiscing sapien, sed malesuada diam lacus eget erat. Cras mollis scelerisque nunc. Nullam arcu. Aliquam consequat. Curabitur augue lorem, dapibus quis, laoreet et, pretium ac, nisi. Aenean magna nisl, mollis quis, molestie eu, feugiat in, orci. In hac habitasse platea dictumst. """ paragraphs = s.splitlines() wrapped = ('\n'.join(textwrap.wrap(para)) for para in paragraphs) return '\n\n'.join(wrapped) def unwrap(s): r""" Given a multi-line string, return an unwrapped version. >>> wrapped = wrap(lorem_ipsum) >>> wrapped.count('\n') 20 >>> unwrapped = unwrap(wrapped) >>> unwrapped.count('\n') 1 >>> print(unwrapped) Lorem ipsum dolor sit amet, consectetur adipiscing ... Curabitur pretium tincidunt lacus. Nulla gravida orci ... """ paragraphs = re.split(r'\n\n+', s) cleaned = (para.replace('\n', ' ') for para in paragraphs) return '\n'.join(cleaned) lorem_ipsum: str = ( files(__name__).joinpath('Lorem ipsum.txt').read_text(encoding='utf-8') ) class Splitter(object): """object that will split a string with the given arguments for each call >>> s = Splitter(',') >>> s('hello, world, this is your, master calling') ['hello', ' world', ' this is your', ' master calling'] """ def __init__(self, *args): self.args = args def __call__(self, s): return s.split(*self.args) def indent(string, prefix=' ' * 4): """ >>> indent('foo') ' foo' """ return prefix + string class WordSet(tuple): """ Given an identifier, return the words that identifier represents, whether in camel case, underscore-separated, etc. >>> WordSet.parse("camelCase") ('camel', 'Case') >>> WordSet.parse("under_sep") ('under', 'sep') Acronyms should be retained >>> WordSet.parse("firstSNL") ('first', 'SNL') >>> WordSet.parse("you_and_I") ('you', 'and', 'I') >>> WordSet.parse("A simple test") ('A', 'simple', 'test') Multiple caps should not interfere with the first cap of another word. >>> WordSet.parse("myABCClass") ('my', 'ABC', 'Class') The result is a WordSet, providing access to other forms. >>> WordSet.parse("myABCClass").underscore_separated() 'my_ABC_Class' >>> WordSet.parse('a-command').camel_case() 'ACommand' >>> WordSet.parse('someIdentifier').lowered().space_separated() 'some identifier' Slices of the result should return another WordSet. >>> WordSet.parse('taken-out-of-context')[1:].underscore_separated() 'out_of_context' >>> WordSet.from_class_name(WordSet()).lowered().space_separated() 'word set' >>> example = WordSet.parse('figured it out') >>> example.headless_camel_case() 'figuredItOut' >>> example.dash_separated() 'figured-it-out' """ _pattern = re.compile('([A-Z]?[a-z]+)|([A-Z]+(?![a-z]))') def capitalized(self): return WordSet(word.capitalize() for word in self) def lowered(self): return WordSet(word.lower() for word in self) def camel_case(self): return ''.join(self.capitalized()) def headless_camel_case(self): words = iter(self) first = next(words).lower() new_words = itertools.chain((first,), WordSet(words).camel_case()) return ''.join(new_words) def underscore_separated(self): return '_'.join(self) def dash_separated(self): return '-'.join(self) def space_separated(self): return ' '.join(self) def trim_right(self, item): """ Remove the item from the end of the set. >>> WordSet.parse('foo bar').trim_right('foo') ('foo', 'bar') >>> WordSet.parse('foo bar').trim_right('bar') ('foo',) >>> WordSet.parse('').trim_right('bar') () """ return self[:-1] if self and self[-1] == item else self def trim_left(self, item): """ Remove the item from the beginning of the set. >>> WordSet.parse('foo bar').trim_left('foo') ('bar',) >>> WordSet.parse('foo bar').trim_left('bar') ('foo', 'bar') >>> WordSet.parse('').trim_left('bar') () """ return self[1:] if self and self[0] == item else self def trim(self, item): """ >>> WordSet.parse('foo bar').trim('foo') ('bar',) """ return self.trim_left(item).trim_right(item) def __getitem__(self, item): result = super(WordSet, self).__getitem__(item) if isinstance(item, slice): result = WordSet(result) return result @classmethod def parse(cls, identifier): matches = cls._pattern.finditer(identifier) return WordSet(match.group(0) for match in matches) @classmethod def from_class_name(cls, subject): return cls.parse(subject.__class__.__name__) # for backward compatibility words = WordSet.parse def simple_html_strip(s): r""" Remove HTML from the string `s`. >>> str(simple_html_strip('')) '' >>> print(simple_html_strip('A stormy day in paradise')) A stormy day in paradise >>> print(simple_html_strip('Somebody tell the truth.')) Somebody tell the truth. >>> print(simple_html_strip('What about
\nmultiple lines?')) What about multiple lines? """ html_stripper = re.compile('()|(<[^>]*>)|([^<]+)', re.DOTALL) texts = (match.group(3) or '' for match in html_stripper.finditer(s)) return ''.join(texts) class SeparatedValues(str): """ A string separated by a separator. Overrides __iter__ for getting the values. >>> list(SeparatedValues('a,b,c')) ['a', 'b', 'c'] Whitespace is stripped and empty values are discarded. >>> list(SeparatedValues(' a, b , c, ')) ['a', 'b', 'c'] """ separator = ',' def __iter__(self): parts = self.split(self.separator) return filter(None, (part.strip() for part in parts)) class Stripper: r""" Given a series of lines, find the common prefix and strip it from them. >>> lines = [ ... 'abcdefg\n', ... 'abc\n', ... 'abcde\n', ... ] >>> res = Stripper.strip_prefix(lines) >>> res.prefix 'abc' >>> list(res.lines) ['defg\n', '\n', 'de\n'] If no prefix is common, nothing should be stripped. >>> lines = [ ... 'abcd\n', ... '1234\n', ... ] >>> res = Stripper.strip_prefix(lines) >>> res.prefix = '' >>> list(res.lines) ['abcd\n', '1234\n'] """ def __init__(self, prefix, lines): self.prefix = prefix self.lines = map(self, lines) @classmethod def strip_prefix(cls, lines): prefix_lines, lines = itertools.tee(lines) prefix = functools.reduce(cls.common_prefix, prefix_lines) return cls(prefix, lines) def __call__(self, line): if not self.prefix: return line null, prefix, rest = line.partition(self.prefix) return rest @staticmethod def common_prefix(s1, s2): """ Return the common prefix of two lines. """ index = min(len(s1), len(s2)) while s1[:index] != s2[:index]: index -= 1 return s1[:index] def remove_prefix(text, prefix): """ Remove the prefix from the text if it exists. >>> remove_prefix('underwhelming performance', 'underwhelming ') 'performance' >>> remove_prefix('something special', 'sample') 'something special' """ null, prefix, rest = text.rpartition(prefix) return rest def remove_suffix(text, suffix): """ Remove the suffix from the text if it exists. >>> remove_suffix('name.git', '.git') 'name' >>> remove_suffix('something special', 'sample') 'something special' """ rest, suffix, null = text.partition(suffix) return rest def normalize_newlines(text): r""" Replace alternate newlines with the canonical newline. >>> normalize_newlines('Lorem Ipsum\u2029') 'Lorem Ipsum\n' >>> normalize_newlines('Lorem Ipsum\r\n') 'Lorem Ipsum\n' >>> normalize_newlines('Lorem Ipsum\x85') 'Lorem Ipsum\n' """ newlines = ['\r\n', '\r', '\n', '\u0085', '\u2028', '\u2029'] pattern = '|'.join(newlines) return re.sub(pattern, '\n', text) def _nonblank(str): return str and not str.startswith('#') @functools.singledispatch def yield_lines(iterable): r""" Yield valid lines of a string or iterable. >>> list(yield_lines('')) [] >>> list(yield_lines(['foo', 'bar'])) ['foo', 'bar'] >>> list(yield_lines('foo\nbar')) ['foo', 'bar'] >>> list(yield_lines('\nfoo\n#bar\nbaz #comment')) ['foo', 'baz #comment'] >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n'])) ['foo', 'bar', 'baz', 'bing'] """ return itertools.chain.from_iterable(map(yield_lines, iterable)) @yield_lines.register(str) def _(text): return filter(_nonblank, map(str.strip, text.splitlines())) def drop_comment(line): """ Drop comments. >>> drop_comment('foo # bar') 'foo' A hash without a space may be in a URL. >>> drop_comment('http://example.com/foo#bar') 'http://example.com/foo#bar' """ return line.partition(' #')[0] def join_continuation(lines): r""" Join lines continued by a trailing backslash. >>> list(join_continuation(['foo \\', 'bar', 'baz'])) ['foobar', 'baz'] >>> list(join_continuation(['foo \\', 'bar', 'baz'])) ['foobar', 'baz'] >>> list(join_continuation(['foo \\', 'bar \\', 'baz'])) ['foobarbaz'] Not sure why, but... The character preceding the backslash is also elided. >>> list(join_continuation(['goo\\', 'dly'])) ['godly'] A terrible idea, but... If no line is available to continue, suppress the lines. >>> list(join_continuation(['foo', 'bar\\', 'baz\\'])) ['foo'] """ lines = iter(lines) for item in lines: while item.endswith('\\'): try: item = item[:-2].strip() + next(lines) except StopIteration: return yield item def read_newlines(filename, limit=1024): r""" >>> tmp_path = getfixture('tmp_path') >>> filename = tmp_path / 'out.txt' >>> _ = filename.write_text('foo\n', newline='', encoding='utf-8') >>> read_newlines(filename) '\n' >>> _ = filename.write_text('foo\r\n', newline='', encoding='utf-8') >>> read_newlines(filename) '\r\n' >>> _ = filename.write_text('foo\r\nbar\nbing\r', newline='', encoding='utf-8') >>> read_newlines(filename) ('\r', '\n', '\r\n') """ with open(filename, encoding='utf-8') as fp: fp.read(limit) return fp.newlines jaraco.text-3.11.1/jaraco/text/layouts.py000066400000000000000000000012031436506465100203220ustar00rootroot00000000000000qwerty = "-=qwertyuiop[]asdfghjkl;'zxcvbnm,./_+QWERTYUIOP{}ASDFGHJKL:\"ZXCVBNM<>?" dvorak = "[]',.pyfgcrl/=aoeuidhtns-;qjkxbmwvz{}\"<>PYFGCRL?+AOEUIDHTNS_:QJKXBMWVZ" to_dvorak = str.maketrans(qwerty, dvorak) to_qwerty = str.maketrans(dvorak, qwerty) def translate(input, translation): """ >>> translate('dvorak', to_dvorak) 'ekrpat' >>> translate('qwerty', to_qwerty) 'x,dokt' """ return input.translate(translation) def _translate_stream(stream, translation): """ >>> import io >>> _translate_stream(io.StringIO('foo'), to_dvorak) urr """ print(translate(stream.read(), translation)) jaraco.text-3.11.1/jaraco/text/show-newlines.py000066400000000000000000000016101436506465100214260ustar00rootroot00000000000000import autocommand import inflect from more_itertools import always_iterable import jaraco.text def report_newlines(filename): r""" Report the newlines in the indicated file. >>> tmp_path = getfixture('tmp_path') >>> filename = tmp_path / 'out.txt' >>> _ = filename.write_text('foo\nbar\n', newline='', encoding='utf-8') >>> report_newlines(filename) newline is '\n' >>> filename = tmp_path / 'out.txt' >>> _ = filename.write_text('foo\nbar\r\n', newline='', encoding='utf-8') >>> report_newlines(filename) newlines are ('\n', '\r\n') """ newlines = jaraco.text.read_newlines(filename) count = len(tuple(always_iterable(newlines))) engine = inflect.engine() print( engine.plural_noun("newline", count), engine.plural_verb("is", count), repr(newlines), ) autocommand.autocommand(__name__)(report_newlines) jaraco.text-3.11.1/jaraco/text/strip-prefix.py000066400000000000000000000006341436506465100212650ustar00rootroot00000000000000import sys import autocommand from jaraco.text import Stripper def strip_prefix(): r""" Strip any common prefix from stdin. >>> import io, pytest >>> getfixture('monkeypatch').setattr('sys.stdin', io.StringIO('abcdef\nabc123')) >>> strip_prefix() def 123 """ sys.stdout.writelines(Stripper.strip_prefix(sys.stdin).lines) autocommand.autocommand(__name__)(strip_prefix) jaraco.text-3.11.1/jaraco/text/to-dvorak.py000066400000000000000000000001671436506465100205400ustar00rootroot00000000000000import sys from . import layouts __name__ == '__main__' and layouts._translate_stream(sys.stdin, layouts.to_dvorak) jaraco.text-3.11.1/jaraco/text/to-qwerty.py000066400000000000000000000001671436506465100206050ustar00rootroot00000000000000import sys from . import layouts __name__ == '__main__' and layouts._translate_stream(sys.stdin, layouts.to_qwerty) jaraco.text-3.11.1/mypy.ini000066400000000000000000000002321436506465100155250ustar00rootroot00000000000000[mypy] ignore_missing_imports = True # required to support namespace packages # https://github.com/python/mypy/issues/14057 explicit_package_bases = True jaraco.text-3.11.1/pyproject.toml000066400000000000000000000005721436506465100167510ustar00rootroot00000000000000[build-system] requires = ["setuptools>=56", "setuptools_scm[toml]>=3.4.1"] build-backend = "setuptools.build_meta" [tool.black] skip-string-normalization = true [tool.setuptools_scm] [tool.pytest-enabler.black] addopts = "--black" [tool.pytest-enabler.mypy] addopts = "--mypy" [tool.pytest-enabler.flake8] addopts = "--flake8" [tool.pytest-enabler.cov] addopts = "--cov" jaraco.text-3.11.1/pytest.ini000066400000000000000000000021201436506465100160550ustar00rootroot00000000000000[pytest] norecursedirs=dist build .tox .eggs addopts=--doctest-modules filterwarnings= # Ensure ResourceWarnings are emitted default::ResourceWarning # Suppress deprecation warning in flake8 ignore:SelectableGroups dict interface is deprecated::flake8 # shopkeep/pytest-black#55 ignore: is not using a cooperative constructor:pytest.PytestDeprecationWarning ignore:The \(fspath. py.path.local\) argument to BlackItem is deprecated.:pytest.PytestDeprecationWarning ignore:BlackItem is an Item subclass and should not be a collector:pytest.PytestWarning # tholo/pytest-flake8#83 ignore: is not using a cooperative constructor:pytest.PytestDeprecationWarning ignore:The \(fspath. py.path.local\) argument to Flake8Item is deprecated.:pytest.PytestDeprecationWarning ignore:Flake8Item is an Item subclass and should not be a collector:pytest.PytestWarning # shopkeep/pytest-black#67 ignore:'encoding' argument not specified::pytest_black # realpython/pytest-mypy#152 ignore:'encoding' argument not specified::pytest_mypy jaraco.text-3.11.1/setup.cfg000066400000000000000000000025551436506465100156610ustar00rootroot00000000000000[metadata] name = jaraco.text author = Jason R. Coombs author_email = jaraco@jaraco.com description = Module for text manipulation long_description = file:README.rst url = https://github.com/jaraco/jaraco.text classifiers = Development Status :: 5 - Production/Stable Intended Audience :: Developers License :: OSI Approved :: MIT License Programming Language :: Python :: 3 Programming Language :: Python :: 3 :: Only [options] packages = find_namespace: include_package_data = true python_requires = >=3.7 install_requires = jaraco.functools jaraco.context >= 4.1 importlib_resources; python_version < "3.9" autocommand inflect more_itertools [options.packages.find] exclude = build* dist* docs* tests* [options.extras_require] testing = # upstream pytest >= 6 pytest-checkdocs >= 2.4 pytest-flake8; \ # workaround for tholo/pytest-flake8#87 python_version < "3.12" # workaround for tholo/pytest-flake8#87 flake8 < 5 pytest-black >= 0.3.7; \ # workaround for jaraco/skeleton#22 python_implementation != "PyPy" pytest-cov pytest-mypy >= 0.9.1; \ # workaround for jaraco/skeleton#22 python_implementation != "PyPy" pytest-enabler >= 1.3 # local pathlib2; python_version < "3.10" docs = # upstream sphinx >= 3.5 jaraco.packaging >= 9 rst.linker >= 1.9 furo sphinx-lint # tidelift jaraco.tidelift >= 1.4 # local [options.entry_points] jaraco.text-3.11.1/tox.ini000066400000000000000000000014331436506465100153450ustar00rootroot00000000000000[tox] envlist = python minversion = 3.2 # https://github.com/jaraco/skeleton/issues/6 tox_pip_extensions_ext_venv_update = true toxworkdir={env:TOX_WORK_DIR:.tox} [testenv] deps = setenv = PYTHONWARNDEFAULTENCODING = 1 commands = pytest {posargs} usedevelop = True extras = testing [testenv:docs] extras = docs testing changedir = docs commands = python -m sphinx -W --keep-going . {toxinidir}/build/html python -m sphinxlint [testenv:release] skip_install = True deps = build twine>=3 jaraco.develop>=7.1 passenv = TWINE_PASSWORD GITHUB_TOKEN setenv = TWINE_USERNAME = {env:TWINE_USERNAME:__token__} commands = python -c "import shutil; shutil.rmtree('dist', ignore_errors=True)" python -m build python -m twine upload dist/* python -m jaraco.develop.create-github-release