Saravanan666/pypi-org huggingface dataset:
Package: processtracker
ProcessTracker - PythonData integration process management made easy!This is the Python implementation of the ProcessTracker framework.  ProcessTracker builds a standard framework that is
tool agnostic.  If you are working with data integration/cleansing processes within Python (i.e. using PySpark, Pandas, etc.)
then this framework can help manage dependencies between processes and provide auditing capabilities without having to
parse logs or build your own framework.To learn more about how to use ProcessTracker, please check out our documentation onReadTheDocs!Want to contribute?  Check out our contributors guide!Found a bug?  Have an idea for an improvement?  Submit it into ourIssues tracker
Package: process-tracker
process-trackerProcess tracker enables tracking creation of child processes.Usage:importprocess_tracker;process_tracker.install()importospid1=os.fork()pid2=os.fork()pid3=os.fork()ifpid1andpid2andpid3:print(process_tracker.children())Prints a list of tuples with(pid, create_time)for each process.create_timecan be used to confirm that the current process (if any) with
the given pid is the same as the original. For example:importprocess_trackerimportpsutildefget_create_time(ctime):boot_time=psutil.boot_time()clock_ticks=os.sysconf("SC_CLK_TCK")returnboot_time+(ctime/clock_ticks)processes=[]forpid,create_timeinprocess_tracker.children():try:p=psutil.Process(pid=pid)exceptpsutil.NoSuchProcess:continueifp.create_time()==get_create_time(create_time):processes.append(p)# processes now has the list of active child processes# psutil itself does a check before sensitive operations that the# active process create time is the same as when the Process object# was initialized.forpinprocesses:p.terminate()LimitationsOnly tracks children spawned from dynamically-linked executables.Relies onLD_PRELOADso will not work for setuid/setgid executables.DevelopmentBasicpython -m venv .venv.venv/bin/python -m pip install toxMake changes.venv/bin/python -m toxDebugging C buildAvoids overhead of making sdistAs abovemake c-buildDebugging issues from sub-processgdb debugging of sub-processes.As abovemake debugDebugging tests without rebuildAs above.venv/bin/python -m pip install . .[dev]Thenpip install . && pytestwhen rebuild is neededpytestwhen only tests changedReleasedocker run \
    -e REAL_UID=$(id -u) \
    -e REAL_GID=$(id -g) \
    -v "$PWD/scripts/build.sh:/build.sh" \
    -v "$PWD:/src" \
    dockcross/manylinux1-x64 \
    sh -c 'cd /src && env "PATH=/opt/python/cp37-cp37m/bin:$PATH" /build.sh'
Package: processtransformer
Process TransformerTransformer Neural Model for Business Process Monitoring TasksTasksNext Activity PredictionTime Prediction of Next ActivityRemaining Time PredictionInstallpip install processtransformerUsageimport argparse
import tensorflow as tf
from processtransformer import constants
from processtransformer.data import loader
from processtransformer.models import transformer

parser = argparse.ArgumentParser(description="Process Transformer - Next Activity Prediction.")
parser.add_argument("--dataset", required=True, type=str, help="dataset name")
parser.add_argument("--task", type=constants.Task, 
    default=constants.Task.NEXT_ACTIVITY,  help="task name")
parser.add_argument("--epochs", default=1, type=int, help="number of total epochs")
parser.add_argument("--batch_size", default=12, type=int, help="batch size")
parser.add_argument("--learning_rate", default=0.001, type=float,
                    help="learning rate")

# Load data
data_loader = loader.LogsDataLoader(name = args.dataset)

(train_df, test_df, x_word_dict, y_word_dict, max_case_length, 
    vocab_size, num_output) = data_loader.load_data(args.task)

# Prepare training examples for next activity prediction task
train_token_x, train_token_y = data_loader.prepare_data_next_activity(train_df, 
    x_word_dict, y_word_dict, max_case_length)

# Create and train a transformer model
transformer_model = transformer.get_next_activity_model(
    max_case_length=max_case_length, 
    vocab_size=vocab_size,
    output_dim=num_output)

transformer_model.compile(optimizer=tf.keras.optimizers.Adam(args.learning_rate),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])

transformer_model.fit(train_token_x, train_token_y, 
    epochs=args.epochs, batch_size=args.batch_size)See complete code examples within the github repository for other tasks, including preparing raw process data for transformer model.ToolsTensorflow >=2.4
Package: process-uptime
Installation$[sudo]pipinstallprocess-uptimeExamplesstarttime (datetime)fromprocess_uptimeimportgetstarttimegetstarttime()# current process starttimegetstarttime(42)# starttime by piduptime (intseconds)fromprocess_uptimeimportgetuptimegetuptime()# current process uptimegetuptime(42)# uptime by pidreadme42.com
Package: processVCF
Copyright (c) 2021 M. BrownPermission 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.Description: # processVCFUtility script to help open and parse a vcf file.
Returns a python object that contains the VCF’s information parsed into pandas dataframes.Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3.6
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Natural Language :: English
Requires-Python: >=3.6
Description-Content-Type: text/markdown
Package: process-wrapper
Process Wrapper is a simple module that executes a command-line style
program via a context manager. This is useful if you want your script
to do something that relies on a background process.This module is conceived because of a need to automate the setup and
teardown of the Django server when running Robotframework tests. Sample
usage would look like this:#!/usr/bin/env python

import robot
from processwrapper import run_process

with run_process('python manage.py runserver'):
    robot.run('blackbox_test.robot')Right now, the process being run is forcefully terminated with a SIGKILL
or equivalent signal on context exit. Caution is advised.To installRun in command line:pip install process-wrapperDependenciespsutilTested CapabilitiesKills parent and child processes on exitHandles in-context exceptions: It still kills the called process and its childrenProcesses are properly cleaned up when in-context exceptions occurProcess wrapper will do nothing if it encounters a Process Not Found exception for the parent process and raise all othersTested to work in win32 and linux2 platformsTest CommandCommand used to test the module. Includes line and branch coverage:py.test processwrapper/tests --cov processwrapper --cov-report term-missing --pep8Thanks tojung rhewfor providing
thebasis of process teardown code that I used
Package: processy
# processy### Description*Processy* is a wrapper around `Popen` similar to the now built-in `subprocess.run()` function, which was added in Python3.5. Prior to 3.5 there was no simple sane function to run subprocesses. This is why I made *processy*.  The current implementation of `subprocess.run()` still won't let you print and return stdout at the same time. *Processy*  remains useful for that.### `processy.run()````pythondef run(cmd: Union[list, str],verbose: bool = True,return_stdout: bool = False,raise_err: bool = False,**popen_kwargs) -> CompletedProcess:"""@cmd: The Popen command. If it's a string shlex is used to split it.@return_stdout: Returns the output from stdout.@verbose: Print the output to stdout if True. If False call runs quite.@raise_error: If subprocess return code is not 0."""# ...```### `CompletedProcess`Since Python3.5 *processy* uses the return object `CompletedProcess` that was added to the subprocess module. It's almost identical to processy's old `ProcResult` object.'```pythonCompletedProcess(args: Union[str, list]returncode: intstdout: Optiona[Union[str, bytes]]stderr: Optiona[Union[str, bytes]])```
Package: procfs
Easy to use>>> from procfs import Proc
>>> proc = Proc()

>>> proc.loadavg
{'average': {1: 0.0, 5: 0.0, 15: 0.0},
 'entities': {'current': 1, 'total': 117},
 'last_pid': 3068}

>>> proc.net.dev.eth1.receive.bytes
117997558

>>> proc.meminfo.MemFree
57044

>>> proc.net.snmp.Udp
{'InDatagrams': 3394, 'OutDatagrams': 3399, 'RcvbufErrors': 0,
 'InErrors': 0, 'SndbufErrors': 0, 'NoPorts': 4}Process information>>> proc.self
<Process 3068: python>

>>> proc.self.parent
<Process 17423: bash>

>>> proc.self.uptime
datetime.timedelta(0, 346, 380262)

>>> proc.processes
<Processes: [<Process 1: init>, <Process 2: kthreadd>, <Process 3: migration/0>, <Process 4: ksoftirqd/0>, <Process 5: watchdog/0>, <Process 6: migration/1>, <Process 7: ksoftirqd/1>, <Process 8: watchdog/1>, <Process 9: events/0>, <Process 10: events/1>, ...]>
>>> len(proc.processes)
110

>>> proc.processes.cmdline('(vim|ssh)')
<Processes: [<Process 2956: vim>, <Process 3044: vim>, <Process 3136: vim>, <Process 10422: sshd>, <Process 10440: sshd>, <Process 10504: sshd>]>

>>> proc.processes.uid(1000)
<Processes: [<Process 1120: bash>, <Process 2593: bash>, <Process 2956: vim>, <Process 3044: vim>, <Process 3093: python>, <Process 10504: sshd>, <Process 10505: bash>, <Process 10875: screen>, <Process 10876: screen>, <Process 12908: bash>, ...]>

>>> proc.processes.user('pmuller').cmdline('python')[0]
<Process 3093: python>Linksdocumentationgithub
Package: procfs3
procfs3-------procfs3 is a python3 version of procfs <https://github.com/pmuller/procfs>.It was converted using 2to3 with some manual fixes and some tests thrown in.To run the tests, run::python3 tests/doctests.pyEasy to use```````````::>>> from procfs import Proc>>> proc = Proc()>>> proc.loadavg{'average': {1: 0.0, 5: 0.0, 15: 0.0},'entities': {'current': 1, 'total': 117},'last_pid': 3068}>>> proc.net.dev.eth1.receive.bytes117997558>>> proc.meminfo.MemFree57044>>> proc.net.snmp.Udp{'InDatagrams': 3394, 'OutDatagrams': 3399, 'RcvbufErrors': 0,'InErrors': 0, 'SndbufErrors': 0, 'NoPorts': 4}Process information```````````````````::>>> proc.self<Process 3068: python>>>> proc.self.parent<Process 17423: bash>>>> proc.self.uptimedatetime.timedelta(0, 346, 380262)>>> proc.processes<Processes: [<Process 1: init>, <Process 2: kthreadd>, <Process 3: migration/0>, <Process 4: ksoftirqd/0>, <Process 5: watchdog/0>, <Process 6: migration/1>, <Process 7: ksoftirqd/1>, <Process 8: watchdog/1>, <Process 9: events/0>, <Process 10: events/1>, ...]>>>> len(proc.processes)110>>> proc.processes.cmdline('(vim|ssh)')<Processes: [<Process 2956: vim>, <Process 3044: vim>, <Process 3136: vim>, <Process 10422: sshd>, <Process 10440: sshd>, <Process 10504: sshd>]>>>> proc.processes.uid(1000)<Processes: [<Process 1120: bash>, <Process 2593: bash>, <Process 2956: vim>, <Process 3044: vim>, <Process 3093: python>, <Process 10504: sshd>, <Process 10505: bash>, <Process 10875: screen>, <Process 10876: screen>, <Process 12908: bash>, ...]>>>> proc.processes.user('pmuller').cmdline('python')[0]<Process 3093: python>Links`````* `github <http://github.com/galini/procfs3>`_
Package: procfs-sensor
# Procfs-SensorThe Proc Filesystem Sensor is a tool that monitor the CPU usage of cgroup via
the linux’s proc filesystem.
It usepidstatto retreive the percentage of CPU usage of each process.
It then use the/sys/fs/perf_eventdirectory to find the appartenance of
processes to cgroup.The sensor need the cgroup version 1. The version 2 is not supported yet.# AboutProcfs Sensor is an open-source project developed by the [Spirals research
group](https://team.inria.fr/spirals) (University of Lille 1 and Inria).The documentation is not available yet.## ContributingIf you would like to contribute code you can do so through GitHub by forking the
repository and sending a pull request.
You should start by reading the [contribution guide](https://github.com/powerapi-ng/procfs-sensor/blob/main/contributing.md)When submitting code, please check that it is conform by usingpylintandflake8with the configurations files at the root of the project.## AcknowledgmentsProcfs Sensor is written in [Python](https://www.python.org/) (under [PSF
license](https://docs.python.org/3/license.html)).
It also use [pidstat](https://github.com/sysstat/sysstat)MIT LicenseCopyright (c) 2021 PowerAPIPermission 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.
Package: procgraph
ProcGraph (“processing graph”) is a Python library for rapid prototyping
of pipelines for logged and realtime data.See documentation at:http://andreacensi.github.com/procgraph/Installation notesThe only painful part to install is mencoder and ffmpeg.### Installation (OS-X)(June 2015, OS X 10.10) Download from here:http://evermeet.cx/pub/ffmpeg/### Installation (Ubuntu 12.04)Needsudo apt-get install x264 libavcodec-extra-53’to install necessary codecs.You can see a list of supported presets by using: ‘x264 –help’.Other packages that might be helpful:libavdevice-extra-52  libavfilter-extra-0 libavformat-extra-52 libavutil-extra-49
libpostproc-extra-51 libswscale-extra-0.### Installation Ubuntu 14.04 - June 2015Install mplayer and mencoder:sudo apt-get install mencoder mplayerFor installing ffmpeg: (June 2015)sudo add-apt-repository ppa:mc3man/trusty-media
sudo apt-get update
sudo apt-get install ffmpeg gstreamer0.10-ffmpeg
Package: procgraph-z6
ProcGraph (“processing graph”) is a Python library for rapid prototyping
of pipelines for logged and realtime data.See documentation at:http://andreacensi.github.com/procgraph/Installation notesThe only painful part to install is mencoder and ffmpeg.### Installation (OS-X)(June 2015, OS X 10.10) Download from here:http://evermeet.cx/pub/ffmpeg/### Installation (Ubuntu 12.04)Needsudo apt-get install x264 libavcodec-extra-53’to install necessary codecs.You can see a list of supported presets by using: ‘x264 –help’.Other packages that might be helpful:libavdevice-extra-52  libavfilter-extra-0 libavformat-extra-52 libavutil-extra-49
libpostproc-extra-51 libswscale-extra-0.### Installation Ubuntu 14.04 - June 2015Install mplayer and mencoder:sudo apt-get install mencoder mplayerFor installing ffmpeg: (June 2015)sudo add-apt-repository ppa:mc3man/trusty-media
sudo apt-get update
sudo apt-get install ffmpeg gstreamer0.10-ffmpeg
Package: procin
procin# Release
Check out [for every release](https://cookiecutter-pypackage.readthedocs.io/en/latest/pypi_release_checklist.html#for-every-release)
# Testlibrary to interface to commands that generate outputFree software: MIT licenseDocumentation:https://procin.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-07-24)First release on PyPI.
Package: procleaner
Linux kernelThere are several guides for kernel developers and users. These guides can
be rendered in a number of formats, like HTML and PDF. Please read
Documentation/admin-guide/README.rst first.In order to build the documentation, usemake htmldocsormake pdfdocs.  The formatted documentation can also be read online at:https://www.kernel.org/doc/html/latest/There are various text files in the Documentation/ subdirectory,
several of them using the Restructured Text markup notation.Please read the Documentation/process/changes.rst file, as it contains the
requirements for building and running the kernel, and information about
the problems which may result by upgrading your kernel.
Package: proclets
From just a single state machine, to a whole universe of interacting objects,
TheProcletis a modelling technique which bridges the worlds of mathematical theory
and software architecture.This package gives you a Pythonic implementation of Proclets and their related structures.StatusThis project was new in 2021 and is under continuous development.DocumentationDocumentation is included in the package. You can find both plain text and HTML:pip download procletsIf you’d rather browse online, you can do sohere.
Package: proclib
Proclib is a high level wrapper/abstraction around the standard
library subprocess module, written in Python, with proper piping
support which aims to simplify the usage of Unix utilities right
from Python and help the developer focus on the commands and not
the code which calls the commands.Overviewproclib.api.spawn(cmd)Given a string or list making up commandscmd, return
a Response object which is the result of piping the commands,
i.e. they are run inparallel. Thedataparameter can be
used to configure the data passed in to the initial process.
Usage example:>>> from proclib.api import spawn
>>> r = spawn('yes | head')
>>> r.stdout.read()
'y\ny\ny\ny\ny\ny\ny\ny\ny\ny\n'
>>> r.close()
>>> r.history[0].explain_signal()
{'action': 'kill',
 'description': 'write on a pipe with no readers',
 'id': 13,
 'signal': 'SIGPIPE'}Streaming support is built-in- that is that the stdout of
any process can be streamed lazily instead of read and stored
in memory all in one go. Also, any kind of iterable can be
piped to the process:def gen():
    yield 'hi\n'
    yield 'ho\n'

r = spawn('cat', data=gen())
assert r.out.split() == ['hi', 'ho']
Package: proclip
ProclipA powerful templating tool for your projects.CPython versions 3.7 through 3.11-dev and PyPy versions 3.7 through 3.9 are officially supported.Windows, MacOS, and Linux are all supported.InstallationTo install the latest stable version of Proclip, use the following command:pipinstallproclipYou can also install the latest development version using the following command:pipinstallgit+https://github.com/parafoxia/proclipYou may need to prefix these commands with a call to the Python interpreter depending on your OS and Python configuration.Creating clipsYou can create clips using the following command:clipnew<name><file>[-ooutput-dir]Useclip new --helpfor more information on what each option does.To create a clip, first create a file, and code it how you want it to look.
You can also include variables that Proclip can replace when you paste the clip.
Variables use a slightly modified Jinja syntax, which additionally allows for default values to be provided.Take the following example:class{{cls=MyClass}}:def__init__(self,n:int)->None:self.{{attr}}=n@propertydefnumber(self)->int:returnself.{{attr}}if__name__=="__main__":c={{cls}}(5)print(c.number)In this example, you have two distinct variables:cls, andattr.clshas a default value (MyClass), so when you paste the clip, that value will be used if you don't supply one.
Note that only the first instance ofclsneeds a default value.
Keep in mind that only one default value can be assigned per variable; others will be overwritten.Pasting clipsYou can paste clips using the following command:clippaste<name>[-iinput-dir][-ooutput][-vvariables]Useclip paste --helpfor more information on what each option does.You can use the-vflag to insert values for variables when pasting.
Variables that were not assigned default values when the clip was created need a value supplied to them.
Default values can be overridden if you choose to do so.Variables are passed as strings, where a value needs to be assigned to a key (for example,key=value).
You can use commas to separate multiple variable assignments (key1=value1,key2=value2).
In the above example, passing-v "attr=n"produces the following file:classMyClass:def__init__(self,n:int)->None:self.n=n@propertydefnumber(self)->int:returnself.nif__name__=="__main__":c=MyClass(5)print(c.number)ContributingContributions are very much welcome! To get started:Familiarise yourself with thecode of conductHave a look at thecontributing guideLicenseThe Proclip module for Python is licensed under theBSD 3-Clause License.
Package: procmanager
ProcManagerAn command line to start and stop long-running processes.UsageRun some program (python -m http.server) and keep track of it under the namehttpd:procmgrstart-nhttpdpython-mhttp.serverTo list currently running processes:procmgrlistTo remove track of no-longer running processes:procmgrcleanTo stop a running process:procmgrstop<name>if not specified, name defaults to the process name (first argument of start)To watch the output of some process:procmgrwatch<name>Installationpip install procmanager
Package: procmaps
procmaps.pyPython bindings forprocmaps.rs.Installationprocmaps.py is available for Python 3.7+ via pip:$pipinstallprocmapsUsageimportprocmaps# also: from_path, from_strmaps=procmaps.from_pid(9001)formap_inmaps:# `in` can be used to check address inclusionif0xfeedfaceinmap_:print("this map contains some address!")# see dict(map_) for all attributesprint(f"{map_.begin_address}:{map_.pathname}")Developmentprocmaps.pyusesPyO3for binding Rust
to Python. It usesMaturinto coerce the
Rust build into apipand PyPI-compatible wheel.Assuming that you have Rust and a relatively recent Python 3 installed,
the following should just work:$makedevelop
$sourceenv/bin/activateA local build ofprocmaps.pywill be created and installed in your virtual environment.
Package: proc-mem-monitor
Process Memory MonitorA Python application for monitoring total memory usage of commands matching specified
pattern. It displays the information either on Tkinter GUI if DISPLAY is availabe or
on stdout if it's launched from a text-only termainl.InstallationOSproc-mem-monitor has been tested on CentOS 7.8 and Ubuntu 16.04.PythonThis program requires Python 3.6 or newer to run.Ubuntu 16.04The default Python on Ubuntu 16.04 is version 3.5. Run the commands below to
install Python 3.6sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt-get update
sudo apt-get install python3.6 python3.6-venv python3.6-tkRedhat/CentOS 7.8The default Python on CentOS 7.8 is already version 3.6. You only need to
install Python Tkinter.sudo yum install python36-tkinterCreate and activate a Python3 virtual environmentpython3.6 -m venv venv
. venv/bin/activateInstall xbutil GUI as a regular userpip install proc_mem_monitorInstall xbutil GUI as a contributorInstall required Python packagespip install -r requirements.txtInstall proc-mem-monitor in development Modepython setup.py developRun Process Memory MonitorRun the command below from the Python virtual environment created aboveproc_mem_monitorSnapshotsProcess Memory Monitor on Tkinter GUIPublish xbutil_gui to PyPI./scripts/publish-pypi.shThe following modules may need to be upgraded or installed:pip install --upgrade pip
pip install twine