Saravanan666/pypi-org huggingface dataset:
Package: pycef
pycefA very simple CEF parser for Python 2/3I originally wrote this because I wasn't able to find very many good Python CEF parsers out there.  I did findone by Sooshiethat got me started (thanks for sharing, sir!), but I elected to produce my own.Theparsefunction takes a string containing a single CEF record and returns a dict containing the following keys, as defined in theCEF format documentation:CEFVersionDeviceVendorDeviceVersionDeviceEventClassIDNameSeverityIf there are anykey=valuepairs in the "extensions" section (and face it, pretty much every CEF record has these), they'll also be in the dict, with the dict key name the same as the CEF record's key name. If it could not recognize any CEF data, theparsefunction will returnNone.NOTE: Versions 1.10 and earlier used 'DeviceName' and 'DeviceSeverity' instead of just 'Name' and 'Severity'. Those old keys are still present in the returned dictionary for backwards-compatibility reasons, but are likely to be removed in the future without warning.Example UsageParsing a well-formatted CEF record>>>importpycef>>>cef='CEF:0|pycef|python CEF tests|1|2|Test event 1|3| field1=value1 field2=value2 field3=value3'>>>d=pycef.parse(cef)>>>d{'DeviceVendor':'pycef','DeviceProduct':'python CEF tests','DeviceVersion':'1','DeviceEventClassID':'2','Name':'Test event 1','Severity':'3','CEFVersion':'0','field1':'value1','field2':'value2','field3':'value3'}Parsing a line of CEF from a source with header junk at the front (NOTE: this isn't specific to syslog headers as in the example. The parser just starts wherever 'CEF:0' is found):>>>importpycef>>>cef_syslog='Nov 16 21:24:18 arcsightfwd.davidbianco.io CEF:0|pycef|python CEF tests|1|2|Test event 1|3| field1=value1 field2=value2 field3=value3'>>>d=pycef.parse(cef_syslog)>>>d{'DeviceVendor':'pycef','DeviceProduct':'python CEF tests','DeviceVersion':'1','DeviceEventClassID':'2','Name':'Test event 1','Severity':'3','CEFVersion':'0','field1':'value1','field2':'value2','field3':'value3'}LoggingPycefuses the standard Pythonloggingmodule.  By default, you will not see any logs, but you can easily configure them within your own application.  Here's an example:importlogging# We log with the name 'pycef'logger=logging.getLogger('pycef')# set log level to DEBUG to get the most verbose outputlogger.setLevel(logging.DEBUG)ch=logging.StreamHandler()ch.setLevel(logging.DEBUG)formatter=logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s')ch.setFormatter(formatter)logger.addHandler(ch)# well-formatted CEF data will log the parsed values at DEBUG levelcef='CEF:0|pycef|python CEF tests|1|2|Test event 1|3| field1=value1 field2=value2 field3=value3'd=pycef.parse(cef)2018-11-2308:49:39,827-pycef-DEBUG-Returningvalues:{'DeviceVendor':'pycef','DeviceProduct':'python CEF tests','DeviceVersion':'1','DeviceEventClassID':'2','Name':'Test event 1','Severity':'3','CEFVersion':'0','field1':'value1','field2':'value2','field3':'value3'}# Parse errors in the data will log at WARNING levelpycef.parse('kjlk')2018-11-2308:47:42,853-pycef-WARNING-Couldnotparserecord.IsitvalidCEFformat?
Package: pycefr
pycefrlIdentifying Python3 Code Level Using the CERFL Framework as InspirationWhat is this project about?The goal of pycefrl is to create a tool capable of obtaining an evaluation inspired by the''Common European Framework of Reference for Languages''for code written in the Python programming language, version 3.With this tool it is possible to analyze the level of GitHub repositories (and their developers) or code snippets in Python3.ABSTRACTPython is known to be a versatile language, well suited both for beginners and advanced users. Some elements of the language are easier to understand than others: some are found in any kind of code, while some others are used only by experienced programmers. The use of these elements lead to different ways to code, depending on the experience with the language and the knowledge of its elements, the general programming competence and programming skills, etc. In this paper, we present pycefr, a tool that detects the use of the different elements of the Python language, effectively measuring the level of Python proficiency required to comprehend and deal with a fragment of Python code. Following the well-known Common European Framework of Reference for Languages (CEFR), widely used for natural languages, pycefr categorizes Python code in six levels, depending on the proficiency required to create and understand it. We also discuss different use cases for pycefr: identifying code snippets that can be understood by developers with a certain proficiency, labeling code examples in online resources such as Stackoverflow and GitHub to suit them to a certain level of competency, helping in the onboarding process of new developers in Open Source Software projects, etcUsagePrepare the files as followsRoot folder of your project
└───projects
|   ├───sample directory
|
└───jupyter notebook
└───resultsCurrent APIfrompycefrimportpycerflpycerfl.read_Directory('projects/sample directory','sample directory')It should create a results folder with two filesd.csvd.jsonCitationIf you use pycefr in your research or wish to refer to the examples in this repo, please cite with:@inproceedings{RoblesICPC22,author={Robles, Gregorio and Kula, Raula Gaikovina and Ragkhitwetsagul, Chaiyong and Sakulniwat, Tattiya and Matsumoto, Kenichi and Gonzalez-Barahona, Jesus M.},title={Pycefr: Python Competency Level through Code Analysis},year={2022},isbn={9781450392983},publisher={Association for Computing Machinery},address={New York, NY, USA},url={https://doi.org/10.1145/3524610.3527878},doi={10.1145/3524610.3527878},booktitle={Proceedings of the 30th IEEE/ACM International Conference on Program Comprehension},pages={173–177},numpages={5},location={Virtual Event},series={ICPC '22}}
Package: pycefsharp
pycefsharpInstallusing pippipinstallpycefsharpUsageopen url from clipython-mpycefsharp"http://www.google.com"--title="hey, google!"--icon="[iconFile]"--geometry=[x],[y],[width],[height]use in scriptfrompycefsharp.cefimportCefApp,CefViewCefApp().Run(CefView("https://github.com/eseunghwan/pycefsharp","simple_test"))Licensepycefsharp is MIT licenseRelease HistoryV 0.1.0 [2020/07/23]initial versionV 0.2.0 [2020/07/23]add properties ofurl,title,icon,geometryV 0.2.1 [2020/07/23]make winform object privateform can be invoked by propertiesV 0.2.1.Rev2 [2020/07/23]revoked changes and upgrade to0.2.1.Rev2V 0.2.1.Rev2 [2020/07/23]bug fixedfind install dependencies properlyaddshow,closefunctionsV 0.2.1.Rev3 [2020/07/23]bug fixedwindow moves to center when geometry's x and y are -1 properlyV 0.2.1.Rev4 [2020/07/23]window appears when page is loaded
Package: pycelium-specifications
PurposeThis repository will be published as a package and will contain the interfaces/
specifications and some testing tools that will form the basis of the Pycelium
project. All packages designed to work within the Pycelium project will work
with these interfaces for interoperability, and the testing tools should be used
to verify specification compliance.Installationpipinstallpycelium-specificationsUseEach specification includes a doc string introducing the specification and how
the testing works.Each specification includes a testing tool that can be used by importing the
protocol(s) and thecheck_modulefunction. Thecheck_modulefunction is
called by passing in a dict mapping implementation classes to protocols. For
example:fromsepcifications.somethingimportSomethingProtocol,check_modulefromsomeimplementationimportSomethingClassimportsomeimplementationcheck_module(someimplementation,{SomethingClass:SomethingProtocol})Thecheck_modulefunction runs high-level tests on the module, then it
callscheck_implementationfor each (key, value) pair in the dict parameter,
and this then runs a test suite on the implementation class. Any failures to
meet the specification will be reported.Note that some types of implementation failures will prevent the full test suite
from running, e.g. failure to instantiate.There are two types of specification requirements: must-haves and should-haves.
Any failure to meet a must-have requirement will be reported as anImplementationError. Any detectable failure to meet a should-have requirement
will be reported as anImplementationNote. Not all should-have requirements
can be automatically detected, e.g. lack of documentation or test coverage for
additional features.Current SpecificationsThe following specifications are currently included:merkletree: a specification showing what a Merkle tree should doISC LicenseCopyleft (c) 2023 k98kurzPermission to use, copy, modify, and/or distribute this software
for any purpose with or without fee is hereby granted, provided
that the above copyleft notice and this permission notice appear in
all copies.Exceptions: this permission is not granted to Alphabet/Google, Amazon,
Apple, Microsoft, Netflix, Meta/Facebook, Twitter, or Disney; nor is
permission granted to any company that contracts to supply weapons or
logistics to any national military; nor is permission granted to any
national government or governmental agency; nor is permission granted to
any employees, associates, or affiliates of these designated entities.THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Package: pycelle
pycelleis a Python package for cellular automata.More information and demos: Coming soon!pycellerequiresnumpy1.8+.  Cython is a recommended dependency.To install:pip install Cython
pip install pycelleTo help out with development, do the following instead:git clone https://github.com/ComSciCtr/pycelle.git
cd pycelle
pip install Cython
pip install -e .
Package: pycellfit
Project Descriptionpycellfit: an open-source Python implementation of the CellFIT method of inferring cellular forces developed by Brodland et al.Author: Nilai Vemula, Vanderbilt University (working under Dr. Shane Hutson, Vanderbilt University)Project Goal: To develop an open-source version of CellFIT, a toolkit for inferring tensions along cell membranes and pressures inside cells based on cell geometries and their curvilinear boundaries. (See[1].)Project Timeline: Initial project started in August 2019 with work based off of XJ Xu. This repository was re-made in May 2020 in order to restart repository structure.Project Status:DevelopmentGetting StartedThis project is available onPyPIand can be installed using pip.It recommended that users make avirtual environmentand then install
the package as such:Install from PyPI:pipinstallpycellfitOr compile from source:gitclonehttps://github.com/NilaiVemula/pycellfit.gitcdpycellfitpythonsetup.pyinstallFull documentation for this package can be found onreadthedocs.DependenciesThis project is written in Python and has been tested on Python 3.7 and 3.8 on Linux and Windows. This project
primarily
depends
on numpy,
scipy, matplotlib, and other common python packages common in scientific computing. Additionally,Pillowis required for reading in input image files. A full list of dependencies
is available in therequirements.txtfile. All dependencies should be automatically installed when running pip install.DevelopmentThis project is under active development and not ready for public use. The project is built using Travis CI, and all
tests are run with every commit or merge.FeaturesCurrently, pycellfit supports the following features in the cellular force inference pipeline:[ ] converting raw images into segmented imagesseeSeedWaterSegmenterorneural_net_cell_segmenter(work in progress).[x] read in segmented images[x] convert between watershed and skeleton segmented images[x] identify triple junctions[ ] identify quad junctions[x] generate a mesh[x] fit cell edges to circular arcs[ ] calculate tangent vectors using circle fits, nearest segment, and chord methodscircle fit is incorrect, others have not been added[x] calculate tensions[ ] calculate pressures[x] visualize all of the above stepsExamplesA example walk-through of how to use this module is found inquickstart.Future GoalsThe final implementation of pycellfit will be as a web-app based on the Django framework. (Seepycellfit-web)References[1]Brodland GW, Veldhuis JH, Kim S, Perrone M, Mashburn D, et al. (2014) CellFIT: A Cellular Force-Inference Toolkit Using Curvilinear Cell Boundaries. PLOS ONE 9(6): e99116.https://doi.org/10.1371/journal.pone.0099116
Package: pycellid
PyCellIDFunctions to analyze Cell-ID single-cell cytometry data using python language.MotivationMicroscopy-based cytometry provides a powerful means to study cells with high throughput. Single cell measurements can reveal information hidden in the population. Some commercial software packages, as well as some open source projects, provide tools for working with microscopy images. However, either they do not fit the problem posed by cell-to-cell analysis, or they do not deliver a complete pipeline.Here, we present a set of tools that facilitate inspection and analysis of fluorescence microscopy images based on their segmentation data.We hope to integrate tools for image segmentation in future releases. In that way we would be able to contribute to completing the routine from data sampling to already analyzed samples.RequirementsPython 3.8+Dependecies for this project.attrs(>=21.1.0)for building the backend.matplotlib(>=3.4.0)for plots managementpandas(>=1.3.0)for panel and dashboard management.numpy(>=1.21.0)for numerical management.InstallationPyCellID can be installed usingpipfromPyPI. Usingvirtualenvis recommended -- for no specific reason other than it being good practice. Installing is simple:$> pip install pycellidFor development, clone theofficial github repositoryinstead and use:$ git clone git@github.com:pyCellID/pyCellID.git
    $ cd pyCellID
    $ python3 -m venv venv
    $ source venv/bin/activate
    $ pip install -e .
    $ pip install -r requirements/dev.txtRun the tests with pytest:$ pytest -v tests/Or run the full checks with tox:$ tox -rContactYou can contact us viaemail.IssuesPlease submit bug reports, suggestions for improvements and patches via
theissue tracker.LinksDocumentationExample ApplicationPyPI ReleasesChangelogCreditsWe propose using the open source software Cell-ID for the image segmentation task. We plan to integrate it into our code in the future.The cellID developers (1)(2).Original source can be found at sourceforge (link) and in the original publication (link).You can also visit the official repositoryACL's Yeast Systems Biology Labfor further details.We have got inspiration fromrcell and rcell2.LicenseThis project is licensed under the MIT License (see theLICENSEfile for details).
Package: pycelsiusnetwork
pyCelsiusNetworkUnofficial Python Wrapper for the Celcius Network APISee more onGithubWhat is this?pyCelsiusNetworkis a Python API Wrapper forCelsius Networkpublic API.
This package also offers a short-and-sweet abstraction layer, with functions like depagination of API Results, reversing, and filtering, but the raw JSON response is always one paramether away.RequirementsYou will need:a Omnibus Treasury Partner Token, you can read on how to get onehere.a Celsius Account API Key, you can read on how to generate oneherea computer withPython 3.5+andpipinstalledInstallation$ pip install pycelsiusnetworkUsage and ExamplesDocsAdditional documentation is provided through the__doc__attribute.>> from pycelsiusnetwork import CelsiusNetwork

>> print(CelsiusNetwork.get_deposit_adress_for_coin.__doc__)InitializationfrompycelsiusnetworkimportCelsiusNetworkapi=CelsiusNetwork("PARTNER_TOKEN","USER_API_KEY")### Filtering transactions
You don't neet to set all filtering options, only the ones you want.
> dt_from and dt_to also accepts datetime objects.
>
```python
filtered_transactions = api.get_transactions(dt_from="2020-01-01",
                                             dt_to="2020-05-01",
                                             state="confirmed",
                                             nature="interest",
                                             amount_lower_than=2,
                                             amount_bigger_than=0.1)Silence errorsBy passingsilent=Trueto any function or the API object itself, you can mute package exceptions, A.K.A.AbstractionFailureandCelsiusNetworkHTTPError, by doing so,Nonewill be returned in the presence of an error instead of raising an Exception.api=CelsiusNetwork("PARTNER_TOKEN","USER_API_KEY",silent=True)orapi.get_deposit_adress_for_coin('BTC',silent=True)Also, if you passsilent=Trueto the API initialization, you can override it for any function by passingsilent=Falseto it.api=CelsiusNetwork("PARTNER_TOKEN","USER_API_KEY",silent=True)api.get_deposit_adress_for_coin('BTC',silent=False)Getting the raw responseIf you want to ignore the abstraction layer and get access to that juicy JSON directly, you can passraw=Trueto any function, doing so, will make the function return the full response JSON.api.get_supported_coins(raw=True)ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT
Package: pycent
pycent is a simple module to quickly return the percentage of a value,
or the reverse.Installationpip install pycentUsage>>> from pycent import pycent
>>> pycent.percentage(1,2)
0.5
>>> pycent.percentage(5, 19, 3)
26.316
>>> pycent.percent_of(5, 20)
1.0LicenseMIT LicenseCopyright (c) 2017 LordFlashmeowPermission 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: pycentraldispatch
PyCentralDispatchA Grand Central Dispatch (GCD) inspired API for python. Not optimal, mostly just for convenience.Inspired by Mike Ash'sarticle.InstallInstall the package usingpip.python3 -m pip install pycentraldispatchAPIThe general behavior of this API is inspired by Apple'sGrand Central Dispatch (GCD). The API allows for dispatching
tasks (functions)synchronouslyorasynchronously. There are two flavors of queues:serialandconcurrent.serial- Tasks will be executed one-at-a-time in the order they are queued.concurrent- Tasks may be executed in parallel, but they will be started in the order they are queued.Additionally, the API provides access to aglobalqueue, which is a default singleton concurrent queue that
can be shared across the application.The primary APIs aredispatch_syncanddispatch_async, which dispatch the task onto a queue, either
synchronously or asynchronously. The primary difference is that synchronous tasks do not return until the
task is completed. Asynchronous tasks will be run in the background and return from the dispatch call
immediately.Global queueA shared concurrent queue singleton for access across the application.from pycentraldispatch import PyCentralDispatch

# This same singleton queue can be used anywhere in the application.
global_queue = PyCentralDispatch.global_queue()

def some_function():
  print 'hello'

global_queue.dispatch_sync(some_function)  # Prints "hello"Serial queuesSerial queues do not provide any parallelization. They execute tasks one-at-a-time in the order they were received.from pycentraldispatch import PyCentralDispatch

local_serial_queue = PyCentralDispatch.create_queue(is_serial_queue=True)

def some_function_with_parameters(a, b):
  print a + b
  
local_serial_queue.dispatch_async(some_function_with_parameters, args=(3, 5))  # Prints `8`Concurrent queuesConcurrent queues allow for tasks to execute in parallel. However the tasks are started in the order they were queued.from pycentraldispatch import PyCentralDispatch

local_concurrent_queue = PyCentralDispatch.create_queue()  # Defaults to concurrent queue.

def some_function_with_parameters(a, b=5):
  print a + b

local_concurrent_queue.dispatch_async(some_function_with_parameters, args=(3,), kwargs={'b' : 3})  # Prints `6`
Package: pycentroid
pycentroid@themost-framework for Python@themost-frameworkis a fully-featured end-to-end framework for building scalable data-driven web applications and services under node.js. It consists of a wide set of server-side libraries and client-side tools for helping developers creating scalable and configurable production environments.pycentroidis a@themost-frameworkalternative for python.pycentroid.clientA client-side library of@themost-frameworkapplication for pythonfromtypingimportListfrompycentroid.clientimportClientDataContext,ClientContextOptionsfrompycentroid.queryimportselectasyncdefget_products():context=ClientDataContext(ClientContextOptions('http://localhost:3000/api/'))# get productsitems:List=awaitcontext.model('Products').as_queryable().select(lambdax:select(id=x.id,name=x.name,product_model=x.model,)).where(lambdax:x.category=='Laptops').get_items()returnitemsRead more atpycentroid.clientpycentroid.queryA database-agnostic query module which for writing SQL expressions of any kindfrompycentroid.queryimportQueryExpression,QueryEntity,SqlFormatter,selectproducts=QueryEntity('ProductData')query=QueryExpression(products).select(lambdax:select(id=x.id,name=x.name,price=round(x.price,2))).where(lambdax:round(x.price,2)<800andx.category=='Laptops')sql=SqlFormatter().format(query)# sql > SELECT id,name,ROUND(price,2) AS price FROM ProductData WHERE ((ROUND(price,2)<800) AND (category='Laptops'))pycentroid.dataA next-generation ORM data module for developing data-driven application and services.frompycentroid.data.applicationimportDataApplicationfromos.pathimportabspath,join,dirnameAPP_PATH=abspath(join(dirname(__file__),'..'))asyncdefmain():app=DataApplication(cwd=APP_PATH)context=app.create_context()results=awaitcontext.model('Order').where(lambdax:x.orderedItem.category=='Desktops').get_items()print(results)
Package: pycentroids
centroidsBuild StatusBuild TypeResultPython Linux BuildsCXX Lib Linux BuildsDocumentation BuildIntroductionRoutines for performing single photon counting and centroiding of CCD dataDocumentationThe documentation can be foundonline.Changesv0.1.11Fixed bug in standard error for 2D fits calculations. Incorrect number of data points was used.Added range option to fitting parameters forsigmaandpositionModified CI to report tests and coverageImproved unit tests to cover parameter range selectionAdded debug output to unit testsUpdated docs