Saravanan666/pypi-org huggingface dataset:
Package: pyclay-annotation-utils
annotation_utilsUtilities that are used for assisting with making annotated data.InstallationInstall From Github#Forinstallingfromthemasterbranch(stable)pip install https://github.com/cm107/annotation_utils/archive/master.zip#Forinstallingfromthedevelopment(latest)pip install https://github.com/cm107/annotation_utils/archive/development.zipNote: If you want to reinstall all dependencies while installing, use the following commands instead:#Forinstallingfromthemasterbranch(stable)pip install --upgrade --force-reinstall https://github.com/cm107/annotation_utils/archive/master.zip#Forinstallingfromthedevelopment(latest)pip install --upgrade --force-reinstall https://github.com/cm107/annotation_utils/archive/development.zipInstall From Pypipip install pyclay-annotation_utilsNote: The github package is updated more often than the pypi package.Note: In order to overwrite an older version with the latest version, use the following command instead.# Warning: This will automatically upgrade the dependencies too.pipinstall--upgradepyclay-annotation_utilsInstall From SourceThis package can also be installed locally.git clone https://github.com/cm107/annotation_utils.gitcd annotation_utilspip install -e .Update BuildIf you change the code and want to re-build the package, do the following../build_package.shImportant NoteOutdated/obsolete code has been moved to theannotation_utils/oldfolder as of version 0.2.The latest COCO utilities can be found underannotation_utils/coco.The latest Labelme utilities can be found underannotation_utils/labelme.The latest dataset management utilities can be found underannotation_utils/dataset.NDDS annotation parsing related classes can be found underannotation_utils/ndds.UsageThere is not any official documentation about usage yet, but for usage examples you may refer to thetest folder.COCO Utility Usage ExamplesLabelme Utility Usage ExamplesDataset Utility Usage ExamplesNDDS Utility Usage ExamplesNDDS to COCO Conversion ExamplesDocumentsThe following documents have been written for further explanation.Praparing Datasets For Training/Validation
Package: pyclblas
###DescriptionPyCLBLAS is a wrapper for the clBLAS library.  This module can be used to call BLAS routines on OpenCL enabled devices from Python.###Resources* Documentation is available at [ReadTheDocs.org](https://pyclblas.readthedocs.io/en/latest/index.html)* Linux binaries and source packages are available at the project's [PyPI page](https://pypi.python.org/pypi/pyclblas/)###Installation:* sudo pip install pyclblas* Installation Requirements (Non-Python):* OpenCL* [clBLAS](https://github.com/clMathLibraries/clBLAS) (Available in Ubuntu repos)* [SWIG](https://www.swig.org/) (Available in Ubuntu and CentOS repos)* Installation Requirements (Python Packages):* [pyopencl](https://github.com/pyopencl/pyopencl/)* [numpy](https://github.com/numpy/numpy)
Package: pyclblast
PyCLBlast: Python wrappers for the tuned OpenCL BLAS library CLBlastThis Python package provides a straightforward wrapper for CLBast based on PyOpenCL. CLBlast is a modern, lightweight, performant and tunable OpenCL BLAS library written in C++11. It is designed to leverage the full performance potential of a wide variety of OpenCL devices from different vendors, including desktop and laptop GPUs, embedded GPUs, and other accelerators. CLBlast implements BLAS routines: basic linear algebra subprograms operating on vectors and matrices.Seethe CLBlast repositoryandthe CLBlast websitefor more information about CLBlast.PrerequisitesNon-Python requirements:OpenCLCLBlastGetting startedAfter installing OpenCL and CLBlast, simply use pip to install PyCLBlast, e.g.:pip install --user pyclblastTo start using the library, browse theCLBlastdocumentation or check out the PyCLBlast samples provided in thesamplessubfolder.For developers, install CLBlast andcython(e.g. in a Python3 virtualenv):pip install CythonAnd then compile the bindings from this location using pip:pip install .Detecting CLBlastThe CLBlast library should be present and detectable to your system, to successfully install the PyCLBlast bindings. In some systems, this is done automatically. But if the CLBlast library cannot be detected, the PyCLBlast installation will fail. To ensure detection, one can apply either of the following:Add the CLBLast root directory to the environment path.Create the environment variableCLBLAST_ROOTthat holds the path to the CLBLast root directory.Define thecmakevariablesCMAKE_PREFIX_PATHor theCLBLAST_ROOTvariable that point to the CLBlast root directory, as:pip install . -C skbuild.cmake.args="-DCMAKE_PREFIX_PATH=/root/path/to/clblast"Create the environment variableCLBlast_DIRthat holds the path to the directory where either of theCLBlastConfig.cmakeorclblast-config.cmakefiles reside.Note that the aforementioned environment variables should be set only during the installation of PyCLBlast and can be unset during normal use.Testing PyCLBlastThe main exhaustive tests are the main CLBlast test binaries. Apart from that, you can also run the PyCLBlast smoke tests from thetestsubfolder, e.g. as follows:python -m unittest discoverHow to release a new version on PyPiFollowingthe guide, in essence doing (after changing the version number insetup.py):python3 -m build
python3 -m twine upload --repository pypi dist/pyclblast-1.4.0.tar.gz
# use '__token__' as username and supply the token from your PyPi account
Package: pycle
The pycle toolboxPycle stands for PYthon Compressive LEarning; it is a toolbox of methods to perform compressive learning (also known as sketched learning), where the training set is not used directly but first heavily compressed; this allows to learn from large-scale datasets with drastically reduced computational resources.Pycle is now stable (version1.0), butstill under development, so don't hesitate to report bugs or other difficulties encountered with the toolbox.Contents of this repo:For documentation:A "Guide" folder with semi-detailed introductory guide to this toolbox.A series of "DEMO_i" jupyter notebooks, that illustrate some core concepts of the toolbox in practice.If you're new here, I suggest you start by opening either of those items first to get a hang of what this is all about.The code itself, located in the "pycle" folder, structured into 3 main files:sketching.pycontains everything related to building a feature map and sketching a dataset with it;compressive_learning.pycontains the actual learning algorithms from that sketch, for k-means and GMM fitting for example;utils.pycontains a diverse set of functions that can be useful, e.g., for generating synthetic datasets, or evaluating the learned models through different metrics and visualization utilities.Note that if you want to use the core code ofpycledirecltly without downloading this entire repository, you can install it directly from PyPI by typingpip install pycleCiting this toolbox:If you publish research using this toolbox, please follow this link for to get citation references (e.g., to generate BibTeX export files)
Package: pycleanarch
# PyCleanArch - Python Clean ArchitectureA simple Python toolkit to work with Clean Architecture for Web. This code base is inspired by [liasis from Johnny Well](https://github.com/johnnywell/liasis/).Use this toolkit to build better applications implementing [Clean Architecture from Robert C. Martin](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)## Requirementspython3 (3.7+)pip3## InstallUsingpip (pip3)`python pip install pycleanarch `Usingpipenv:`python pipenv install pycleanarch `Usingpoetry:`python poetry add pycleanarch `## Usage`python # to use in your project eg.: from pycleanarch.core.domain import Entity `## Concepts:This project use some concepts like DDD, Clean Architecture, TDD, Hexagonal Architecture, Onion Architecture, and much more. See some links below.### Articles[The Clean Architecture by Robert C. Martin (Uncle Bob)](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)[The Onion Architecture by Jeffrey Palermo](https://jeffreypalermo.com/2008/07/the-onion-architecture-part-1/)[Hexagonal Architecture by Alistair Cockburn](https://web.archive.org/web/20180408231827/http://alistair.cockburn.us/Hexagonal+architecture)### Books[Clean Architecture: A Craftsman’s Guide to Software Structure and Design by Robert C. Martin (Uncle Bob)](https://amzn.to/2MFJX8O)[Domain-Driven Design Distilled by Vaughn Vernon ](https://amzn.to/35tM74g)[Domain Driven Development by Eric Evans (2003)](https://amzn.to/2M8c9Cn)[Domain Driven Development by Eric Evans (2003) - Portuguese](https://amzn.to/2IKgnOq)## ContributingI encourage you to contribute to this project! Join us!Trying to report a possible security vulnerability? [Open a issue now.](https://github.com/wallacesilva/pycleanarch/issues/new)Everyone interacting in this project and its sub-projects’ codebases, issue trackers, chat rooms, and mailing lists is expected to follow the code of conduct (building, but respect everyone).## LicenseMIT License
Package: pycleancodecli
Python Comment-out Code Cleaner CLIPython Code Cleaner CLI (pycleancodecli) is a tool designed to clean up Python files by removing comments and unnecessary whitespace. It helps in maintaining a cleaner, more readable codebase.PrerequisitesPython 3.6 or higherInstallationInstall directly from PyPI:pipinstallpycleancodecliUsageTo use pycleancodecli, run the following command in your terminal:pycleancodecliFILE_PATHS[OPTIONS]Options:--dry-run: Display the changes without applying them.Example:pycleancodecliexample.py--dry-runThis will clean up example.py and show the cleaned code without overwriting the original file.Project Structurepycleancodecli: Main project folder.cleaner: Contains the core cleaning functionality.tests: Contains test cases for the tool.test_cleaner.py: Test script for the cleaner module.setup.py: Setup script for packaging and distribution.ImprovementsFuture improvements and features can include:Enhanced comment detection and removal logic.Options for different cleaning levels based on user preference.Feel free to contribute to the project by submitting pull requests or opening issues for bugs and feature requests on GitHub.
Package: pycleanup
# pycleanClean up your working directory.# Why?Everyone uses commands like```{r, engine='bash', count_lines}find . -name \*.pyc -delete```or```{r, engine='bash', count_lines}find . -name "*.pyc" -exec rm -f {} \;```but I often switch me OS from Linux to Windows. Fist I would wrote differentscrips, but a python package is much nicer.# InstallUses pip to install.```{r, engine='bash', count_lines}pip install pyclear```# UsesAs command-line tool.```{r, engine='bash', count_lines}pyclear --help```or```{r, engine='bash', count_lines}python -m pyclear --help```As python function```{r, engine='python', count_lines}from pyclean.func import cleanupdir = '.'args = {'cache': True, 'egg': True}cleanup(dir, args)```
Package: pycleartool
Python Extension to ClearCasePycleartool is a Python extension that provides a high-level interface toIBM
Rational ClearCase, suitable for scripting solutions.  Pycleartool links
directly against ClearCase libraries, preventing you from extra-processing
usually encountered in scripts that interact with ClearCase, where the
creation of a cleartool subprocess is required to handle a ClearCase request.
See theREADMEfile for more information.
Package: pyclesperanto-assistant
pyclesperanto assistantAssistedpyclesperantoscripting injupyternotebooks.Download full movieUsageWhen hacking jupyter notebooks, add this import statement:frompyclesperanto_assistant.ipythonimport*Afterwards, when executingwhat_next()in a cell, the cell will be replaced by suggestions derived from theCLIJ online documentation.
For making good suggestions, it analyses the code in the notebook cell above.InstallationYou can installpyclesperanto_assistantviapip:pip install pyclesperanto_assistantContributingContributions are very welcome.LicenseDistributed under the terms of theBSD-3license,
"pyclesperanto_assistant" is free and open source softwareIssuesIf you encounter any problems, pleaseopen a thread on image.scalong with a detailed description and tag@haesleinhuepf.
Package: py-cli
android自动构建python脚本零、配置fromsetuptoolsimportsetupsetup(author='handy',author_email='cvdnn@foxmail.com',url='https://github.com',license='Apache v2.0',description='python lang units',name='py-cli',version='1.0',packages=['xcli'],install_requires=['androguard','oss2','requests'])一、准备环境pipinstalltwinepytest二、PyPi在Pypi上注册账号，并创建API tokens，复制证书到~/.pypirc[pypi]
  username = __token__
  password = pypi-xxxxxx设置权限chmod600~/.pypirc三、发布SDKpythonsetup.pysdist
twineuploaddist/*四、应用# 安装SDKpipinstallpy-cli# 运行测试用例pytest-s
Package: pyclibrary
PyCLibrary includes 1) a pure-python C parser and
2) an automation library that uses C header file definitions to simplify the
use of c bindings. The C parser currently processes all macros, typedefs,
structs, unions, enums, function prototypes, and global variable declarations,
and can evaluate typedefs down to their fundamental C types +
pointers/arrays/function signatures. Pyclibrary can automatically build c
structs/unions and perform type conversions when calling functions via
cdll/windll.
Package: pyclibrary-aagallag
PyCLibrary includes 1) a pure-python C parser and
2) an automation library that uses C header file definitions to simplify the
use of c bindings. The C parser currently processes all macros, typedefs,
structs, unions, enums, function prototypes, and global variable declarations,
and can evaluate typedefs down to their fundamental C types +
pointers/arrays/function signatures. Pyclibrary can automatically build c
structs/unions and perform type conversions when calling functions via
cdll/windll.
Package: pyclick
pyclickThis is a library for generating human-like mouse movements.
The movements are based on the concept of bezier curve:https://en.wikipedia.org/wiki/B%C3%A9zier_curveSimple Example:from pyclick import HumanClicker

# initialize HumanClicker object
hc = HumanClicker()

# move the mouse to position (100,100) on the screen in approximately 2 seconds
hc.move((100,100),2)

# mouse click(left button)
hc.click()You can also customize the mouse curve by passing a HumanCurve to HumanClicker. You can control:number of internal knots, to change the overall shape of the curve,distortion to simulate shivering,tween to simulate acceleration and speed of movement
Package: pyclicksign
PyClicksignImplementação open source de um cliente para consumo da API rest para criação
e assinaturas de documentos disponibilizada pela empresa Clicksign.A é Clicksing uma plataforma de assinatura eletrônica de documentos que atende
aos requisitos de integridade, autenticidade e não-repúdio da legislação
brasileira. Saiba mais emhttps://www.clicksign.com.A Candango Open Source Group não é responsável pelo serviço disponibilizado
pela Clicksign, e sim, desenvolve um cliente para consumo do serviço da API
rest desta empresa.Seguindo documentação publicada emhttps://developers.clicksign.com/.LicenseApache License V2.0Copyright © 2021-2022 Flávio Gonçalves Garcia
Package: pyclickup
A python wrapper for the ClickUp APIQuick startInstallation# install pyclickuppipinstallpyclickupBasic UsagefrompyclickupimportClickUpclickup=ClickUp("$ACCESS_TOKEN")main_team=clickup.teams[0]main_space=main_team.spaces[0]members=main_space.membersmain_project=main_space.projects[0]main_list=main_project.lists[0]tasks=main_list.get_all_tasks(include_closed=True)
Package: pyclics-clustering
pyclics-clusteringVarious clustering algoriths packaged as plugins for CLICS.Connected ComponentsAs implemented in thenetworkxpackage.Hierarchical Link Clustering (HLC)The algorithm is described inAhn YY, Bagrow JP and Lehmann S: Link communities reveal multiscale complexity in networks.Nature466, 761 (2010).The implementation is copied fromTamás Nepuszwith
slight modifications to work with CLICS networks.Louvain Community DetectionThe algorithm is described inVincent D Blondel, Jean-Loup Guillaume, Renaud Lambiotte, Renaud Lefebvre: Fast unfolding of communities in large networks.Journal of Statistical Mechanics: Theory and Experiment10(2008), P10008 (12pp).We use the implementation byThomas Aynaud.Label PropagationThe algorithm is described inCordasco, G., & Gargano, L.: Community detection via semi-synchronous label propagation algorithms.
In Business Applications of Social Network Analysis (BASNA),
2010 IEEE International Workshop on (pp. 1-8). IEEE.As implemented in thenetworkxpackage.
Package: pyclier
PyclierA python CLI framework base onargparse, supporting: config system, command-completion, rich-text log, friendly help message prompt and so on.Note: This project was created withCookiecutterand thezhangxianbing/cookiecutter-pypackageproject template.Featuressupport friendly help message promptsupport configuration file parsing systemsupport easy-to-use interface for building complex CLI programsupport rich-text and flexible log system (base onrich)support command auto-completion (base onargcomplete)support auto generating and updating usage (based onauto-usage)support updating CLI programQuick StartInstallationpipinstallpyclierFor using auto completion, you should first installargcompleteand the activate it:pipinstallargcomplete
activate-global-python-argcompleteThen add the following lines in your setup.py:fromsetuptoolsimportsetupsetup(...)# post installationfrompyclier.setuptoolsimportcopytree,enable_completecommand=sys.argv[-1]ifcommand=="install":copytree("conf",appdirs.user_config_dir(prog_name))enable_complete(prog_name)importpippip.main(["install",".","-U","--no-index"])Run democdpyclier-demo&&makeinstall# then refresh your bash environmentpyclier-h
Package: pyCLiFF
pyCLiFF, the Python Command Line Filter Framework is a simple tool designedto remove the boilerplate and annoyances from command line filters.In *nix there is a tradition of using pipes to connact many programs togetherwhen processing data. The programs are usually very single transformations ontext.  This text may come in from a file or from stdin, and leave via file orstdout. This pattern is ubiquitous in *nix programming, allowing for verypowerful command line usage.   Such tools frequently (mostly?) follow the thispattern:1. Setup/handle arguments2. Mainloop:A. Read line from input file (stdin or file)B. Process that line in some wayC. Output the result of processing.3. Cleanup and exit.The above pattern results in many programs with a large portion of boilerplatecode, and a few dozen lines of unique application code. pyCLiFF is an attemptto cover all the parts of a command line filter that are not unique. (Usuallythis means step B above).
Package: py-cli-interaction
Python CLI Interaction LibraryIntroductionThis library is created for simplifyINPUT/OUTPUTprocedure when generatingYAML/JSONconfigurations for daemon services.Get StartedTODO: complete this exampleYou can follow this example.resolution_sel=must_parse_cli_sel("Select color resolution",self.__COLOR_RESOLUTION_CANDIDATES__,default_value=self.__COLOR_RESOLUTION_DEFAULT_SEL__)fps_sel=must_parse_cli_sel("Select color fps",self.__COLOR_FPS_CANDIDATES__,default_value=self.__COLOR_FPS_DEFAULT_SEL__)format_sel=must_parse_cli_sel("Select color format",self.__COLOR_FORMAT_CANDIDATES__,default_value=self.__COLOR_FORMAT_DEFAULT_SEL__)exposure_sel=must_parse_cli_int("Set exposure [ 0 - 10000 ], -1 for auto exposure",min=-1,max=10001,default_value=-1)
Package: pyclilib
pyclilibPython Library to create CLI tools using Subject-Verb-Object pattern# [my-namespace] not yet implemented
my-cmd [my-namespace] my-action my-resource [pos_args] [--options]Quickstart 1: CLI without Namespacespip install pyclilibCreate a hello world CLIimportclilib@clilib.decorator.resourceclassMyResource():@clilib.decorator.verbdefget(self):print("Hello world")clilib.init("mycli")clilib.run("mycli")Run your program$ python example.py get my-resource
Hello worldQuickstart 2: CLI with argspip install pyclilibCreate a hello world CLI with args.importclilib# Under the hood, clilib uses argparse.# the @arg decorator uses its "add_argument" method@clilib.decorator.resource@clilib.decorator.arg("--environment","-e",type=str,default="dev")classMyResource():@clilib.decorator.verb@clilib.decorator.arg("name",type=str)defget(self,args):print(f"Get:{args.name},{args.environment}")@clilib.decorator.verbdeflist(self,args):print(f"List:{args.environment}")clilib.init("mycli")clilib.run("mycli")Run your program$ python example.py get my-resource Foo -e stage
Get: Foo, stage

$ python example.py list my-resource
List: devQuickstart 3: CLI with Namespaces (not implemented yet)pip install clilibCreate the runner,example.pyimportclilibclilib.init("mycli")clilib.run("mycli")Namespaces are sub-packages of an expected localnamespacepackage$ mkdir -p namespace namespace/my-namespace
$ touch namespace/__init__.py namespace/my-namespace/__init__.py# namespace/my-namespace/__init__.pyimportclilib@clilib.decorator.resourceclassMyResource():@clilib.decorator.verbdefget(self):print("Hello World")Run your program$ python example.py my-namespace get my-resource
Hello WorldNotesYou can either havecli namespace action resourceORcli action resourcein the futureRoadmapGlobal Config --PotentialNamespaceConditional ArgsCLI without resource ex.git initTODOHow to make log level configurable?
Since decorators run during "compile"(?) time, setting the level throughclilib.run("foo", logging.DEBUG)will set the level after the decorators do their thing.
Same story withclilib._log_level = logging.DEBUG
Package: pyclimacell
Python ClimaCell APIPython3.7+ package to access theClimaCell Weather APIBoth an async module (ClimaCellV4andClimaCellV3) and a synchronous module
(ClimaCellV3SyncandClimaCellV4Sync) are provided.Example CodefrompyclimacellimportClimaCellV4Syncapi=ClimaCellSync("MY_API_KEY",latitude,longitude)print(api.realtime(api.available_fields(timedelta(0))))print(api.forecast_nowcast(api.available_fields(timedelta(minutes=5))),start_time,timedelta_duration,timestep))FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-06-04)First release on PyPI.
Package: pyClimat
pyClimatClimat python package for analysising GCM model output and visualization. The package is written in a function based
(would be pivoted to OPP style in future development). The analysis module features climate variable extraction
and estimation of statistical long-term means and difference. Statistical tools like PCA or EOF analysis are included for specific
estimates and many other classical methods like testing, OLS estiates, etc.installationCan be installed by chećking the dependencies in pyClimat.yml (But it will be compiled afterwards for easy installatoin)The package would also be uploaded on pypi (which can be installed with pip install pyClimat or with the -e flag to install in edit mode)DocumentationThe docs folder contains all the dist for the documentation compilation (cd docs; make html)
The direct stable link would be shared shortlyExamplesThis package was adopted for all the visualization in the research study by Boateng et. al 2022 ( Impacts of surface uplift on regional climate)
The scripts can be located in the folderAlps