Saravanan666/pypi-org huggingface dataset:
Package: epicnumbers
epicnumbersA small tool I often used to convert a number into various other formatsUsage$pipinstallepicnumbers$epicnumbers<number>ExamplesConvert -100 into signed, unsigned, hex, printable and binary in different sized integers$ en -100
type      signed              unsigned  hex                  printable                         binary
------  --------  --------------------  -------------------  --------------------------------  -----------------------------------------------------------------------
8 bit       -100                   156  0x9c                 \x9c                              10011100
16 bit      -100                 65436  0xff9c               \x9c\xff                          11111111 10011100
32 bit      -100            4294967196  0xffffff9c           \x9c\xff\xff\xff                  11111111 11111111 11111111 10011100
64 bit      -100  18446744073709551516  0xffffffffffffff9cL  \x9c\xff\xff\xff\xff\xff\xff\xff  11111111 11111111 11111111 11111111 11111111 11111111 11111111 10011100Convert 0x100 into signed, unsigned, hex, printable and binary in different sized integers$ en 100h
type      signed    unsigned  hex    printable                         binary
------  --------  ----------  -----  --------------------------------  ----------
16 bit       256         256  0x100  \x00\x01                          1 00000000
32 bit       256         256  0x100  \x00\x01\x00\x00                  1 00000000
64 bit       256         256  0x100  \x00\x01\x00\x00\x00\x00\x00\x00  1 00000000Convert 100b (binary) into signed, unsigned, hex, printable and binary in different sized integers$ en 100b
type      signed    unsigned  hex    printable                           binary
------  --------  ----------  -----  --------------------------------  --------
8 bit          4           4  0x4    \x04                                   100
16 bit         4           4  0x4    \x04\x00                               100
32 bit         4           4  0x4    \x04\x00\x00\x00                       100
64 bit         4           4  0x4    \x04\x00\x00\x00\x00\x00\x00\x00       100Developmentinstallpoetry$ poetry install$ poetry shellRun tests$poetryrunpytestRun tool$poetryrunen100h
Package: epico
EpicoJust some epic python utilitiesFunctionsepico.pause()Pauses the terminal and waits for input to continue.epico.checktype(value, type)Checks if the value is, or can be converted to, the specified type.epico.dir.delete(path, recursive=False)Deletes the specified path. recursive is defaulted to false.epico.dir.create(path)Creates the specified directory.epico.file.create(filename, encoding=None)Creates the specified file. ecoding defaults to None.epico.file.append(filename, data, encoding=None)Appends data to analready existingfile.epico.file.write(filename, data, encoding=None)Overwrites data to analready existingfile.epico.file.delete(filename)Deletes the specified fileepico.file.exists(filename)Detects if a file exists, returns True or False.epico.file.read(filename, mode='s')Reads the contents of a file, returns a string normally, but if mode set to 'l' it becomes a listepico.thread.runfunc(function)Runs the specified function in a thread, and continues on in the code while that function is running
Package: epic-pandas
Epic pandas — Extra treats for the data-orientedWhat is it?Theepic-pandasPython library provides various utilities for working with data. Most are built
on top of thepandaslibrary, but some only requirenumpy. These are various functions and classes which
can be useful and helpful in almost any data-oriented project. Some allow for more efficiency and
flexibility in some common tasks, while others are just convenient. Also included is a package full of helpers
and treats for plotting withmatplotlib.Modulesalgorithm:Mostly statistical algorithms for working with binary data.create:Create a (potentially large) DataFrame or Series efficiently from an iterable.matplotlib:Package with easy plotting functions and other plotting utilities.networkx:Draw a networkx graph with labels and colors.numpy:Utilities for working withnumpy.parallel:Apply a function over a DataFrame or Series in parallel.sparse:TheSparseDataFrameclass — a CSR sparse matrix with anindexandcolumns.utils:General utilities, including functions for dumping and loadingpandasobjects, sampling,
displaying, and many more.
Package: epic-path
:sparkles: EpicPath :sparkles:A high Level Python Library to work with PathEpicPathis a SubClass ofPathfrompathlib.
This class aims to simplify high level operations with pathContext and historyI'm a Computing Student tired of creating again and again the same functions through all my projects to do the exact same things... :tired_face:
Indeed, in every of my projects I create files, delete them, create folders and delete themblablabla...
To solve this boring problem, I decided to create my own library that I can create one and only one time to use and reuse as many times as I wish to.
And because I'm trying to be nice to this cruel world I share thisEpicproject with all of you :heart:
So feel free to download it, use it and give feedback about thisepiccreation. :+1:DescriptionYou already knowPathfrom the librarypathlib. Well,EpicPathis all likePathbut in aEPICway :tada: .It is apseudosubclass ofPathbut consider it as a subclass, it supports all the methods and options of the original library.
It is also aos.PathLikeobject which allows you to use as you would want to:withopen(my_epic_path_object,'w')asf:f.write('This is epic !!!')Use itInstall itpipinstallepic-pathUse itfromepicpathimportEpicPathasEPathpath=EPath('f1','f2')# EpicPath('f1/f2')path2=path/'f3'# EpicPath('f1/f2/f3')path2+='_0'# EpicPath('f1/f2/f3_0')See the documentation:warning: Warnings :warning:BecausePathis build-in Python libraries, some other library
(likePILorskopt)
can have a specific behavior when the given filename is astror aPathobject.
Unfortunately, they don't support anEpicPathobject ... :cry: But no worries, it is still possible to give anEpicPathobject as aPathobject or astrobject using the properties.pathand.str:path=EPath('f1','f2')# EpicPath('f1/f2')weird_function(path.path)# Gives Path('f1/f2') to the functionweird_function(path.str)# Gives the string 'f1/f2' to the function
Package: epic-py
epic-py packageThis is the Python client for ePIC APIversion >= 3.0.0.FeaturesGet a PIDTo get a PID and its values, simply call thegetmethod. It returns aPidobject which containsprefix,suffix,
and its values indatavariable. Note that ifusernameandpasswordare not provided, the client can only get the
PID and its public readable values.Create a PIDTo create a PID, aPidobject must first be created with properdata, which is a list ofPidData(handle values).
Please see the example usage below for more details.There are 2 ways to create a PID:Call thecreatemethod: this method will throw an error in case the PID has already existed.Call thecreate_or_updatemethod: as the name suggested, if the PID has already existed, it will be updated
instead. This update overwrites the PID with new data.Update a PIDTo update a PID, aPidobject must first be created with properprefix,suffix, anddata.datais a list
ofPidData(handle values).Same as create, there are 2 ways to update a PID:Call theupdatemethod: this method will throw an error in case the PID does not exist.Call thecreate_or_updatemethod: if the PID already exists, it will be updated. This update overwrites the PID
with new data.Delete a PIDTo delete a PID, simply call thedeletemethod and pass the PID string as a parameter. This command does not guarantee
that the PID will be deleted. It depends on the policies of each prefix. Usually, theno-deletepolicy is enforced. If
that is the case, trying to delete a PID will lead to an error.Example usageSuppose one wants to create a PID with its content as follows:[{"parsed_data":"Test Publisher","type":"publisher"},{"parsed_data":"2021","type":"publicationYear","privs":"rw--"},{"parsed_data":{"identifier-Attribute":"DOI","identifier-Value":"10.123.456/789"},"type":"identifier"},{"parsed_data":{"resourceType-Value":"test"},"type":"resourceType"},{"parsed_data":{"creator":{"creatorName":"Triet Doan"}},"type":"creators"},{"parsed_data":{"title":{"title-Value":"Test title"}},"type":"titles"}]The following example code can be used:fromepic_pyimportEpicAPI,PidData,Pidpublisher=PidData(type='publisher',parsed_data='Test Publisher')publication_year=PidData(type='publicationYear',parsed_data='2021',privs='rw--')identifier=PidData(type='identifier',parsed_data={"identifier-Attribute":"DOI","identifier-Value":"10.123.456/789"})resource_type=PidData(type='resourceType',parsed_data={"resourceType-Value":"test"})creators=PidData(type='creators',parsed_data={"creator":{"creatorName":"Triet Doan"}})titles=PidData(type='titles',parsed_data={"title":{"title-Value":"Test title"}})# Create the PID objectprefix='my_prefix'pid=Pid(prefix=prefix,data=[publisher,publication_year,identifier,resource_type,creators,titles])# Create the clientepic_api=EpicAPI('<host>','<username>','<password>')# Create the PIDpid=epic_api.create(pid)# Get the PIDpid_response=epic_api.get(pid.pid_str)# Delete the PIDepic_api.delete(pid.pid_str)
Package: epics-appimage
EPICS AppImageThis project is intended to provide prebuilt EPICS base tools in the form
of AppImages for the end-users, for those who usually do not need to have the full
EPICS base built. Tools likesoftIoc,caget,caput,cainfo,camonitor,softIocPVA,pvget,pvput,pvinfo,pvmonitor, etc. could be used in the command line interface. More tools
will be included in future releases.User GuideInstallationOn an x86_64 machine, type in the Terminal withpip install epics-appimageto install the package.Alternatively, each AppImage can also be downloaded from the release page,chmod +x <AppImage>and run it. If only one AppImage is needed, downloadepics-base-tools-x86_64.AppImage.RunTypical EPICS base tools could be invoked by just typing the name in the
Terminal, e.g.softIoc,caget,caput, etc.One special command calledepics-base-toolsis built to be used as the
entry point for all the packaged tools, all packaged tools are sharing the
same libraries, thus this single AppImage is way more compact.Typeepics-base-toolsin the Terminal will output the usage message:Missingtheappname!
Usage:epics-base-tools-x86_64.AppImage-i-l-happ-name

RunthedeployedEPICSbasetools.

Availableoptions:-i,--infoEPICSbaseversion-l,--listAllavailableEPICSbasetoolsapp-nameNameofoneofthedeployedtools-h,--helpPrintthishelpandexit-v,--verbosePrintscriptdebuginfo

Examples:# use caget toolepics-base-tools-x86_64.AppImagecaget# create an alias for cagetaliascaget="epics-base-tools-x86_64.AppImage caget"epics-base-tools softIocis equivalent assoftIoc, the same applies to other tools.--listor-loption lists all packaged EPICS base tools, e.g.:epics-base-tools -loutputs:(26)appsareavailable:

acctstantelopeascheckcaConnTestcaEventRatecagetcainfocamonitorcaputcaRepeatercaswca_testcatimee_flexiocLogServermakeBptmsip2ppvcallpvgetpvinfopvlistpvmonitorpvputsoftIocsoftIocPVABuild AppImages from EPICS baseIn the Terminal, run:make bootstrap | tee -a log, editbootstrap.shas needed.
Package: epics-containers-cli
A simple CLI with shortcuts for common operations when developing epics-containers
projects.PyPIpip installepics-containers-cliSource codehttps://github.com/epics-containers/epics-containers-cliDocumentationhttps://epics-containers.github.io/epics-containers-cliReleaseshttps://github.com/epics-containers/epics-containers-cli/releasesSee theepics-containers tutorialsfor more information. In particular the noteshereTo learn more try the help# get global helpec--help# get help on the ioc namespaceecioc--help# use -v to show the underlying commands being executedec-vpsSeehttps://epics-containers.github.io/epics-containers-clifor more detailed documentation.
Package: epicsdbbuilder
This Python module is designed to make it easy to build complex EPICS databases
by writing a Python script.  While writing record templates the corresponding
dbd entries are checked to reduce the number of errors in the database.PyPIpip install epicsdbbuilderSource codehttps://github.com/dls-controls/epicsdbbuilderDocumentationhttps://dls-controls.github.io/epicsdbbuilderA simple example of the use of this library is the following:fromepicsdbbuilderimport*InitialiseDbd('/dls_sw/epics/R3.14.12.3/base/')SetTemplateRecordNames()a=records.ao('TEST')c=records.calc('CALC',CALC='A+B',SCAN='1 second',INPA=a.VAL)c.INPB=cWriteRecords('output.db')Seehttps://dls-controls.github.io/epicsdbbuilderfor more detailed documentation.
Package: epic-serialize
Epic serialize - Easy Python objects serializationWhat is it?Theepic-serializePython library provides a method for easily and efficiently serializing multiple Python objects
into a single file, and then deserializing them back in random-like access.Here's a quick example:fromepic.serializeimportSpocReader,SpocWriterwithSpocWriter("myfile.spoc")asspocw:spocw.write(map(str,range(10)))spocw.write("--done--")assertlist(SpocReader("myfile.spoc")[-3:])==["8","9","--done--"]The SPOC formatSpoc, or Serialized Python Objects Chunks, is a multi-serialization file format that allows
to easily serialize multiple Python objects into a file which later allows quick reading and slicing.Consider the case where a dict with 100M items is to be serialized to disk. By simply using pickle.dump,
for example, the entire serialization will be done first in memory, and only then written to file, which
may be slow and cause out-of-memory errors. In addition, it's sometimes desirable to serialize objects
one-by-one (for example, while traversing an iterator).In addition to serializing objects (in "chunks", as the name implies), Spoc also applies compression
before writing to disk, thus potentially saving a lot of space.The two main classes are SpocWriter, which can either create a new file or append to an existing one,
and SpocReader, which allows reading, iteration and random access via index or slice.SpocReader slices may also be passed to other process (they are picklable), which is useful when
dividing jobs over multiple slices of the same Spoc file.The SpocReader/SpocWriter classes fully support the 'with' statement, and this is the preferred syntax.Currently, the following serialization schemes are supported:pickle (builtin)dill (requires installation)Currently, the following compression algorithms are supported:zlib (builtin)bz2 (builtin)gzip (builtin)lzma (builtin)lz4 (requires installation)These parameters can be passed (by name or class) to the SpocWriter, but will only be used if
the file is new or overwritten (not appended to). SpocReader as well as SpocWriter, when used to append
to an existing file, interpret the serializer and compressor from the file's header.Usage examplesCreate new file with explicit serialization/compression:withSpocWriter(filename,serialization="pickle",compression="gzip")asspocw:foriteminitems:spocw.write(item)Open an existing file for appending:withSpocWriter(filename,append=True)asspocw:spocw.write(more_items)Read all items:withSpocReader(filename)asspocr:read_items=list(spocr)Read sliced items:sliced_items=list(SpocReader(filename)[10:-1])sliced_item=SpocReader(filename)[1000]
Package: epicserver
Epic ServerEpicMan Server is a SANS-IO Async application server that runs your code over
multiple 'Nodes'. This has the added effect of not being limited to a single
core for running your code and mitigating some of the effects of the GIL in
the cpython (and others) implementationWhile this is an Async Server this is NOT AsyncIO compatible and brings its
own abstractions for File, Network and locking in order to meet the latency
requirements imposed by its primary use case (Game engine that runs atop this
framework)*** NOTE: this is a Technology preview/Alpha release ***Only a single instance is likley to work at this time or 2 node clusters with
caveatsInternal and External APIs are in heavy fluxFeaturesPluggable IO enginesAutomatic Persistence of game featuresTransparent Inter-process messaging abstractionpython3 codebaseUses async/await (but is not AsyncIO compatible)pypy3 compatible for versions supporting the python3.8 specGetting StartedThe Full documentation is availablehere. The
examples below should give you a quick feel for management of a cluster and
what programming for epic server looks like.RequirementsPython 3.6 or newerLinux 5.x or newer (io_uring)liburing-dev (debian)liburing1 (debian)64bit CPU if using lmdb backendKernel headers may be required to compile the python io_uring moduleExamplesStarting a single or multiple node cluster is relatively simple as shown below.
All that is required is a simple script to bootstrap the Initial Entities. In
this example we use a simple test script called 'cluster.py' that is looked up
on PYTHONPATH. if using a script in your current directory then prepending
PYTHONPATH=. to the epic-server commands will ensure that this script can be
found correctly.$ python3 -m venv venv
$ venv/bin/pip install epicman-server
$ venv/bin/epic-server -vvv -l '[::1]:3030'
$ venv/bin/epic-server-start -vvv -b '[::1]:3030' cluster:startProgramming for epicman.serverThe following is taken from 'cluster:start' from the above example and simply
sends a value, has it incremented then passes the incremented value on to the
next entity to confirm that the RPC like interface worksfrom epicman.objects import EntityProxy, Entity, remote_spawn, remote_call
from epicman.syscalls import THREAD_SLEEP
from epicman.logging import log
import sys

TOTAL_COUNT = 1000

class _Test(Entity):
    @remote_call
    async def test(self, val):
        return val + 1
# this is a temporary work around pickle limitations and
# issues pickle has with things that are renamed
Test = EntityProxy(_Test)

async def start():
    count = 0
    for i in range(TOTAL_COUNT):
        count = await Test[i].test(count)

    log.info('Value: {count}', count=count)
    sys.exit()Stay up to dateTwitterXMPPWeb ChatDocsSRCNews
Package: epic-sklearn
Epic sklearn — An expansion pack for scikit-learnWhat is it?Theepic-sklearnPython library is a companion to the scikit-learn library for machine learning.
It provides additional components and utilities, which can make working within the scikit-learn
framework even more convenient and productive.The main difference in base-assumptions between scikit-learn and epic-sklearn is that epic-sklearn
has pandas as a dependency. Moreover, most epic-sklearn components support pandas objects (DataFrame
and Series) and "pass along" as much information as possible. For example, in most transformers,
if the features matrix is provided as a DataFrame, the transformed matrix will also be a DataFrame,
and the index (and columns, if applicable) will be preserved. There are also a few components specifically
designed for working only with pandas objects.Content Highlightscomposite:Classifiers acting on other classifiers.feature_selection:mutual_info:Calculation of conditional mutual information between a feature and the target given another
feature, and feature selection algorithms based on conditional mutual information.metrics:Metrics and scores for evaluating classification results and other data sets.neighbors:Utilities relevant for nearest neighbors algorithms.pipeline:Transformers for constructing transformation pipelines.Contains a transformer that splits
the samples based on a criterion, and applies different transformations on each sample group.plot:Plotting utilities.preprocessing:categorical:Transformers for encoding and processing categorical data.data:Transformers for binning and manipulating data distribution. Includes the
Yeo–Johnson transformation.general:General-purpose transformers (e.g. select DataFrame columns, apply a function in parallel,
generate features from an iterator).label:Utilities for encoding labels.utils:data:Generate random batches from data.general:Functions for input validation and normalization.kneedle:Implementation of the "Kneedle in a Haystack" algorithm.thresholding:A helper for setting and applying a threshold based on classification metrics.ContributorsThanks toYaron Cohenfor his contribution to this project.
Package: epicsmacrolib
epics-base compliant macro tools.What?Do you want epics-base compliant macro expansion, with all of its idiosyncracies?No? I didn’t think so. This is a really boring project and you probably don’t need it.Then why?This will be the future of the macro and IOC shell splitting tools inwhatrecord,
removing its reliance on Cython and epicscorelibs.Examplesmacros_from_stringfromepicsmacrolibimportmacros_from_stringmacros_from_string("A=5,  B=$(A=3)")# -> {'A': '5', 'B': '$(A=3)'}MacroContextfromepicsmacrolibimportMacroContextctx=MacroContext(use_environment=True)ctx.define(TEST="A")print(ctx.expand("TEST=$(TEST) SHELL=$(SHELL)"))# TEST=A SHELL=/bin/bashctx=MacroContext(use_environment=False)ctx.define_from_string("A=5,B=6")ctx.define(C="7")print(ctx.expand("$(A) $(B) ${C}${D=5} ${E}"))# -> 5 6 7 5 $(E)ctx=MacroContext(use_environment=False,show_warnings=True)ctx.define_from_string("A=5,B=6")ctx.define(C="7")print(ctx.expand("$(A) $(B) ${C}${D=5} ${E}"))# -> 5 6 7 5 $(E,undefined)ctx.define_from_string("A=5,B=$(B)")print(ctx.expand("$(A) $(B)"))# -> 5 $(B,recursive)withctx.scoped(A="10",B="0"):print(ctx.expand("$(A)"))# -> 10withctx.scoped(A="0"):print(ctx.expand("$(A)"))# -> 0print(ctx.expand("$(A)"))# -> 10split_iocsh_line(likeshlex.split)fromepicsmacrolibimportsplit_iocsh_linesplit_iocsh_line("dbLoadRecords > output_filename")# -> IocshSplit(#     argv=["dbLoadRecords"],#     redirects={1: IocshRedirect(fileno=1, name="output_filename", mode="w")},#     error=None,# )LicenseThe Python portions of this code is under a BSD-3 clause license
(LicenseRef-BSD-3-Clause-SLAC, seeLICENSE).
Portions of epics-base have been vendored insrcunder its original license
(seesrc/LICENSE).
Package: epicstore-api
epicstore_apiAn unofficial library to work with Epic Games Store Web API.InstallingPython 3.6 or higher is requiredTo install the library you can just run the following command:# Linux/macOSpython3-mpipinstall-Uepicstore_api# Windowspy-3-mpipinstall-Uepicstore_apiQuick Exampleapi=EpicGamesStoreAPI()namespace,slug=list(api.get_product_mapping().items())[0]first_product=api.get_product(slug)offers=[]forpageinfirst_product['pages']:ifpage.get('offer')isnotNone:offers.append(OfferData(page['namespace'],page['offer']['id']))offers_data=api.get_offers_data(*offers)foroffer_datainoffers_data:data=offer_data['data']['Catalog']['catalogOffer']developer_name=''forcustom_attributeindata['customAttributes']:ifcustom_attribute['key']=='developerName':developer_name=custom_attribute['value']print('Offer ID:',data['id'],'\nDeveloper Name:',developer_name)You can find more examples in the examples directory.ContributingFeel free to contribute by creating PRs and sending your issuesLinksDocumentation
Package: epic-trials
epic-trialsTrials for the EPIC labs of the Concrete, Soil and MaterialFree software: MIT licenseDocumentation:https://epic-trials.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2023-01-05)First release on PyPI.