Saravanan666/pypi-org huggingface dataset:
Package: py-doccle
py-doccleRetrieve documents from Doccle with an easy to use interfaceExample usage# Import the libraryfromdoccleimportdoccle# Create a new connector object. Make sure to safely store and retrieve your credentials (don't hardcode them!)docs=doccle.Connector('<your-doccle-username>','<your-doccle-password>')# Get a list of the 5 latest documents available in your Doccle account that are marked as new# Arguments are optional. When left empty, all documents will be listed.docs.get_documents(only_new=True,max_docs=2)# This will yield the following dictionary (limited to 1 for documentation purposes):{'documents':[{'sender':'<Name of the sender>','name':'<document name in Doccle>','publish_date':'<Date that the document has been published in Doccle>','document_type':'<Type of document. For example, an invoice','file_url':'<File URL>','file_name':'<Filename as saved in Doccle>','mime_type':'<MIME type, for example application/pdf>','payment_info':{'amount_to_pay':'<Amount to pay as stated on the invoice, if applicable>','sender_bic':'<BIC of the sender, if applicable>','sender_iban':'<IBAN of the sender, if applicable>','payment_reference':'<Payment reference on the invoice, if applicable>','payment_status':'<Payment status of the invoice, if applicable>'}}]}
Package: pydoc-fork
pydoc_forkA fork of pydoc to optimize it for generating, on a build server, html documentation for a python library you wroteLess ambitious than the very goodpdoc3and easier to use
thanSphinxInstallationRequires Python 3.8+pipinstallpydoc_fork# or virtual environment accesspipenvinstallpydoc_fork# WARNING- installation by pipx will only allow for doc generation of the python standard library!pipxinstallpydoc_forkUsage# Generate HTML for all modules and submodules from source codepydoc_forkmy_module--outputdocs--document_internals# Generate HTML for a module that is importable, e.g. syspydoc_forksys--outputdocsDocsMotivationPrior ArtTODOpydoc_fork documented in several ways:pydoc_forkPyccoPyDoctorpdoc3mkdocstringssphinxCreditsForked frompydoc in python 3.10.That code is governed by the cpythonlicenseI picked a MIT license, but I'm no lawyer, the cpython license probably governs in any conflict.
Package: pydocgen
PyDocGenAutomatically generate docstrings and documentation for your Python modules!Installationpip install pydocgenUsagePydocgen currently will accept a Python module file, it will support packages in the near futurepydocgen --help         #View all options
pydocgen -i file_nameFeaturesEasy to use, quick way to document your codeInput module file will automatically be decorated with docstrings (under development)Only need to fill in variable and function descriptionAutomatic type inference!Documentation files will be generated automatically (current supports HTML)
Package: pydocker
pydockerEasy generator Dockerfile for humansLet's use power of python for generate dockerfile!

Advantages:
    - all features from python: variables, multiline strings, code reuse.
    - keep all your code in one file [bash, python, conf, ...]
    - generate many docker files from one template [testing, production, ]
    - generate sequence [Dockerfile.debian => Dockerfile.python => Dockefile.yourapp, ...]
    - or if you not expert in sed, awk - you can use python for modify conf files : )easy code, easy costomizeInstall# sudo apt-get install python-setuptools && sudo easy_install pip
pip install -U pydockerUsing# Dockerfile.pyimportsysimportloggingimportpydocker# github.com/jen-soft/pydockerlogging.getLogger('').setLevel(logging.INFO)logging.root.addHandler(logging.StreamHandler(sys.stdout))classDockerFile(pydocker.DockerFile):"""   add here your custom features   """d=DockerFile(base_img='debian:8.2',name='jen-soft/custom-debian:8.2')d.RUN_bash_script('/opt/set_repo.sh',r'''cp/etc/apt/sources.list/etc/apt/sources.list.copy

cat>/etc/apt/sources.list<<EOLdeb     http://security.debian.org/ jessie/updates maindeb-src http://security.debian.org/ jessie/updates maindeb     http://ftp.nl.debian.org/debian/ jessie maindeb-src http://ftp.nl.debian.org/debian/ jessie maindeb     http://ftp.nl.debian.org/debian/ testing mainEOLapt-keyadv--keyserverkeyserver.ubuntu.com--recv-keys04EE7237B7D453EC
apt-getclean&&apt-getupdate''')d.EXPOSE = 80d.WORKDIR = '/opt'# d.ENTRYPOINT = ["/opt/www-data/entrypoint.sh"]d.CMD = ["python", "--version"]d.build_img()# >_ console:python3Dockerfile.py
dockerimagesAlternative uage:install from repo (without pip)F=$(python -c "import site; print(site.getsitepackages()[0]+'/pydocker.py')")
sudo wget -v -N raw.githubusercontent.com/jen-soft/pydocker/master/pydocker.py -O $Fwithout any installation:try:fromurllib.requestimporturlopen# python-3exceptImportError:fromurllibimporturlopen# python-2exec(urlopen('https://raw.githubusercontent.com/jen-soft/pydocker/master/pydocker.py').read())#d=DockerFile(base_img='debian:8.2',name='jen-soft/custom-debian:8.2')# ...Helpful if you need just build imgnot required installation#!/usr/bin/env python# -*- coding: utf-8 -*-try:frompydockerimportDockerFile# pip install -U pydockerexceptImportError:try:fromurllib.requestimporturlopen# python-3exceptImportError:fromurllibimporturlopen# python-2#exec(urlopen('https://raw.githubusercontent.com/jen-soft/pydocker/master/pydocker.py').read())#importsysimportlogginglogging.getLogger('').setLevel(logging.INFO)logging.root.addHandler(logging.StreamHandler(sys.stdout))classMyDockerFile(DockerFile):"""   add here your custom features   """#d=MyDockerFile(base_img='debian:8.2',name='jen-soft/debian:8.2')# ...Helpful if you need share your Dockerfile.pyLicenseThis work is dual-licensed underApache License 2.0andMIT License.
You can choose between one of them if you use this work.
Package: pydockercompose
pydockercomposeDescriptionThis package is a python package for generating Docker Compose file.
It contains two classes :DockerCompose : It represents docker-compose file.
In this version, it supports adding the following parameters:versionservicesvolumesnetworksService: This class represent docker compose service.
In this version, Service class supports adding the following parameters:container_nameimagebuildenvironmentrestartportsvolumesnetworksulimitslinksdepends_oncommandentrypointnetwork_modeTo find out more about these parameters, you can checkdocker-composedocumentation.UsecaseIn this example we usedpydockercomposepackage to generatedocker-compose.ymlfor :ElasticSearch serviceElasticSearch Client service that will be built using Dockerfile.import pydockercompose
  import os,sys

  def generate_elastic_docker_compose_file():
      docker_compose = DockerCompose(version="3.3")
  
      # Create ElasticSearch service.
      elastic_svc = Service(container_name="es",
                            image="elasticsearch:7.13.3",
                            restart="on-failure",
                            ports=["9200:9200"],
                            networks=["es-network"],
                            volumes=["es-data:/usr/share/elasticsearch/data"],
                            environments=["discovery.type=single-node"])
      elastic_svc.set_ulimits("memlock", {"soft": -1, "hard": -1})
  
      # Create ElasticSearch Customer service.
      cmd = "while [ 1 -e 1 ]; do curl 'http://es:9200/' && sleep 3 ; done"
      with open("Dockerfile", "w") as dockerfile:
          dockerfile.write("FROM alpine:3\nRUN apk add curl\nCMD "+cmd)
      customer_svc = Service(container_name="es-customer",
                             build=".",
                             restart="on-failure",
                             depends_on=["es"],
                             networks=["es-network"])
  
      # Add services to DockerCompose object.
      docker_compose.add_service("es", elastic_svc)
      docker_compose.add_service("es-customer", customer_svc)
  
      # Add the network es-network
      docker_compose.add_network("es-network", {"driver": "bridge"})
  
      # Add the volume es-data
      docker_compose.add_volumes("es-data", {"driver": "local"})
      return docker_compose
  
  
  if __name__ == '__main__':
      generate_elastic_docker_compose_file().to_yaml()
      os.system("docker-compose up")
Package: py-docker-gadgets
py-docker-toolsSome convenience tools for managing docker containers in pythonpy-docker-gadgets is a very compact set of tools for working with docker containers in python. Its API exposes
a very simple command to spin up a container and then shut it down.Super Quick Startrequirements:python3install through pip:$ pip install py-docker-toolsExample UsageHere’s a very basic example of how this could be used:fromdocker_gadgetsimportstart_service,stop_servicestart_service("test-postgres",image="postgres",env=dict(POSTGRES_PASSWORD="test-password",POSTGRES_USER="test-user",POSTGRES_DB="test-db",),ports={"5432/tcp":8432},)stop_service("test-postgres")
Package: pyDockingOrg
smallworld_api2.1Rewritten version of Matteo Ferla's unofficial python API to SmallWorld (https://github.com/matteoferla/Python_SmallWorld_API)Please make sure you are allowed to use this interface in the same way that you'd do for Matteo Ferla's API. It interacts withhttps://sw.docking.org/.Updates:Callback-driven requestsThreading for handling volume searchDefault 3-attempt retry strategy to tackle the random HTTP 502This version is not thread safe. Only one process can use this class at a time.withEnamine()asenamine:mols=enamine.search_smiles(['O=C(C)Oc1ccccc1C(=O)O','C=C(Cl)CNC(=O)C1(CC)CCC1'],remove_duplicates=True)print(mols)Please note thathttps://sw.docking.org/now provides a new REST API which should be usd instead. This version should be updated to it. The new interface sends results using a single query (instead of two that we use here with the Hit List IDs), and also alows querying multiple Smiles in one go.
Package: pydockter
Dockter: the doctor for your DockerfilesThe objective of Dockter is to make your Dockerfiles better, it will make sure that your Dockerfiles:build secure imagesbuild smaller imagesbuild fasterfollow best practicesare pretty formattedDevOps lifecycleTypically, a CI/CD pipeline consists of roughly the following steps:lint codebuild Docker imagerun tests in Docker imagescan image for vulnerabilities (hopefully)push image to registrydeploy imageDockterfits into the first stage and aims to prevent building an image that exposes credentials or contains
vulnerabilities, which at the bare minimum saves CI/CD minutes.Separate processes like container registry scanning will also run, but they may run only after an image has been pushed,
potentially already exposing a vulnerable image to the public.What makes Dockter special?Good question,Dockteris the byproduct of a much bigger product,GitLab AI Assist, as a first starting point,
Dockerfiles were chosen. A parser was developed to fully parse Dockerfiles in a format that is designed for machine
learning. In order to train ML models, there is a need to create a large, rich dataset and in order to do that a good
analysis of Dockerfiles is needed. Hence, the creation ofDockter. It will start improving your Dockerfiles from day 1
but will become much more powerful in the future, eventually it will automatically create Dockerfiles for you.No telemetryNo worries, your Dockerfiles remain private,Dockterwon't share any telemetry with GitLab, perhaps at some point in
time when machine learning models would benefit from user feedback, the option to provide anonymous feedback may be,
with plenty of user awareness and opt-in, introduced.Dynamic parserThe parser behindDockterhas been designed with data and ML in mind, it supports parsing of all Docker instructions
and adds support for comments, both actual comments and commented out code.The parser also supports dynamic analysis, it's context aware, example:COPY./appIf a static analysis was performed, it would approve the above instruction,Dockterhowever will actually list the
files that are in.and analyze them against known files to contain credentials, but also filter against your.dockerignorefile.UsageThere are a couple of ways you can useDockter:LocalCI/CDIt is suggested to always use both, but at least run it where you are actually building and publishing your images.Local usageYou will need to installDockterfrompippipinstall--upgradedockter--extra-index-urlhttps://gitlab.com/api/v4/projects/36078023/packages/pypi/simple
dockter-dpath/to/DockerfileIf you want more information you can either run it in verbose mode or ask to explain a specific rule# Explain rule dfa001docker-edfa001# Run in verbose mode (this will be a lot of text)dockter-v-dpath/to/DockerfileYou can also use docker:dockerrun-it-v$(pwd):/appregistry.gitlab.com/gitlab-org/incubation-engineering/ai-assist/dockter/dockter:latestdockter-ddocter.DockerfileCI/CDUsage in GitLab CI example:dockter:image:registry.gitlab.com/gitlab-org/incubation-engineering/ai-assist/dockter/dockter:lateststage:lintscript:-dockter -d Dockerfile
Package: pydocktors
MasterDeveloppmentWhat is it ?On top of docker, pydocktors is a simple way to declare a decorator to start and shutdown a docker container.Why to use it ?You can use it anywhere you want in your python code ! This include test and code…For example, if you have a application that require a database (for example, MySQL or Neo4J) but you don’t want to install the database globally on your system, you can use the docker decorator !Or you may need to load a application such as Nginx or Eureka when running your code locally without installing it, this docker decorator is made for you !ExamplesAll of them are also available in theexamples. Each example are designed to be independent.Starting a Nginx with a your content and your configuration:@docktors.docker(
    inject_arg=True,
    image='nginx',
    ports=[(80, 8080)],
    volumes=[
        (TARGET_DIR, '/usr/share/nginx/html', 'ro'),
        (NGINX_CONF, '/etc/nginx/nginx.conf', 'ro')
    ],
    wait_for_port=8080,
)
def main(container):
    logger.info(
        'Nginx container with id %s is %s. Visit http://localhost:8080/',
        container.id, container.status
    )FAQWhy this name ?Because it’s the contraction of 3 famous words :python,dockeranddecoratorsHow did it came from ?It will be a shame if a told you that I didn’t take inspiration from other Open Source project…
In fact, as a Java developper, I was aware of this 2 projects :docker-junit-rulejunit5-dockerBut after some research, I wonder why there was no python decorator already made to run docker in python scripts.
So, for my needs, I decided to do one and to share it !I hope that it will be helpful for you to.Authors :Patrick AllainLicense :MIT
Package: pydocless
# pydoclessLibrary for turning your python docstrings into Markdown documentation.Note this should not be used as a substitute for good documentation, but as an addition.The style is intended to look similar to Python's standard library API docs.### Usage:From the command line:```pydocless config.json > module_doc.md```Or from within a python environment:```from pydocless import pydoclessmd_text = pydocless(config)```The config object should be a dictionary:```{"module": "module_name",    # Module should be available within the python environment"includes": [],             # List of regexes for what to include. By default nothing is included"excludes": []              # List of regexes for what to exclude. By default everything is excluded}```
Package: pydoclite
pydoclitepydoclite is the python api for doclite. More info on doclite can be found herehttps://github.com/haibeey/docliteInstallationpip install pydocliteExamplefrom pydoclite import doclite

d = doclite.Doclite.Connect(b"doclitetest.db")
baseCollection = d.Base()

for i in range(10): 
    baseCollection.Insert({"a":1})

print(baseCollection.FindOne(1))
baseCollection.DeleteOne(2)

print(baseCollection.Find({"a":1}))
baseCollection.Delete({"a":1})

print(baseCollection.Find({"a":1}))

d.Close()
Package: pydoc-markdown
Pydoc-Markdown 📃Pydoc-Markdown is a tool to create Python API documentation in Markdown format. Instead of executing your Python
code like so many other documentation tools, it parses it usingdocspecinstead.→ Go to the Documentation 📘Table of ContentsInstallation 📦Features 🌟News 📢4.7.0 (Undeprecating YAML configuration)4.6.0 (Novella integration)Contributing to Pydoc-Markdown 🤝Questions / Need help? 🤔Projects using Pydoc-Markdown 📚Installation 📦You can install Pydoc-Markdown using Pipx:$ pipx install pydoc-markdownIf you plan on using theNovellaintegration, you may want to install it as:$ pipx install novella
$ pipx inject novella pydoc-markdown[novella]You need at least Python 3.7 to run Pydoc-Markdown. The Python version compatibility of the package you are looking to
generate documentation for is irrelevant.Features 🌟Understands multiple documentation styles (Sphinx, Google, Pydoc-Markdown specific) and converts them to properly
formatted MarkdownCan parse docstrings for variables thanks todocspec(#:block before or string literal after the statement)Generates links to other API objects per the documentation syntax (e.g.#OtherClassfor the Pydoc-Markdown style)Configure the output using a YAML file orpyProject.toml, then you're only one command away to generate the
documentation in Markdown formatOr useNovellato tightly integrate with static site generators like MkDocs and Hugo with with additional
features such as Markdown pre-processingNews 📢4.7.0 (Undeprecating YAML configuration)Many users prefer the YAML configuration over the usingNovella, which is why starting with4.7.0, the YAML
style configuration is officially un-deprecated and will continue to be supported.4.6.0 (Novella integration)Starting with4.6.0, development focuses on integrating withNovellaand use it as a replacement for
tool-specific renderers thus far provided directly by Pydoc-Markdown (i.e. integrations with MkDocs, Hugo and
Docusuraus). Such integrations are/will be provided by Novella instead.With the Novella integration, you can now place generated API content in Markdown format inline with your
existing Markdown documentation source files using@pydoctags. Check out theDocumentationfor more
information on how to use Pydoc-Markdown with Novella.The old style of using Pydoc-Markdown with a YAML or PyProject configuration to generate files and kick off the
build is now deprecated but will be maintained for the foreseeable future (at least until the next major version
bump). It is strongly recommended to migrate your existing projects to using the Novella build backend.Contributing to Pydoc-Markdown 🤝All contributions are welcome! Check out theContribution Guidelines.Questions / Need help? 🤔Feel free to open a topic onGitHub Discussions!Projects using Pydoc-Markdown 📚An incomplete list of projects that use Pydoc-Markdown to generate their API documentation. Feel free to open a
pull request to add your project to this list!CosmPyhaystack by deepsettensorchord/envdtqdm
Package: pydocmd
pydocmdpydocmd generates Python Module / script documentation in the Markdown (md)
format. It was written to automatically generate documentation that can be put
on Github or Bitbucket.It is as of yet not very complete and is more of a Proof-of-concept than a
fully-fledged tool. Markdown is also a very restricted format and every
implementation works subtly, or completely, different. This means output
may be different on different converters.Author: Ferry Boenderferry.boender@gmail.comVersion: 0.1Copyright: Copyright 2014, Ferry BoenderLicense: MIT (expat) LicenseUsage./pydocmd file.py > file.mdExample outputhttps://github.com/fboender/pydocmd/wiki/Example-output-1https://github.com/fboender/pydocmd/wiki/Example-output-2
Package: pydoc-quarto
pydoc-quartoInstallpipinstallpydoc_quartoUsage!pydoc_quarto-husage: pydoc_quarto [-h] lib dest_dir

Generate Quarto Markdown API docs

positional arguments:
  lib         the name of the python library
  dest_dir    the destination directory the markdown files will be rendered into

options:
  -h, --help  show this help message and exitExampleThis will generate markdown files for therequestslibrary:!pydoc_quartorequests_test_dir/!ls_test_dir/adapters.qmd     compat.qmd       hooks.qmd        status_codes.qmd
api.qmd          cookies.qmd      models.qmd       structures.qmd
auth.qmd         exceptions.qmd   packages.qmd     utils.qmd
certs.qmd        help.qmd         sessions.qmd
Package: pydocstring
Python package for autogenerating python docstrings, built on top ofParso.This project can be wrapped by an editor extension to provide docstrings as autocompletion or in response to a shortcut command.StatusReady for basic use - SupportsGoogle,Numpy, andreSTdocstring formats, and it’s pretty simple to create your own formatter.Types are able to be inferred for some things, but if they can’t be worked out ‘TYPE’ is just inserted instead.Doesn’t support more complicated things like converting between styles or updating docstrings.FutureCheck the issues for any more, but the nice-to-haves are:Docstring insertion for a whole fileUpdating docstrings for methods with changed paramenters/exeptions/TypesConversion between docstring stylesDocsDocumentation is onRead The DocsAPIFor integration with editors, there’s a really simple api avaialble (just a single call), check out the docs for more on that.Downloadpydocstring is onPyPIand can be installed with pip:pipinstallpydocstringDevelopmentTesting/Coverage is automanted withtox. Pull requests are welcome.
Package: pydocstringformatter
PydocstringformatterA tool to automatically format Python docstrings to follow recommendations fromPEP 8andPEP 257(or other supported style
guides.)SeeWhat it doesfor currently supported auto-formatting.RationaleThis project is heavily inspired bydocformatter.When this project was starteddocformatterdid not meet all of the requirements thepylintproject had for its docstring formatter and
was no longer actively maintained (this has changed since then). Therefore, some
contributors ofpylintgot together and started working on our own formatter to
fulfill our needs.When asked we defined the objective of the tool as:"A docstring formatter that follows PEP8 and PEP257 but makes some of the more
'controversial' elements of the PEPs optional"Seethe original answer.As such, the biggest difference between the two is thatpydocstringformatterfixes
some of the open issues we found indocformatter. In general, the output of both
formatters (and any other docstring formatter) should be relatively similar.How to installpipinstallpydocstringformatterUsageClick herefor a
full Usage overview.ConfigurationPydocstringformatter will also read any configuration added to the[tool.pydocstringformatter]section of apyproject.tomlfile.For example:[tool.pydocstringformatter]write=trueexclude="**/my_dir/**,**/my_other_dir/**"# Or:exclude=["**/my_dir/**","**/my_other_dir/**"]strip-whitespaces=truesplit-summary-body=falsenumpydoc-section-hyphen-length=falseStylePydocstringformatter can be configured to use a specific style. The default ispep257but we support other styles as well. These can also be used at the same time. For
example with:pydocstringformatter --style=pep257 --style=numpydoc myfile.pyPre-commitPydocstringformatter can also be used as apre-commit hook.
Add the following to your.pre-commit-config.yamlfile:-repo:https://github.com/DanielNoord/pydocstringformatterrev:SPECIFY VERSION HEREhooks:-id:pydocstringformatterWhat it doesThe following examples show some of the changes pydocstringformatter will apply. For a
full overview of all potential changes you can check out theUsagepage which
shows an up to date list of all formatters and their description.# Bad'''my docstring'''"""    mymulti-line docstring      """"""my title===========my docstring"""# Good"""My docstring.""""""Mymulti-line docstring.""""""My title===========My docstring"""# With --summary-quotes-same-line# Bad"""Mymulti-line docstring"""# Good"""Mymulti-line docstring"""DevelopmentFor development and contributing guidelines please seeDevelopment.